¿Cómo usar el método toString en Java?

¿Alguien puede explicarme el concepto del toString()método, definido en la Objectclase? ¿Cómo se usa y cuál es su propósito?

De los Object.toStringdocumentos:

Devuelve una representación de cadena del objeto. En general, el toString método devuelve una cadena que "representa textualmente" este objeto. El resultado debe ser una representación concisa pero informativa que sea fácil de leer para una persona. Se recomienda que todas las subclases anulen este método.

El toStringmétodo de clase Object devuelve una cadena que consta del nombre de la clase de la que el objeto es una instancia, el carácter de signo de arroba "@" y la representación hexadecimal sin signo del código hash del objeto. En otras palabras, este método devuelve una cadena igual al valor de:

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

Ejemplo:

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

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

Uso de String.toString:

Siempre que necesite explorar el constructor llamado valor en el Stringformulario, simplemente puede usar String.toString... por ejemplo ...

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 este programa en tu Eclipse y ejecútalo ... obtendrás las ideas sobre String.toString...

El toString()método devuelve una representación textual de un objeto. Ya se incluye una implementación básica java.lang.Objecty, debido a que todos los objetos heredados de java.lang.Objectella, se garantiza que todos los objetos en Java tienen este método.

Anular el método siempre es una buena idea, especialmente cuando se trata de depurar, porque los depuradores a menudo muestran objetos por el resultado del toString()método. Por lo tanto, use una implementación significativa, pero úsela con fines técnicos . La lógica de la aplicación debe usar 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()+"]";
  }
}

Opcionalmente, puede tener usos dentro del contexto de una aplicación, pero con mucha más frecuencia se usa con fines de depuración. Por ejemplo, cuando llega a un punto de interrupción en un IDE, es mucho más fácil leer una cantidad significativa toString()de objetos que inspeccionar sus miembros.

No hay un requisito establecido sobre lo toString()que debe hacer un método. Por convención, la mayoría de las veces le indicará el nombre de la clase y el valor de los miembros de datos pertinentes. La mayoría de las veces, los toString()métodos se generan automáticamente en IDE.

Depender de una salida particular de un toString()método o analizarla dentro de un programa es una mala idea. Hagas lo que hagas, no sigas ese camino.

toString () devuelve una cadena / representación textual del objeto. El método toString (), que se utiliza comúnmente para fines de diagnóstico como depuración, registro, etc., se utiliza para leer detalles significativos sobre el objeto.

Se invoca automáticamente cuando el objeto se pasa a println, print, printf, String.format (), assert o el operador de concatenación de cadenas.

La implementación predeterminada de toString () en la clase Object devuelve una cadena que consta del nombre de clase de este objeto seguido del signo @ y la representación hexadecimal sin firmar del código hash de este objeto utilizando la siguiente lógica,

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

Por ejemplo, lo siguiente

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

huellas dactilares

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

Ahora, anulando toString () en la clase Coordenadas como se muestra a continuación,

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

resultados en

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

La utilidad de anular toString () se vuelve aún mayor cuando el método se invoca en colecciones que contienen referencias a estos objetos. Por ejemplo, lo siguiente

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

huellas dactilares

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

en lugar de esto,

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

Pocos consejos de implementación,

1. Casi siempre debería anular el método toString (). Uno de los casos en los que no se requeriría la anulación son las clases de utilidad que agrupan métodos de utilidad estáticos, a la manera de java.util.Math . El caso de que no se requiera anular es bastante intuitivo; casi siempre lo sabrías.
2. La cadena devuelta debe ser concisa e informativa, idealmente autoexplicativa.
3. Al menos, los campos utilizados para establecer la equivalencia entre dos objetos diferentes, es decir, los campos utilizados en la implementación del método equals () deben ser escupidos por el método toString ().

4. Proporcione descriptores de acceso / captadores para todos los campos de instancia contenidos en la cadena devuelta. Por ejemplo, en la clase Coordenadas,

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

En el artículo 10 del libro, Effective Java ™, Second Edition, de Josh Bloch, se incluye una cobertura completa del método toString ().

Codificación:

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

    }

}

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

Salida:

[Steve 12 Daniel, Sachin 10 Tendulkar]

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

Si no está acostumbrado a toString () en la clase Pojo (Student.java), obtendrá un resultado como [com.steve.test.Student@6e1408, com.steve.test.Student@e53108]. Para evitar este tipo de problema, estamos usando el método toString ().

Siempre que acceda a un objeto (que no sea una cadena) en un contexto de cadena, el compilador invoca a toString () oculto.

Esta es la razón por

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

funciona, y al anular el estándar toString () de Object en sus propias clases, puede hacer que sus objetos también sean útiles en contextos de String.

(¡y considérelo una caja negra! Nunca, nunca use el contenido para otra cosa que no sea presentarle a un humano)

El método toString correctamente anulado puede ayudar en el registro y la depuración de Java.

Aparte de lo que Cletus respondió con respecto a la depuración, se usa cada vez que genera un objeto, como cuando usa

 System.out.println(myObject);

o

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

El propósito principal de toString es generar una representación de cadena de un objeto, lo que significa que el valor de retorno es siempre una cadena. En la mayoría de los casos, esto es simplemente la clase del objeto y el nombre del paquete, pero en algunos casos como StringBuilder, en realidad obtendrá 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 aprendes Python primero y luego Java. Creo que juega el mismo papel que el __str__()método en Python, es un método mágico como __dict__()y, __init__()pero para referirse a una cadena que representa el objeto.

la toString()convierte el objeto especificado en un valor de cadena.