tostringbuilder(stringbuilder怎么用)

j*a中toString()方法怎么用

toString

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

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

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

toString是源自j*a Object类，在Object内定义为：返回一个类名@hashcode的字符串，可以overridden用来返回你认为有用的信息，

toStrng没有arguments

override：public String toString（）{

// insert you code

return”informations”

}

因为在j*a中 Object类是基类，所以每个类都会有toString方法。

System.out.println（Object）实际上就是调用 object的toString方法。

我们用的比较多的就是 String类的toString方法，String类重写了Object的toString方法，用于返回String的字符串值。

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

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

总而言之，它只是sun*开发j*a的时候为了方便所有类的字(de0 shi2 hou4 wei4 le0 fang1 bian4 suo3 you3 lei4 de0 zi4)符串*作而特意加入的一个方法

//toString改个名字试试看

}

A obj=new A();

System.out.println(obj);

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

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

会得到输出:this is A

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

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

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

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

回答补充：

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

例子1：

public class A{

public String toString(){return”this is A”;}

}

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

A obj=new A();

System.out.println(obj);

会得到输出:this is A

例子2：

public class A{

public String getString(){return”this is A”;}//toString改个名字试试看

}

A obj=new A();

System.out.println(obj);

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

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

会得到输出:this is A

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

toString()是重写了父类Object的方法，目的是把该对象以字符串的形式表达出来，

一般的实体类都要重写toString()、equals()、hashCode()等方法方法,如User,Student等实体类

如果一个类用来处理一些业务的就没必要重写toStirng()

在commons-lang包中都封装了这些方法，

1）public boolean equals(Object obj){

return EqualsBuilder.reflectionEquals(this.obj);

}

2）public int hashCode(){

return HashCodeBuilder.reflectionHashCode(this);

}

3）public String toStirng(){

teturn ToStringBuilder.reflectionToString(this);

}

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

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

例如：com.struts2.User@de6ced

而重写该类的toString()方法后，将返回该类里面的toString（）方法的返回值！

view plaincopy to clipboardprint?

package com.struts2;

public class User{

private String username;

private String password;

public User(){

}

public User(String username,String password){

this.username=username;

this.password= password;

}

public String getUsername(){

return username;

}

public void setUsername(String username){

this.username= username;

}

public String getPassword(){

return password;

}

public void setPassword(String password){

this.password= password;

}

public String toString(){

return this.username+this.password;

}

public static void main(String[] args){

System.out.println(new User(“张三”,”123456″));

}

}

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

toString（）方法将

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@11b86e7sample.Orc@11b86e7

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

结果：

Orc12:I'm a Villain and my name is LimburgerOrc19:I'm a Villain and my name is Bob

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

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

import j*a.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 j*a.util.ArrayList;

import j*a.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#0This is Hamster#1This is Hamster#2

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

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

import j*a.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}

Exception()

构造详细消息为 null的新异常。

Exception(String message)

构造带指定详细消息的新异常。

Exception(String message, Throwable cause)

构造带指定详细消息和原因的新异常。

Exception(Throwable cause)

在j*a中，如果一个对象未重写toString()方法，那么它将会调用父类的toString()，如果父类也没有重写这个方法，那么就迭代往上调用，直到Object的toString()方法。

我们在打印这个toStirng()方法的时候，会出现XXXX@e29820字样，那么@后面的值到底是什么呢，它是对象所在的内存地址么？下面我们来证明：

package oliver.examination.part1;

import j*a.util.ArrayList;

import j*a.util.List;

public class ObjectToStringTest{

private static final int SIZE=10000;

public static void main(String[] args)

{

//创建列表存放对象

List<Object> list= new ArrayList<Object>();

int existNumber=0;

//新建SIZE个对象，如果toStirng代表的是内存地址，地址是不会重复的，

//那么list中应该不会存在重复的元素。

//list的大小应该为SIZE

for(int i=0;i<SIZE;i++){

Object obj= new Object();

if(list.contains(obj.toString())){

System.out.println(“对象：”+obj.toString()+”已存在!”);

existNumber++;

}else

list.add(obj.toString());

}

System.out.println(“列表List的大小:”+list.size());

System.out.println(“重复元素的个数：”+existNumber);

System.out.println

//清空list

list.clear();

existNumber=0;

//新建一个对象的时候，变量名是对这个对象的应用（相当于对象的”地址”）

//利用这个原理，我们再测试

for(int i=0;i<SIZE;i++){

Object obj= new Object();

if(list.contains(obj)){

System.out.println(“对象：”+obj+”已存在!”);

existNumber++;

}else

list.add(obj.toString());

}

System.out.println(“列表List的大小:”+list.size());

System.out.println(“重复元素的个数：”+existNumber);

}

}

运行结果如下：

对象：j*a.lang.Object@922804已存在!

对象：j*a.lang.Object@e29820已存在!

列表List的大小:9998

重复元素的个数：2

列表List的大小:10000

重复元素的个数：0

查看Object源代码：

public String toString(){

return getClass().getName()+”@”+ Integer.toHexString(hashCode());

}

如何在JAVA中重写toString()方法

string是一个对象，但也可以用基本类型创建的方式来创建，例如:

String s=”abababababa”;//基本类型创建的方式

String s= new String(“asdsad”);//对象

j*a里，所有的类，不管是j*a库里面的类，或者是你自己创建的类，全部是从object这个类继承的。object里有一个方法就是toString(),那么其实所有的类创造的时候，都有一个toString的方法。j*a输出用的函数print();是不接受对象直接输出的，只接受字符串或者数字之类的输出。例如：

class Acccc

{}

Acccc s1= new Acccc();

