Come utilizzare il metodo toString in Java?

Question

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

Answer 1

Dalle Object.toString() documentazione:

Restituisce una rappresentazione in formato stringa dell'oggetto . In generale, il metodo toString restituisce una stringa che " " rappresenta testualmente "questo oggetto. Il risultato dovrebbe essere una rappresentazione informativa concisa ma che sia facile da leggere per una persona. È consigliato che tutte le sottoclassi sostituiscano questo metodo.

Il metodo toString per la classe Object restituisce una stringa costituita dal nome della classe di cui l'oggetto è un'istanza, il carattere a-segno `@', e la non firmato rappresentazione esadecimale dell'hash codice dell'oggetto . 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 

Answer 2

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

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

Fare affidamento su un'uscita specifica da un metodo toString() o analizzarlo in un programma è una cattiva idea. Qualunque cosa tu faccia, non andare giù per quella strada.

Answer 3

parte quanto Cletus ha risposto per quanto riguarda il debug, è usato ogni volta che si uscita di un oggetto, come quando si utilizza

System.out.println(myObject); 

o

Answer 4

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

Answer 5

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

Questo è il motivo per cui

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

opere, e sovrascrivendo il toString standard() da un oggetto a proprie classi, è possibile rendere i vostri oggetti utili in contesti stringa troppo.

(e lo considerano una scatola nera! Mai, mai utilizzare i contenuti per altro che presentare a un essere umano)

Answer 6

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

L'override del 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 utilizzare un'implementazione significativa ma utilizzarla per gli scopi tecnici. La logica applicazione dovrebbe utilizzare 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()+"]"; 
    } 
} 

Answer 7

il toString() converte l'oggetto specificato un valore di stringa.

Answer 8

uso del toString String: ogni volta che si richiede di esplorare il costruttore chiamato valore nella forma di stringa, si può semplicemente 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<Bank> l = new LinkedList<Bank>(); 

     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<Bank> i = l.iterator(); 
     while (i.hasNext()) { 
      System.out.println(i.next()); 
     } 
    } 

} 

.. Copia questo programma in Eclipse ed eseguilo ... otterrai le idee su String toString ...

Answer 9

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

Answer 10

/** 
* 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(); 
} 

Answer 11

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

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

L'implementazione predefinita di toString() nella classe Object restituisce una stringa costituita dal nome della classe di questo oggetto seguito da @ segno e la rappresentazione esadecimale senza segno del codice hash di questo oggetto utilizzando la seguente logica,

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

Ad esempio, i seguenti

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 - Coordinates@addbf1 //concise, but not really useful to the reader 

Ora, sovrascrivendo toString() nella classe coordinate 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 rilevante toString() diventa ancora di più quando viene richiamato il metodo su collezioni che contengono 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<String, Coordinates> locations = new HashMap<String, Coordinates>(); 
    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 Bond=Coordinates@addbf1, Jason Bourne=Coordinates@42e816} 

puntatori implementazione Poche,

1. Si dovrebbe quasi sempre eseguire l'override del metodo toString () metodo. Uno dei casi in cui non è necessario eseguire l'override è classi di utilità che raggruppano i metodi di utilità statica, nella maniera di java.util.Math. Il caso di override non richiesto è abbastanza intuitivo; quasi sempre lo sapresti.
2. La stringa restituita deve essere concisa e informativa, idealmente auto-esplicativa.
3. Almeno, i campi utilizzati per stabilire l'equivalenza tra due diversi oggetti, vale a dire i campi utilizzati nell'implementazione del metodo equals() devono essere sputati dal metodo toString().

4. Fornire accessors/getter per tutti i campi di istanza contenuti nella stringa restituita. Per esempio, nella classe coordinate,

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

una copertura completa del metodo toString() è al punto 10 del libro, Effective Java ™, Second Edition, da Josh Bloch.

Answer 12

Coding:

public class Test { 

    public static void main(String args[]) { 

     ArrayList<Student> a = new ArrayList<Student>(); 
     a.add(new Student("Steve", 12, "Daniel")); 
     a.add(new Student("Sachin", 10, "Tendulkar")); 

     System.out.println(a); 

     display(a); 

    } 

    static void display(ArrayList<Student> 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 [com.steve.test.Student@6e1408, com.steve.test.Student@e53108] 
      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; 
    } 
} 

uscita:

[Steve 12 Daniel, Sachin Tendulkar 10]

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

Se non siete abituati toString() in Pojo (Student.java) di classe, si otterrà un output come [com.steve.test.Student@6e1408, com.steve.test.Student@e53108] Per evitare i questo tipo di problema stiamo usando il metodo toString().

Answer 13

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