如何在Java中使用toString方法？

时间：2010-09-01 07:07:09

标签： java

有人可以向我解释toString()类中定义的Object方法的概念吗？它是如何使用的，它的目的是什么？

13 个答案:

答案 0 :(得分：82)

来自Object.toString()文档：

  

返回的字符串表示形式   宾语。一般来说，toString   method返回一个字符串   “文字表示”这个对象。   结果应该是简洁但是   信息表示即   一个人容易阅读。它是   建议所有子类   覆盖此方法。

     

类Object的toString方法   返回由。组成的字符串   对象的类的名称   是一个实例，即符号字符   `@'和无符号十六进制   表示哈希码的   宾语。换句话说，这种方法   返回一个等于该值的字符串   的：

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

示例：

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

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

答案 1 :(得分：39)

使用String toString： 每当你需要在String表单中探索名为value的构造函数时，你可以简单地使用String toString ... 举个例子...... 

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

}

...将这个程序复制到你的eclipse中，运行它......你会得到关于String toString的想法...

答案 2 :(得分：34)

toString()方法返回对象的文本表示。 java.lang.Object中已经包含了一个基本实现，因为所有对象都从java.lang.Object继承，所以保证Java中的每个对象都有这种方法。

重写方法总是一个好主意，特别是在调试时，因为调试器通常会根据toString()方法的结果显示对象。因此，请使用有意义的实现，但将其用于技术目的。应用程序逻辑应该使用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()+"]";
  }
}

答案 3 :(得分：15)

它可以选择在应用程序的上下文中使用，但更常用于调试目的。例如，当您在IDE中遇到断点时，读取有意义的toString()个对象要比检查其成员要容易得多。

对toString()方法应该做什么没有设定要求。按照惯例，大多数情况下，它会告诉您类的名称和相关数据成员的值。通常，在IDE中自动生成toString()方法。

依赖于toString()方法的特定输出或在程序中解析它是一个坏主意。无论你做什么，都不要走那条路。

答案 4 :(得分：12)

toString()返回对象的字符串/文本表示。 通常用于调试，记录等诊断目的，toString（）方法用于读取有关对象的有意义的详细信息。

当对象传递给println，print，printf，String.format（），assert或字符串连接运算符时，会自动调用它。

Object类中toString（）的默认实现返回一个字符串，该字符串由该对象的类名后跟@符号和该对象的哈希码的无符号十六进制表示形式，使用以下逻辑，

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

例如，以下

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

打印

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

现在，在Coordinates类中覆盖toString（），如下所示，

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

结果

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

当对包含对这些对象的引用的集合调用方法时，重写toString（）的用处变得更加有用。例如，以下

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

打印

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

而不是这个，

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

很少有实现指针，

  1. 您应该几乎总是覆盖toString（）方法。不需要覆盖的情况之一是以{{3}的方式对静态实用程序方法进行分组的实用程序类}。不需要覆盖的情况非常直观;几乎总是你会知道。
  2. 返回的字符串应简洁明了，理想情况下不言自明。
  3. 至少，用于在两个不同对象之间建立等价的字段，即java.util.Math方法实现中使用的字段，应该由toString（）方法吐出。

  4. 为返回的字符串中包含的所有实例字段提供访问者/获取者。例如，在Coordinates类中，

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

    5. toString（）方法的全面介绍在本书的第10部分，Effective Java™，第二版，作者Josh Bloch。

答案 5 :(得分：5)

每当你在String上下文中访问一个Object（不是一个String）时，编译器就会调用toString（）。

这就是为什么

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

工作，并且通过在您自己的类中覆盖Object的标准toString（），您也可以使您的对象在String上下文中有用。

（并认为它是一个黑盒子！永远不要将内容用于除了呈现给人类之外的任何其他内容）

答案 6 :(得分：5)

编码： 

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

<强>输出：

  

[Steve 12 Daniel，Sachin 10 Tendulkar]

     

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

如果你没有在Pojo（Student.java）类中使用toString（），你将获得类似[com.steve.test.Student@6e1408, com.steve.test.Student@e53108]的输出。为了避免这些问题，我们使用toString（）方法。

答案 7 :(得分：4)

正确覆盖toString方法可以帮助记录和调试Java。

答案 8 :(得分：3)

除了cletus关于调试的回答之外，无论何时输出对象，都会使用它，就像你使用时一样

 System.out.println(myObject);

或

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

答案 9 :(得分：2)

toString的主要目的是生成对象的String表示，意味着返回值始终是String。在大多数情况下，这只是对象的类和包名，但在某些情况下，比如StringBuilder，你会得到一个字符串文本。

答案 10 :(得分：1)

如果先学习Python，再学习Java。我认为它在Python中扮演与__str__()方法相同的角色，它是magic method，如__dict__()和__init__()，但是要引用表示对象的字符串。

答案 11 :(得分：0)

toString()将指定的对象转换为字符串值。

答案 12 :(得分：0)

/**
 * 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();
}
相关问题
最新问题