java中toString的用法

toString

public String toString()

返回该对象的字符串表示。通常， toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：

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

返回：

该对象的字符串表示形式。

因为它是Object里面已经有了的方法，而所有类都是继承Object，所以“所有对象都有这个方法”。

 

它通常只是为了方便输出，比如System.out.println(xx)，括号里面的“xx”如果不是String类型的话，就自动调用xx的toString()方法

 

总而言之，它只是sun公司开发Java的时候为了方便所有类的字符串操作而特意加入的一个方法

 

回答补充：

 

写这个方法的用途就是为了方便操作，所以在文件操作里面可用可不用

 

例子1：

public class Orc{       public static class A       {              public String toString()              {                     return "this is A";              }       }       public static void main(String[] args)       {              A obj = new A();              System.out.println(obj);       }}

如果某个方法里面有如下句子： 

A obj=new A();

 

System.out.println(obj);

 

会得到输出:this is A

 

例子2：

public class Orc{       public static class A       {              public String getString()              {                     return "this is A";              }       }       public static void main(String[] args)       {              A obj = new A();              System.out.println(obj);              System.out.println(obj.getString());       }}

会得到输出:xxxx@xxxxxxx的类名加地址形式

System.out.println(obj.getString());

 

会得到输出:this is A

 

看出区别了吗，toString的好处是在碰到“println”之类的输出方法时会自动调用，不用显式打出来。

 

 

 

 

 1 public class Zhang 2  3 { 4  5        public static void main(String[] args) 6  7        { 8  9               StringBuffer MyStrBuff1 = new StringBuffer();10 11               MyStrBuff1.append("Hello, Guys!");12 13               System.out.println(MyStrBuff1.toString());14 15               MyStrBuff1.insert(6, 30);16 17               System.out.println(MyStrBuff1.toString());18 19        }20 21 }     

 

值得注意的是, 若希望将StringBuffer在屏幕上显示出来, 则必须首先调用toString方法把它变成字符串常量,因为PrintStream的方法println()不接受StringBuffer类型的参数.

 

 

 

 

1 public class Zhang2 {3     public static void main(String[] args)4     {5         String MyStr = new StringBuffer();6         MyStr = new StringBuffer().append(MyStr).append(" Guys!").toString();7         System.out.println(MyStr);        8     }9 }     

toString()方法在此的作用是将StringBuffer类型转换为String类型.

 

 

 

 

1 public class Zhang2 {3     public static void main(String[] args)4     {5         String MyStr = new StringBuffer().append("hello").toString();6         MyStr = new StringBuffer().append(MyStr).append(" Guys!").toString();7         System.out.println(MyStr);        8     }9 }     

  

 

1．toString（）方法

Object类具有一个toString()方法，你创建的每个类都会继承该方法。它返回对象的一个String表示，并且对于调试非常有帮助。然而对于默认的toString()方法往往不能满足需求，需要覆盖这个方法。

toString（）方法将对象转换为字符串。看以下代码：

package sample;

class Villain {

    private String name;

    protected void set(String nm) {

       name = nm;

    }

    public Villain(String name) {

       this.name = name;

    }

    public String toString() {

       return "I'm a Villain and my name is " + name;

    }

}

public class Orc extends Villain {

    private int orcNumber;

    public Orc(String name, int orcNumber) {

       super(name);

       this.orcNumber = orcNumber;

    }

    public void change(String name, int orcNumber) {

       set(name);

       this.orcNumber = orcNumber;

    }

    public String toString() {

       return "Orc" + orcNumber + ":" + super.toString();

    }

    public static void main(String[] args) {

       Orc orc = new Orc("Limburger", 12);

       System.out.println(orc);

       orc.change("Bob", 19);

       System.out.println(orc);

    }

}

结果：

sample.Orc@11b86e7

sample.Orc@11b86e7

如果去掉注释，即加入2个toString（）方法后，得到

结果：

Orc12:I'm a Villain and my name is Limburger

Orc19:I'm a Villain and my name is Bob

2．在容器类中使用toString()

编写一个工具类，用于在控制台输出Iterator。

import java.util.Iterator;

public class Printer {

    static void printAll(Iterator e){

       while(e.hasNext()){

           System.out.println(e.next());

       }

    }

}

在Hamster类中重写父类的toString（）方法。

public class Hamster {

    private int hamsterNumber;

    public Hamster(int hamsterNumber){

       this.hamsterNumber=hamsterNumber;

    }

    public String toString(){

       return "This is Hamster #"+hamsterNumber;

    }

}

在HamsterMaze类中使用容器类加载Hamster类对象并输出结果。

import java.util.ArrayList;

import java.util.List;

public class HamsterMaze {

    @SuppressWarnings("unchecked")

    public static void main(String[] args){

       List list=new ArrayList();

       for(int i=0;i<3;i++)

           list.add(new Hamster(i));

       Printer.printAll(list.iterator());

    }

}

结果：

