java中List的用法尽量详细解释,包括例子。

一、java中List的用法尽量详细解释,包括例子。

List集合中的对象按照一定的顺序排放，里面的内容可以重复。

List接口实现的类：ArrayList(实现动态数组)， Vector（实现动态数组），LinkedList（实现链表）， Stack（实现堆栈）

1.java.util.ArrayList类实现一个可增长的动态数组，平时用的比较多的就是add()方法，其它方法

请参考API帮助文档。使用该方法向集合内添加对象，并且这些对象是按照一定的顺序排列

的，它内部原理是数组实现的，因此处理数据量较大时，不建议使用。

public static void main(String[] args){

//使用Iterator迭代器遍历出集合的元素并打印

for(Iterator i= al.iterator();i.hasNext();){

String str=(String) i.next();

3.java.util.Vector（向量）类与ArrayList类似的也是实现一个动态的数组，该向量可以随意的增长以存放更多的对象

public static void main(String[] args){

//使用Iterator迭代器遍历出集合的对象并打印

for(Iterator i= al.iterator();i.hasNext();){

String str=(String) i.next();

3.java.util.LinkedList类实现了链表，可初始化化为空或者已存在的集合，通常使用以下方法

addFirst（）在链表开头添加对象。

addLast（）在链表末尾添加对象。

getFirst（）得到链表开头的对象。

getLast（）得到链表末尾的对象。

注意该类提供了随机访问列表中的元素的方法，但是底层依然必须遍历去查找随机访问的对象，因此性能依然有限.

public static void main(String[] args){

LinkedList al= new LinkedList();

//使用Iterator迭代器遍历出集合的元素并打印

for(Iterator i= al.iterator();i.hasNext();){

String str=(String) i.next();

for(Iterator i= al.iterator();i.hasNext();){

String str=(String) i.next();

4.java.util.Stack类实现了堆栈数据结构，即按照先进后出的原则存放数据。创建时只能为空。

public static void main(String[] args){

//使用Iterator迭代器遍历出集合的元素并打印

for(Iterator i= al.iterator();i.hasNext();){

String str=(String) i.next();

二、java中的循环队列front和rear指的是什么

这个要看编程者的习惯，一般有两种，一种就是front指向头，rear指向尾的下一个元素（就是下次入队的位置），另外一种就是front指向头，rear指向尾，每个人习惯不同，要看具体的代码才知道它们到底指向什么。

1、要求front指向队头，rear指向队尾，那么初始化front=0,rear究竟是0还是n-1，不妨假设rear=0，那么很明显此时已经有一个元素入队了，在a[0]的位置，此时front=rear=0,与初始为空矛盾.所以rear=(0-1)%n=n-1.

2、循环队列为充分利用向量空间，克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。

3、存储在其中的队列称为循环队列(Circular Queue)。这种循环队列可以以单链表的方式来在实际编程应用中来实现。

循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时头尾指针均相等。因此，无法通过条件front==rear来判别队列是"空"还是"满"。

1.可以另设一布尔变量以区别队列的空和满。

2.另一种方式就是数据结构常用的：队满时：(rear+1)%n==front，n为队列长度（所用数组大小），由于rear，front均为所用空间的指针，循环只是逻辑上的循环，所以需要求余运算。

类型定义采用环状模型来实现队列,各数据成员的意义如下：

front指定队首位置，删除一个元素就将front顺时针移动一位；

rear指向元素要插入的位置，插入一个元素就将rear顺时针移动一位；

count存放队列中元素的个数，当count等于MaxQSize时，不可再向队列中插入元素。

#define QueueSize 100//应根据具体情况定义该值

typedef char DataType;//DataType的类型依赖于具体的应用

int front;//头指针，队非空时指向队头元素

int rear;//尾指针，队非空时指向队尾元素的下一位置

int count;//计数器，记录队中元素总数DataTypedata[QueueSize];

队列的操作特点是“先进先出”。前者主要是头指针、尾指针的使用，后者主要是理解循环队列提出的原因及其特点。两者都要掌握队列空与满的判定条件以及出队列、入队列操作的实现。

参考资料：百度百科——循环队列

三、java中的toString()是什么方法

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

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

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

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

override：public String toString（）{

因为在java中 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公司开发java的时候为了方便所有类的字(de0 shi2 hou4 wei4 le0 fang1 bian4 suo3 you3 lei4 de0 zi4)符串操作而特意加入的一个方法

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1）public boolean equals(Object obj){

return EqualsBuilder.reflectionEquals(this.obj);

return HashCodeBuilder.reflectionHashCode(this);

teturn ToStringBuilder.reflectionToString(this);

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

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

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

view plaincopy to clipboardprint?

public User(String username,String password){

public void setUsername(String username){

public void setPassword(String password){

return this.username+this.password;

public static void main(String[] args){

System.out.println(new User("张三","123456"));

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

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

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

protected void set(String nm){

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

public class Orc extends Villain{

public Orc(String name, int orcNumber){

public void change(String name, int orcNumber){

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

public static void main(String[] args){

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

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

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

static void printAll(Iterator e){

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

public Hamster(int hamsterNumber){

this.hamsterNumber=hamsterNumber;

return"This is Hamster#"+hamsterNumber;

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

@SuppressWarnings("unchecked")

public static void main(String[] args){

Printer.printAll(list.iterator());

This is Hamster#0This is Hamster#1This is Hamster#2

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

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

import java.lang.reflect.Field;

StringBuffer sb= new StringBuffer();

Field[] fields= t.getDeclaredFields();

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

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

public class TestBean extends BaseBean{

public static void main(String[] args){

TestBean testBean= new TestBean();

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

Exception(String message, Throwable cause)

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

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

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

package oliver.examination.part1;

public class ObjectToStringTest{

private static final int SIZE=10000;

public static void main(String[] args)

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

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

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

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

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

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

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

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

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

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

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

对象：java.lang.Object@922804已存在!

对象：java.lang.Object@e29820已存在!

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