System.out.print(s1);

按照print接受的类型来说，s1是不能直接输出的，那么是否代表这个是不能编译运行的呢?当然不是。因为当print检测到输出的是一个对象而不是字符或者数字时，那么它会去调用这个对象类里面的toString方法。

即使你没有创建，因为是所有的类都是集成object类，所以自然也继承了这个方法。所以默认情况下，你输出一个对象，会调用这个对象继承的toString方法,而object里的这个方法，默认的功能是返回这个对象的名称。

class A

{

String toString()

return“cao”；

}

class B

{

public static void main(String [] args)

{

A x1= new A();

System.out.println(x1);//输出就是”cao”……

}

}

j*a中的toString()是什么方法

toString

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

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

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

toString是源自j*a Object类，在Object内定义为：返回一个类名@hashcode的字符串，可以overridden用来返回你认为有用的信息，

toStrng没有arguments

override：public String toString（）{

// insert you code

return”informations”

}

因为在j*a中 Object类是基类，所以每个类都会有toString方法。

System.out.println（Object）实际上就是调用 object的toString方法。

我们用的比较多的就是 String类的toString方法，String类重写了Object的toString方法，用于返回String的字符串值。

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

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

总而言之，它只是sun*开发j*a的时候为了方便所有类的字(de0 shi2 hou4 wei4 le0 fang1 bian4 suo3 you3 lei4 de0 zi4)符串*作而特意加入的一个方法

//toString改个名字试试看

}

A obj=new A();

System.out.println(obj);

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

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

会得到输出:this is A

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

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

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

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

回答补充：

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

例子1：

public class A{

public String toString(){return”this is A”;}

}

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

A obj=new A();

System.out.println(obj);

会得到输出:this is A

例子2：

public class A{

public String getString(){return”this is A”;}//toString改个名字试试看

}

A obj=new A();

System.out.println(obj);

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

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

会得到输出:this is A

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

toString()是重写了父类Object的方法，目的是把该对象以字符串的形式表达出来，

一般的实体类都要重写toString()、equals()、hashCode()等方法方法,如User,Student等实体类

如果一个类用来处理一些业务的就没必要重写toStirng()

在commons-lang包中都封装了这些方法，

1）public boolean equals(Object obj){

return EqualsBuilder.reflectionEquals(this.obj);

}

2）public int hashCode(){

return HashCodeBuilder.reflectionHashCode(this);

}

3）public String toStirng(){

teturn ToStringBuilder.reflectionToString(this);

}

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

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

例如：com.struts2.User@de6ced

而重写该类的toString()方法后，将返回该类里面的toString（）方法的返回值！

view plaincopy to clipboardprint?

package com.struts2;

public class User{

private String username;

private String password;

public User(){

}

public User(String username,String password){

this.username=username;

this.password= password;

}

public String getUsername(){

return username;

}

public void setUsername(String username){

this.username= username;

}

public String getPassword(){

return password;

}

public void setPassword(String password){

this.password= password;

}

public String toString(){

return this.username+this.password;

}

public static void main(String[] args){

System.out.println(new User(“张三”,”123456″));

}

}

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

toString（）方法将

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@11b86e7sample.Orc@11b86e7

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

结果：

Orc12:I'm a Villain and my name is LimburgerOrc19:I'm a Villain and my name is Bob

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

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

import j*a.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 j*a.util.ArrayList;

import j*a.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#0This is Hamster#1This is Hamster#2

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

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

import j*a.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}

Exception()

构造详细消息为 null的新异常。

Exception(String message)

构造带指定详细消息的新异常。

Exception(String message, Throwable cause)

构造带指定详细消息和原因的新异常。

Exception(Throwable cause)

在j*a中，如果一个对象未重写toString()方法，那么它将会调用父类的toString()，如果父类也没有重写这个方法，那么就迭代往上调用，直到Object的toString()方法。

我们在打印这个toStirng()方法的时候，会出现XXXX@e29820字样，那么@后面的值到底是什么呢，它是对象所在的内存地址么？下面我们来证明：

package oliver.examination.part1;

import j*a.util.ArrayList;

import j*a.util.List;

public class ObjectToStringTest{

private static final int SIZE=10000;

public static void main(String[] args)

{

//创建列表存放对象

List<Object> list= new ArrayList<Object>();

int existNumber=0;

//新建SIZE个对象，如果toStirng代表的是内存地址，地址是不会重复的，

//那么list中应该不会存在重复的元素。

//list的大小应该为SIZE

for(int i=0;i<SIZE;i++){

Object obj= new Object();

if(list.contains(obj.toString())){

System.out.println(“对象：”+obj.toString()+”已存在!”);

existNumber++;

}else

list.add(obj.toString());

}

System.out.println(“列表List的大小:”+list.size());

System.out.println(“重复元素的个数：”+existNumber);

System.out.println

//清空list

list.clear();

existNumber=0;

//新建一个对象的时候，变量名是对这个对象的应用（相当于对象的”地址”）

//利用这个原理，我们再测试

for(int i=0;i<SIZE;i++){

Object obj= new Object();

if(list.contains(obj)){

System.out.println(“对象：”+obj+”已存在!”);

existNumber++;

}else

list.add(obj.toString());

}

System.out.println(“列表List的大小:”+list.size());

System.out.println(“重复元素的个数：”+existNumber);

}

}

运行结果如下：

对象：j*a.lang.Object@922804已存在!

对象：j*a.lang.Object@e29820已存在!

列表List的大小:9998

重复元素的个数：2

列表List的大小:10000

重复元素的个数：0

查看Object源代码：

public String toString(){

return getClass().getName()+”@”+ Integer.toHexString(hashCode());