This is Hamster #0

This is Hamster #1

This is Hamster #2

3．一个实现toString()的通用的Bean

在作一个项目时发现,许多bean需要实现toString()方法,就实现一个通用的bean,然后通过其他继承即可。

import java.lang.reflect.Field;

public class BaseBean {

  

    public String toString() {

       StringBuffer sb = new StringBuffer();

       try {

           Class t = this.getClass();

           Field[] fields = t.getDeclaredFields();

           for (int i = 0; i < fields.length; i++) {

              Field field = fields[i];

              field.setAccessible(true);

              sb.append("{");

              sb.append(field.getName());

              sb.append(":");

              if (field.getType() == Integer.class) {

                  sb.append(field.getInt(this));

              } else if (field.getType() == Long.class) {

                  sb.append(field.getLong(this));

              } else if (field.getType() == Boolean.class) {

                  sb.append(field.getBoolean(this));

              } else if (field.getType() == char.class) {

                  sb.append(field.getChar(this));

              } else if (field.getType() == Double.class) {

                  sb.append(field.getDouble(this));

              } else if (field.getType() == Float.class) {

                  sb.append(field.getFloat(this));

              } else

                  sb.append(field.get(this));

              sb.append("}");

           }

       } catch (Exception e) {

           e.printStackTrace();

       }

       return sb.toString();

    }

}

测试类

public class TestBean extends BaseBean {

    private int id;

    public int getId() {

       return id;

    }

    public void setId(int id) {

       this.id = id;

    }

    public static void main(String[] args) {

       TestBean testBean = new TestBean();

       testBean.setId(9);

       System.out.println(testBean.toString());

    }

}

结果

{id:9}

 

关于String ,StringBuffer的性能

 

博客分类： java语言

通过使用一些辅助性工具来找到程序中的瓶颈，然后就可以对瓶颈部分的代码进行优化。一般有两种方案：即优化代码或更改设计方法。我们一般会选择后者，因为不去调用以下代码要比调用一些优化的代码更能提高程序的性能。而一个设计良好的程序能够精简代码，从而提高性能。

下面将提供一些在JAVA程序的设计和编码中，为了能够提高JAVA程序的性能，而经常采用的一些方法和技巧。

1．对象的生成和大小的调整。

JAVA程序设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数，从而常常会生成大量的对象（或实例）。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。

例1：关于String ,StringBuffer，+和append

JAVA语言提供了对于String类型变量的操作。但如果使用不当，会给程序的性能带来影响。如下面的语句：

String name=new String("HuangWeiFeng");

System.out.println(name+"is my name");

看似已经很精简了，其实并非如此。为了生成二进制的代码，要进行如下的步骤和操作：

(1) 生成新的字符串 new String（STR_1);

(2) 复制该字符串;

(3) 加载字符串常量"HuangWeiFeng"（STR_2);

(4) 调用字符串的构架器（Constructor）;

(5) 保存该字符串到数组中（从位置0开始）;

(6) 从java.io.PrintStream类中得到静态的out变量;

(7) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);

(8) 复制该字符串缓冲变量;

(9) 调用字符串缓冲的构架器（Constructor）;

(10) 保存该字符串缓冲到数组中（从位置1开始）;

(11) 以STR_1为参数，调用字符串缓冲(StringBuffer)类中的append方法;

(12) 加载字符串常量"is my name"(STR_3);

(13) 以STR_3为参数，调用字符串缓冲(StringBuffer)类中的append方法;

(14) 对于STR_BUF_1执行toString命令;

(15) 调用out变量中的println方法，输出结果。

由此可以看出，这两行简单的代码，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。

经修改，上面的代码可以用如下的代码来替换。

StringBuffer name=new StringBuffer("HuangWeiFeng");

System.out.println(name.append("is my name.").toString());

系统将进行如下的操作：

(1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);

(2) 复制该字符串缓冲变量;

(3) 加载字符串常量"HuangWeiFeng"(STR_1);

(4) 调用字符串缓冲的构架器（Constructor）;

(5) 保存该字符串缓冲到数组中（从位置1开始）;

(6) 从java.io.PrintStream类中得到静态的out变量;

(7) 加载STR_BUF_1;

(8) 加载字符串常量"is my name"(STR_2);

(9) 以STR_2为参数，调用字符串缓冲(StringBuffer)实例中的append方法;

(10) 对于STR_BUF_1执行toString命令(STR_3);

(11)调用out变量中的println方法，输出结果。

由此可以看出，经过改进后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程序的性能有很大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象，而代码段2只生成了四个对象。

代码段1：

String name= new StringBuffer("HuangWeiFeng");

name+="is my";

name+="name";

代码段2：

StringBuffer name=new StringBuffer("HuangWeiFeng");

name.append("is my");

name.append("name.").toString();

因此，充分的利用JAVA提供的库函数来优化程序，对提高JAVA程序的性能时非常重要的.其注意点主要有如下几方面；