ti-enxame.com

Como usar o método toString em Java?

Alguém pode me explicar o conceito do método toString(), definido na classe Object? Como é usado e qual é o seu propósito?

106
David Brown

Do Object.toString () docs:

Retorna uma representação de string do objeto. Em geral, o método toString Retorna uma string que "Representa textualmente" esse objeto. O resultado deve ser uma representação informativa concisa, mas Que seja fácil para uma pessoa ler. É Recomendado que todas as subclasses Anulem este método. 

O método toString para a classe Object Retorna uma string que consiste no nome Da classe da qual o objeto É uma instância, o caractere arroba ` @ ', e a representação hexadecimal não assinada do código hash do objeto . Em outras palavras, esse método Retorna uma string igual ao valor De:

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

Exemplo:

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

output:- mystr.toString: [Ljava.lang.String;@13aaa14a
81
Sean Patrick Floyd

Uso da String toString: Sempre que você precisar explorar o construtor chamado value no formulário String, você pode simplesmente usar String toString ... Para um exemplo ...

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

}

... copie este programa em seu Eclipse, e execute-o ... você terá as idéias sobre String toString ...

38
Naseem Afzal

O método toString() retorna um textual representação de um objeto. Uma implementação básica já está incluída em Java.lang.Object e, assim, como todos os objetos são herdados de Java.lang.Object, é garantido que todos os objetos em Java tenham esse método.

Substituir o método é sempre uma boa idéia, especialmente quando se trata de depuração, porque os depuradores geralmente mostram objetos pelo resultado do método toString(). Portanto, use uma implementação significativa, mas use-a para technical purposes. A lógica do aplicativo deve 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()+"]";
  }
}
32
Andreas_D

Ele pode, opcionalmente, ter usos dentro do contexto de um aplicativo, mas com muito mais frequência é usado para fins de depuração. Por exemplo, quando você atinge um ponto de interrupção em um IDE, é muito mais fácil ler uma toString() significativa de objetos do que inspecionar seus membros.

Não há nenhum requisito definido para o que um método toString() deve fazer. Por convenção, na maioria das vezes, ele informará o nome da classe e o valor dos membros de dados pertinentes. Mais frequentemente, os métodos toString() são gerados automaticamente em IDEs.

Confiar na saída particular de um método toString() ou analisá-lo dentro de um programa é uma má ideia. Faça o que fizer, não vá por esse caminho.

14
cletus

toString () retorna uma string/representação textual do objeto. Comumente usado para fins de diagnóstico, como depuração, criação de log, etc., o método toString () é usado para ler detalhes significativos sobre o objeto.

É invocado automaticamente quando o objeto é passado para println, print, printf, String.format (), assert ou o operador de concatenação de strings.

A implementação padrão de toString () na classe Object retorna uma string que consiste no nome da classe deste objeto seguido por @ sign e a representação hexadecimal não assinada do código hash deste objeto usando a seguinte lógica,

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

Por exemplo, o seguinte

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

impressões

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

Agora, substituindo toString () na classe Coordenadas como abaixo,

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

resulta em

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

A utilidade de sobrescrever toString () torna-se ainda mais quando o método é invocado em coleções contendo referências a esses objetos. Por exemplo, o seguinte

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

impressões

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

em vez disso,

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

Poucos indicadores de implementação,

  1. Você deve quase sempre substituir o método toString (). Um dos casos em que a substituição não seria necessária são classes de utilitário que agrupam métodos de utilitário estáticos, na forma de Java.util.Math . O caso da substituição não ser necessária é bastante intuitivo; quase sempre você saberia.
  2. A string retornada deve ser concisa e informativa, idealmente auto-explicativa.
  3. Pelo menos, os campos usados ​​para estabelecer a equivalência entre dois objetos diferentes, ou seja, os campos usados ​​na implementação de equals () devem ser cuspidos pelo método toString ().
  4. Forneça acessadores/getters para todos os campos de instância contidos na string retornada. Por exemplo, na classe Coordenadas,

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

Uma cobertura abrangente do método toString () está no Item 10 do livro Effective Java ™, Second Edition, de Josh Bloch.

12
sxnamit

Sempre que você acessa um objeto (não sendo um String) em um contexto String, o toString () é chamado sob as capas pelo compilador.

Isso é por que

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

funciona, e substituindo o padrão toString () do objeto em suas próprias classes, você pode tornar seus objetos úteis em contextos String também.

(e considere isso uma caixa preta! Nunca, nunca use o conteúdo para qualquer outra coisa além de apresentar a um humano)

5
Thorbjørn Ravn Andersen

Codificação:  

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

Saída:

[Steve 12 Daniel, Sachin 10 Tendulkar]

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

Se você não estiver acostumado toString () na classe Pojo (Student.Java), você obterá uma saída como [[email protected], [email protected]].Para evitar esse tipo de problema, estamos usando o método toString ().

5
Stephen

O método toString substituído corretamente pode ajudar no registro e depuração do Java.

4
USM167

Além do que o cletus respondeu em relação à depuração, ele é usado sempre que você gera um objeto, como quando você usa

 System.out.println(myObject);

ou

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

O principal objetivo do toString é gerar uma representação de String de um objeto, o valor de retorno é sempre uma String. Na maioria dos casos, isso é simplesmente a classe e o nome do pacote do objeto, mas em alguns casos, como o StringBuilder, você terá um String-text.

2
heb

Se você aprende Python primeiro e depois Java. Eu acho que ele desempenha o mesmo papel que o método __str__() no Python, é um método magic like __dict__() e __init__() mas para se referir a uma string representando o objeto. 

1
lerner

o toString() converte o objeto especificado em um valor de string.

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