Come usare il metodo toString in Java?

Qualcuno può spiegarmi il concetto del metodo toString() , definito nella class Object ? Come viene utilizzato e qual è il suo scopo?

Dai documenti Object.toString () :

Restituisce una rappresentazione in formato stringa dell’object. In generale, il metodo toString restituisce una stringa che “rappresenta testualmente” questo object. Il risultato dovrebbe essere una rappresentazione concisa ma informativa che sia facile da leggere per una persona. Si raccomanda che tutte le sottoclassi superino questo metodo.

Il metodo toString per l’object class restituisce una stringa composta dal nome della class di cui l’object è un’istanza, il carattere at-sign `@ ‘e la rappresentazione esadecimale senza firma del codice hash dell’object. In altre parole, questo metodo restituisce una stringa uguale al valore di:

 getClass().getName() + '@' + Integer.toHexString(hashCode()) 

Esempio:

 String[] mystr ={"a","b","c"}; System.out.println("mystr.toString: " + mystr.toString()); output:- mystr.toString: [Ljava.lang.String;@13aaa14a 

Uso di String toString: ogni volta che è necessario esplorare il costruttore chiamato value nel modulo String, è sufficiente utilizzare String toString … per un esempio …

 package pack1; import java.util.*; class Bank { String n; String add; int an; int bal; int dep; public Bank(String n, String add, int an, int bal) { this.add = add; this.bal = bal; this.an = an; this.n = n; } public String toString() { return "Name of the customer.:" + this.n + ",, " + "Address of the customer.:" + this.add + ",, " + "A/c no..:" + this.an + ",, " + "Balance in A/c..:" + this.bal; } } public class Demo2 { public static void main(String[] args) { List l = new LinkedList(); Bank b1 = new Bank("naseem1", "Darbhanga,bihar", 123, 1000); Bank b2 = new Bank("naseem2", "patna,bihar", 124, 1500); Bank b3 = new Bank("naseem3", "madhubani,bihar", 125, 1600); Bank b4 = new Bank("naseem4", "samastipur,bihar", 126, 1700); Bank b5 = new Bank("naseem5", "muzafferpur,bihar", 127, 1800); l.add(b1); l.add(b2); l.add(b3); l.add(b4); l.add(b5); Iterator i = l.iterator(); while (i.hasNext()) { System.out.println(i.next()); } } } 

… copia questo programma in eclipse ed eseguilo … otterrai le idee su String toString …

Il metodo toString() restituisce una rappresentazione testuale di un object. Un’implementazione di base è già inclusa in java.lang.Object e quindi poiché tutti gli oggetti ereditano da java.lang.Object è garantito che ogni object in Java ha questo metodo.

Sovrascrivere il metodo è sempre una buona idea, soprattutto quando si tratta di eseguire il debug, poiché i programmi di debug mostrano spesso oggetti in base al risultato del metodo toString() . Quindi usa un’implementazione significativa ma usala per scopi tecnici . La logica dell’applicazione dovrebbe utilizzare i getter:

 public class Contact { private String firstName; private String lastName; public Contact (String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } public String getFirstName() {return firstName;} public String getLastName() {return lastName;} public String getContact() { return firstName + " " + lastName; } @Override public String toString() { return "["+getContact()+"]"; } } 

Può facoltativamente avere usi nel contesto di un’applicazione, ma molto più spesso è usato per scopi di debug. Ad esempio, quando si preme un punto di interruzione in un IDE, è molto più semplice leggere un toString() significativo di oggetti piuttosto che ispezionare i propri membri.

Non esiste un requisito toString() per ciò che dovrebbe fare un metodo toString() . Per convenzione, molto spesso ti dirà il nome della class e il valore dei membri dei dati pertinenti. Più spesso, i metodi toString() vengono generati automaticamente negli IDE.

Affidarsi a un particolare output di un metodo toString() o analizzarlo all’interno di un programma è una ctriggers idea. Qualunque cosa tu faccia, non andare giù per quella strada.

toString () restituisce una stringa / rappresentazione testuale dell’object. Comunemente utilizzato per scopi diagnostici come il debug, la registrazione ecc., Il metodo toString () viene utilizzato per leggere dettagli significativi sull’object.

Viene automaticamente richiamato quando l’object viene passato a println, print, printf, String.format (), assert o all’operatore di concatenazione di stringhe.

L’implementazione predefinita di toString () nella class Object restituisce una stringa composta dal nome della class di questo object seguito dal segno @ e dalla rappresentazione esadecimale senza firma del codice hash di questo object utilizzando la seguente logica,

 getClass().getName() + "@" + Integer.toHexString(hashCode()) 

Ad esempio, il seguente

 public final class Coordinates { private final double x; private final double y; public Coordinates(double x, double y) { this.x = x; this.y = y; } public static void main(String[] args) { Coordinates coordinates = new Coordinates(1, 2); System.out.println("Bourne's current location - " + coordinates); } } 

stampe

 Bourne's current location - [email protected] //concise, but not really useful to the reader 

Ora, sovrascrivendo toString () nella class Coordinates come sotto,

 @Override public String toString() { return "(" + x + ", " + y + ")"; } 

risultati in

 Bourne's current location - (1.0, 2.0) //concise and informative 

L’utilità di eseguire l’override di toString () diventa ancora maggiore quando il metodo viene invocato su raccolte contenenti riferimenti a questi oggetti. Ad esempio, il seguente

 public static void main(String[] args) { Coordinates bourneLocation = new Coordinates(90, 0); Coordinates bondLocation = new Coordinates(45, 90); Map locations = new HashMap(); locations.put("Jason Bourne", bourneLocation); locations.put("James Bond", bondLocation); System.out.println(locations); } 

stampe

 {James Bond=(45.0, 90.0), Jason Bourne=(90.0, 0.0)} 

Invece di questo,

 {James [email protected], Jason [email protected]} 

Pochi indicatori di implementazione,

  1. Dovresti quasi sempre sovrascrivere il metodo toString (). Uno dei casi in cui l’override non sarebbe richiesto sono classi di utilità che raggruppano metodi di utilità statica, alla maniera di java.util.Math . Il caso di override non richiesto è abbastanza intuitivo; quasi sempre lo sapresti.
  2. La stringa restituita dovrebbe essere concisa e informativa, idealmente auto-esplicativa.
  3. Almeno, i campi utilizzati per stabilire l’equivalenza tra due oggetti diversi, vale a dire i campi utilizzati nell’implementazione del metodo equals () , dovrebbero essere sputati dal metodo toString ().
  4. Fornire accessor / getter per tutti i campi di istanza contenuti nella stringa restituita. Ad esempio, nella class Coordinates,

     public double getX() { return x; } public double getY() { return y; } 

Una copertura completa del metodo toString () si trova nell’articolo 10 del libro, Effective Java ™, Second Edition, di Josh Bloch.

Ogni volta che si accede ad un object (non essendo una stringa) in un contesto di stringa, allora il toString () viene chiamato sotto le copertine dal compilatore.

Ecco perché

 Map map = new HashMap(); System.out.println("map=" + map); 

funziona e sovrascrivendo lo standard toString () da Object nelle proprie classi, è ansible rendere gli oggetti utili anche in contesti String.

(e consideralo una scatola nera! Non usare mai il contenuto per nient’altro che presentarlo a un umano)

Coding:

 public class Test { public static void main(String args[]) { ArrayList a = new ArrayList(); a.add(new Student("Steve", 12, "Daniel")); a.add(new Student("Sachin", 10, "Tendulkar")); System.out.println(a); display(a); } static void display(ArrayList stu) { stu.add(new Student("Yuvi", 12, "Bhajji")); System.out.println(stu); } } 

Student.java:

 public class Student { public String name; public int id; public String email; Student() { } Student(String name, int id, String email) { this.name = name; this.id = id; this.email = email; } public String toString(){ //using these toString to avoid the output like this [[email protected], [email protected]] return name+" "+id+" "+email; } public String getName(){ return name; } public void setName(String name){ this.name=name; } public int getId(){ return id; } public void setId(int id){ this.id=id; } public String getEmail(){ return email; } public void setEmail(String email){ this.email=email; } } 

Produzione:

[Steve 12 Daniel, Sachin 10 Tendulkar]

[Steve 12 Daniel, Sachin 10 Tendulkar, Yuvi 12 Bhajji]

Se non si è utilizzati toString () nella class Pojo (Student.java), si otterrà un output come [[email protected], [email protected]] . Per evitare questo tipo di problema stiamo usando il metodo toString ().

Il metodo toString correttamente sostituito può aiutare nella registrazione e nel debug di Java.

A prescindere da ciò che il cletus ha risposto riguardo al debug, viene utilizzato ogni volta che generi un object, come quando lo usi

  System.out.println(myObject); 

o

 System.out.println("text " + myObject); 

Lo scopo principale di toString è generare una rappresentazione String di un object, il valore restituito è sempre una stringa. Nella maggior parte dei casi questo è semplicemente la class dell’object e il nome del pacchetto, ma in alcuni casi, come StringBuilder, si otterrà effettivamente un testo String.

Se impari prima Python e poi Java. Penso che giochi lo stesso ruolo del metodo __str__() in Python, è un metodo magico come __dict__() e __init__() ma fare riferimento a una stringa che rappresenta l’object.

toString() converte l’object specificato in un valore stringa.

 /** * This toString-Method works for every Class, where you want to display all the fields and its values */ public String toString() { StringBuffer sb = new StringBuffer(); Field[] fields = getClass().getDeclaredFields(); //Get all fields incl. private ones for (Field field : fields){ try { field.setAccessible(true); String key=field.getName(); String value; try{ value = (String) field.get(this); } catch (ClassCastException e){ value=""; } sb.append(key).append(": ").append(value).append("\n"); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (SecurityException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } return sb.toString(); }