Come utilizzare il metodo toString in Java?

Qualcuno può spiegarmi il concetto di toString()metodo, definito in Objectclasse? Come viene utilizzato e qual è il suo scopo?

Dai Object.toStringdocumenti:

Restituisce una rappresentazione di stringa dell'oggetto. In generale, il toString metodo restituisce una stringa che "rappresenta testualmente" questo oggetto. Il risultato dovrebbe essere una rappresentazione concisa ma informativa facile da leggere per una persona. Si raccomanda che tutte le sottoclassi sovrascrivano questo metodo.

Il toStringmetodo per class Object restituisce una stringa composta dal nome della classe di cui l'oggetto è un'istanza, il carattere del segno "@" e la rappresentazione esadecimale senza segno del codice hash 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

Utilizzo di String.toString:

Ogni volta che hai bisogno di esplorare il costruttore chiamato valore nel Stringmodulo, puoi semplicemente usare 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 nel tuo Eclipse ed eseguilo ... otterrai le idee su String.toString...

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

L'override del metodo è sempre una buona idea, soprattutto quando si tratta di debug, perché i debugger spesso mostrano gli oggetti in base al risultato del toString()metodo. 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ò opzionalmente avere usi nel contesto di un'applicazione, ma molto più spesso viene utilizzato per scopi di debug. Ad esempio, quando si raggiunge un punto di interruzione in un IDE, è molto più facile leggere un significativo toString()di oggetti che ispezionarne i membri.

Non ci sono requisiti fissi per ciò toString()che dovrebbe fare un metodo. Per convenzione, molto spesso ti dirà il nome della classe e il valore dei membri dei dati pertinenti. Il più delle volte, i toString()metodi vengono generati automaticamente negli IDE.

Affidarsi a un particolare output di un toString()metodo o analizzarlo all'interno di un programma è una cattiva idea. Qualunque cosa tu faccia, non seguire quella strada.

toString () restituisce una rappresentazione stringa / 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 invocato 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 composta dal nome della classe di questo oggetto seguito dal segno @ e dalla rappresentazione esadecimale senza segno del codice hash di questo oggetto 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 - Coordinates@addbf1 //concise, but not really useful to the reader

Ora, sovrascrivendo toString () nella classe Coordinates come di seguito,

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

risultati in

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

L'utilità di sovrascrivere 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<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}

Pochi suggerimenti sull'implementazione,

1. Dovresti quasi sempre sovrascrivere il metodo toString (). Uno dei casi in cui l'override non sarebbe richiesto sono le classi di utilità che raggruppano metodi di utilità statici, alla maniera di java.util.Math . Il caso in cui l'override non sia richiesto è piuttosto intuitivo; quasi sempre lo sapresti.
2. La stringa restituita dovrebbe essere concisa e informativa, idealmente autoesplicativa.
3. Almeno, i campi usati per stabilire l'equivalenza tra due oggetti differenti, cioè i campi usati nell'implementazione del metodo equals () , dovrebbero essere sputati dal metodo toString ().

4. Fornire funzioni di accesso / getter per tutti i campi dell'istanza contenuti nella stringa restituita. Ad esempio, nella classe Coordinates,

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

Una copertura completa del metodo toString () si trova nell'elemento 10 del libro, Effective Java ™, seconda edizione, di Josh Bloch.

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;
    }
}

Produzione:

[Steve 12 Daniel, Sachin 10 Tendulkar]

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

Se non sei abituato a String () nella classe Pojo (Student.java), otterrai un output come [com.steve.test.Student@6e1408, com.steve.test.Student@e53108]. Per evitare questo tipo di problema, stiamo usando il metodo toString ().

Ogni volta che accedi a un oggetto (che non è una stringa) in un contesto String, toString () viene chiamato sotto le coperte dal compilatore.

Ecco perché

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

funziona, e sovrascrivendo lo standard toString () da Object nelle tue classi, puoi rendere i tuoi oggetti utili anche in contesti String.

(e consideralo una scatola nera! Mai, mai usare il contenuto per nient'altro che presentarlo a un essere umano)

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

A parte ciò che cletus ha risposto riguardo al debug, viene utilizzato ogni volta che si esegue l'output di un oggetto, come quando si utilizza

 System.out.println(myObject);

o

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

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

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

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

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