Comment utiliser la méthode toString en Java?

Quelqu'un peut-il m'expliquer le concept de la toString()méthode, défini dans la Objectclasse? Comment est-il utilisé et quel est son objectif?

À partir de la Object.toStringdocumentation:

Renvoie une représentation sous forme de chaîne de l'objet. En général, la toString méthode renvoie une chaîne qui "représente textuellement" cet objet. Le résultat doit être une représentation concise mais informative, facile à lire pour une personne. Il est recommandé que toutes les sous-classes remplacent cette méthode.

La toStringméthode pour la classe Object renvoie une chaîne composée du nom de la classe dont l'objet est une instance, du caractère at-sign `` @ '' et de la représentation hexadécimale non signée du code de hachage de l'objet. En d'autres termes, cette méthode renvoie une chaîne égale à la valeur de:

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

Exemple:

String[] mystr ={"a","b","c"};
System.out.println("mystr.toString: " + mystr.toString());

output:- mystr.toString: [Ljava.lang.String;@13aaa14a

Utilisation du String.toString:

Chaque fois que vous avez besoin d'explorer le constructeur appelé value dans le Stringformulaire, vous pouvez simplement utiliser String.toString... pour un exemple ...

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

}

... copiez ce programme dans votre Eclipse, et exécutez-le ... vous aurez les idées sur String.toString...

La toString()méthode renvoie une représentation textuelle d'un objet. Une implémentation de base est déjà incluse dans java.lang.Objectet donc, parce que tous les objets en héritent, java.lang.Objectil est garanti que chaque objet en Java a cette méthode.

Le remplacement de la méthode est toujours une bonne idée, en particulier en ce qui concerne le débogage, car les débogueurs affichent souvent les objets par le résultat de la toString()méthode. Utilisez donc une implémentation significative, mais utilisez-la à des fins techniques . La logique de l'application doit utiliser des getters:

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()+"]";
  }
}

Il peut éventuellement avoir des utilisations dans le contexte d'une application, mais il est beaucoup plus souvent utilisé à des fins de débogage. Par exemple, lorsque vous atteignez un point d'arrêt dans un IDE, il est beaucoup plus facile de lire un objet significatif toString()que d'inspecter leurs membres.

Il n'y a pas d'exigence fixe pour ce qu'une toString()méthode doit faire. Par convention, le plus souvent, il vous indiquera le nom de la classe et la valeur des données membres pertinentes. Le plus souvent, les toString()méthodes sont générées automatiquement dans les IDE.

Se fier à une sortie particulière d'une toString()méthode ou l'analyser dans un programme est une mauvaise idée. Quoi que vous fassiez, ne suivez pas cette voie.

toString () renvoie une chaîne / représentation textuelle de l'objet. Couramment utilisée à des fins de diagnostic comme le débogage, la journalisation, etc., la méthode toString () est utilisée pour lire des détails significatifs sur l'objet.

Il est automatiquement appelé lorsque l'objet est passé à println, print, printf, String.format (), assert ou à l'opérateur de concaténation de chaînes.

L'implémentation par défaut de toString () dans la classe Object renvoie une chaîne composée du nom de classe de cet objet suivi du signe @ et de la représentation hexadécimale non signée du code de hachage de cet objet en utilisant la logique suivante,

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

Par exemple, ce qui suit

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

impressions

Bourne's current location - Coordinates@addbf1 //concise, but not really useful to the reader

Maintenant, en remplaçant toString () dans la classe Coordinates comme ci-dessous,

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

résulte en

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

L'utilité de remplacer toString () devient encore plus lorsque la méthode est appelée sur des collections contenant des références à ces objets. Par exemple, ce qui suit

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

impressions

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

au lieu de cela,

{James Bond=Coordinates@addbf1, Jason Bourne=Coordinates@42e816}

Peu de pointeurs d'implémentation,

1. Vous devriez presque toujours remplacer la méthode toString (). L'un des cas où le remplacement ne serait pas nécessaire est celui des classes utilitaires qui regroupent des méthodes utilitaires statiques, à la manière de java.util.Math . Le cas où le remplacement n'est pas nécessaire est assez intuitif; vous le sauriez presque toujours.
2. La chaîne renvoyée doit être concise et informative, idéalement explicite.
3. Au moins, les champs utilisés pour établir l'équivalence entre deux objets différents, c'est-à-dire les champs utilisés dans l' implémentation de la méthode equals () , doivent être crachés par la méthode toString ().

4. Fournissez des accesseurs / récupérateurs pour tous les champs d'instance contenus dans la chaîne retournée. Par exemple, dans la classe Coordinates,

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

Une couverture complète de la méthode toString () se trouve dans l'élément 10 du livre, Effective Java ™, deuxième édition, par Josh Bloch.

Codage:

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

Production:

[Steve 12 Daniel, Sachin 10 Tendulkar]

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

Si vous n'êtes pas habitué à toString () dans la classe Pojo (Student.java), vous obtiendrez une sortie du type [com.steve.test.Student@6e1408, com.steve.test.Student@e53108]. Pour éviter ce genre de problème, nous utilisons la méthode toString ().

Chaque fois que vous accédez à un objet (qui n'est pas une chaîne) dans un contexte de chaîne, le toString () est appelé sous les couvertures par le compilateur.

C'est pourquoi

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

fonctionne, et en remplaçant le toString () standard d'Object dans vos propres classes, vous pouvez également rendre vos objets utiles dans les contextes String.

(et considérez cela comme une boîte noire! N'utilisez jamais le contenu à autre chose que de le présenter à un humain)

La méthode toString correctement remplacée peut aider à la journalisation et au débogage de Java.

En dehors de ce que cletus a répondu en ce qui concerne le débogage, il est utilisé chaque fois que vous sortez un objet, comme lorsque vous utilisez

 System.out.println(myObject);

ou

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

L'objectif principal de toString est de générer une représentation String d'un objet, ce qui signifie que la valeur de retour est toujours une String. Dans la plupart des cas, il s'agit simplement de la classe et du nom du package de l'objet, mais dans certains cas comme StringBuilder, vous obtiendrez en fait un String-text.

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

Si vous apprenez d'abord Python, puis Java. Je pense qu'elle joue le même rôle que la __str__()méthode en Python, c'est une méthode magique comme __dict__()et __init__()mais pour faire référence à une chaîne représentant l'objet.

le toString()convertit l'objet spécifié à une valeur de chaîne.