奋斗黑马程序员----Java集合框架之List

[b]----------android培训[/b]、java培训、期待与您交流！----------

/**Java之集合框架
*
*/
/**1,集合框架简介：
*面向对象语言对事物的体现都是以对象的形式，所以为了方便对多
*个对象的操作，就对对象进行封装（存储），集合就是存储对象最常用
*的一种方式。集合就是用来存对象的。数据多了用对象存。对象多了用
*集合存
*
*数组和集合类同是容器，有何不同？
*	数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。
*	数组中可以存储基本数据类型，但集合只能存储对象。
*
*集合类的特点：
*	集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
*
*集合框架，为什么出现了这么多的容器呢？
*	因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构。
*
*Collection:
*publicinterfaceCollection<E>extendsIterable<E>,Collection层次结构中的
*根接口。Collection表示一组对象，这些对象也称为collection的元素。一些
*collection允许有重复的元素，而另一些则不允许。一些collection是有序的，而另一
*些则是无序的。JDK不提供此接口的任何直接实现：它提供更具体的子接口（如Set和
*List）实现。此接口通常用来传递collection，并在需要最大普遍性的地方操作这些collection。
*
*部分已知接口：List和Set
*1，List：
*	publicinterfaceList<E>extendsCollection<E>，有序的collection（也称为序列）。
*此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索
*引（在列表中的位置）访问元素，并搜索列表中的元素。
*
*与set不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足e1.equals(e2)的
*元素对e1和e2，并且如果列表本身允许null元素的话，通常它们允许多个null元素。难免
*有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望
*这种用法越少越好。
*
*2，Set
*一个不包含重复元素的collection。更确切地讲，set不包含满足e1.equals(e2)的元素对
*e1和e2，并且最多包含一个null元素。正如其名称所暗示的，此接口模仿了数学上的set抽象。
*
*
*Collection
*|----interfaceList
*|
*|----interfaceSet
*
*List:允许重复元素
*	|----ArrayList
*	|----LinkedList
*	|----Stack
*	|----Vector
*
*Set:不允许重复元素
*|----HashSet
*|----TreeSet
*/

/**2:add方法
*booleanadd(Ee)确保此collection包含指定的元素（可选操作）。
*1，add方法的参数类型是Object，以便于接受任意类型的对象。
*2，集合中存储的都是对象的引用（地址）
*
*/
importjava.util.*;
class	CollectionDemo
{
publicstaticvoidmain(String[]args)
{
//method_2();
method_get();

}

publicstaticvoidbase_method()
{
//创建一个集合容器，使用Collection接口的子类，ArrayList
ArrayListal=newArrayList();

//1，添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");

//打印对象
sop("打印原集合："+al);

//2，获取个数，集合长度
//sop("ArrayList的al的size:"+al.size());

/**编译时提示：要学了泛型才能解决，但和编译失败没有关系
*注:CollectionDemo.java使用了未经检查或不安全的操作。
*注:有关详细信息,请使用-Xlint:unchecked重新编译。
*/

//3，删除元素。
//al.remove("java02");
//al.clear();	//这个是清空集合
sop("打印改变后的集合："+al);

//4,判断元素
sop("java03是否存在："+al.contains("java03"));
sop("集合是否为空？"+al.isEmpty());
}

publicstaticvoidmethod_2()
{
ArrayListal1=newArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");

ArrayListal2=newArrayList();
al2.add("java03");
al2.add("java04");
al2.add("java05");
al2.add("java06");

/*取交集
*booleanretainAll(Collection<?>c)
*仅保留此collection中那些也包含在指定collection的元素（可选操作）。
*
*booleanremoveAll(Collection<?>c)
*移除此collection中那些也包含在指定collection中的所有元素（可选操作）。
*/
//al1.retainAll(al2);	//取交集：al1中只会保留和al2中相同的元素
al1.removeAll(al2);		//al1中只会保留al2中没有的元素。
sop("al1:"+al1);
sop("al2:"+al2);

/**输出：
al1:[java01,java02]
al2:[java01,java02,java05,java06]
*/
}
}

/**3：用迭代器取出集合中的元素。
*
*迭代器：其实就是取出集合中元素的方式。
*
*迭代器（Iterator）
*
*	迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，
*		而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创
*建它的代价小。
*
*	Java中的Iterator功能比较简单，并且只能单向移动：
*	(1)使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，
*它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
*	(2)使用next()获得序列中的下一个元素。
*	(3)使用hasNext()检查序列中是否还有元素。
*	(4)使用remove()将迭代器新返回的元素删除。
*
*	Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，
*它可以从两个方向遍历List，也可以从List中插入和删除元素。
迭代器应用：
listl=newArrayList();
l.add("aa");
l.add("bb");
l.add("cc");
for(Iteratoriter=l.iterator();iter.hasNext();)
{
Stringstr=(String)iter.next();
System.out.println(str);
}
/*迭代器用于while循环
Iteratoriter=l.iterator();
while(iter.hasNext())
{
Stringstr=(String)iter.next();
System.out.println(str);
}
*while循环外面还创建了一个Iterator，而for循环却没有，随着for循环的结束
*其内部的Iterator也被释放，效率更高
*/

publicclassIteratorDemo{
publicstaticvoidmain(String[]args){
method_get();
}

publicstaticvoidmethod_get()
{
ArrayListal1=newArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");

//真正的开发过程中，我们的目的是要取出元素，并操作元素，只有在上课的时候才打印元素。
sop(al1);
/**
*Iterator<E>iterator()返回在此collection的元素上进行迭代的迭代器。
*iterator()是一个方法，但是他的返回值类型是Iterator
*/

/*
Iteratorit=al1.iterator();	//获取迭代器，用于取出集合中的元素。
//接口型引用只能指向自己的子类对象，但此处的对象不是new出来的，而是用iterator方法获取的。？？？

//sop(it.next());
//sop(it.next());
//如果对象中的内容较多，这样写就会很繁琐，所以用个循环解决，但是怎么控制呢？
//booleanhasNext();如果仍有元素可以迭代，则返回true。
while(it.hasNext())
{
sop(it.next());
}
*/

/**上面的写法，当循环结束后，在内存中还存在一个对象it，就会浪费内存
*老外不会用上面的写法，当下面的循环完成后，对象it就会被释放，内存管理更优化。
*/
for(Iteratorit=al1.iterator();it.hasNext();)
{
sop(it.next());
}

/*
*就是取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素，
*那么取出方式就被定义成了内部类
*而每一个容器的数据结构不同，所以取出的，动作细节也不一样，但都是有共性内容
*判断和取出，那么可以将这些共性抽取。
*
*那么这些内部类都符合一个规则，该规则就是Iterator。
*如何获取集合的取出对象呢？
*	通关过一个对外提供的方法，iterator();
*/
/*
*实例：游乐场的夹玩具的机器，
*	各式各样，格式摆放的玩具，就相当于不同结构的数据。大的机器就相当于一个容器，而夹子就是传说中的迭代器。
*夹子在内部，复杂的事物，能移动，能操作，而且很多种游戏机的夹子不同。
*/

}
publicstaticvoidsop(Objectobj)
{
System.out.println(obj);
}
}

/**4：list集合
*Collection：第六讲：
*	|--List：元素是有序的，元素可以重复.因为该集合体系有索引	**（面试会问）**
*		|--ArrayList:底层的数据结构使用的是数组结构。(1.2版本后出现)
*			特点：查询，修改速度很快，但删除，增加麻烦（元素多时越明显）,线程不同步
*		|--LinkedList:底层的数据结构使用的是链表数据结构
*			特点：查询稍慢，添加，删除简单。
*		|--Vector:底层是数组数据结构。(1.0版本出现)
*			功能类似ArrayList，但Vector线程同步，被ArrayList替代了。
*	|--Set：元素是无序的。元素不可以重复。
*
*List集合的常见方法：
*	特有方法，凡是可以操作角标的方法都是该体系特有的方法
*	增：
*		add(intindex,elemente);
*		addAll(index,Collection);
*	删：
*		remove(index);
*	改：
*		set(index,element);
*	查：
*		get(index);
*		subList(from,to);
*		listIterator();
*/

/**5，List御用迭代器，ListIterator
*publicinterfaceListIterator<E>extendsIterator<E>系列表迭代器，允许程序
*员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
*ListIterator没有当前元素；它的光标位置始终位于调用previous()所返回的元素
*和调用next()所返回的元素之间。（即，光标位置始终在两个元素之间，见文档）
*
*	List集合特有的迭代器：ListIterator是Iterator的子接口。
*	在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生并发操作
*异常（java.util.ConcurrentModificationException）
*	所以在迭代时，只能用迭代器的方法操作元素，可是Iterator的方法是有限的，
*只能进行判断，去除，删除的操作，如果想用其他的操作，如：
*	添加，修改等，就需要使用其子接口，ListIterator。
*	该接口只能通过List集合的listIterator方法获取
*/
importjava.util.*;
publicclassListDemo{
publicstaticvoidmethod()
{
ArrayListal=newArrayList();
//添加元素：
al.add("java01");
al.add("java02");
al.add("java03");

sop("原集合是："+al);
//在指定位置添加元素
al.add(1,"java05");	//在1角标处添加元素
sop("修改后的集合是："+al);

//删除指定位置的元素
al.remove(2);
sop("删除后的元素有："+al);

//修改指定位置的元素
al.set(1,"java038");
sop("修改后的集合为："+al);

//查找元素
sop("查找的元素为："+al.get(2));

//获取所有的元素
System.out.println("集合al中全部的元素如下：");
for(intx=0;x<al.size();x++)
{
sop("al["+x+"]="+al.get(x));
}

Iteratorit=al.iterator();
while(it.hasNext())
{
sop("next："+it.next());
}
}
publicstaticvoidmain(String[]args)
{
ArrayListal=newArrayList();
//添加元素：
al.add("java01");
al.add("java02");
al.add("java03");

//通过indexOf获取对象的位置
//sop("index="+al.indexOf("java038"));
//Listsub=al.subList(1,3);	//subList(1,3);包含1，不包含3
//sop("sub="+sub);

/**
*演示列表迭代器：
*/

//		//在迭代过程中，准备添加或者删除元素
//		Iteratorit=al.iterator();
//		while(it.hasNext())
//		{
//			//sop("next："+it.next());
//			Objectobj=it.next();	//迭代方法
//			if(obj.equals("java02"))
//			{
//				/**
//				*迭代器只能做判断，删除，不能做添加操作
//				*/
//				//al.add("java0089");	//集合方法
//				it.remove();	//移除该元素，将java02的引用从集合中删除了
//
//				/*
//				*抛出：java.util.ConcurrentModificationException，不能并发操作
//				*/
//			}
//			sop("obj="+obj);
//			/**
//			*问题：为什么此处打印了“java02”，而下面的没有打印？
//			*	因为，it.remove();执行后，内存中还存在“java02”的引用，元素还在被obj使用中，所以被打印了
//			*/
//
//		}
sop("原集合元素："+al);

ListIteratorli=al.listIterator();

/*
*booleanhasPrevious()如果以逆向遍历列表，列表迭代器有多个元素，则返回true。
*/
sop("hasPrevious:"+li.hasPrevious());
//false，默认指向第一个，所以他的前一个是没有的
while(li.hasNext())
{
Objectobj=li.next();
if(obj.equals("java02"))
{
//li.add("java099");
li.set("java008");
}
/**
*ListIterator增删改查，样样都行，也只有list具备这样的功能，那么这时为什么呢？
*	因为List集合中的元素都带有角标。
*/
sop("next---"+obj);
}
//sop("最终打印："+al);
//sop("hasNext:"+li.hasNext());	//false
//sop("hasPrevious:"+li.hasPrevious());	//true
while(li.hasPrevious())
{
sop("pre---"+li.previous());
}

}

publicstaticvoidsop(Objectojb)
{
System.out.println(ojb);
}
}

/**6：Vector中的枚举
*枚举就是Vector特有的取出方式。
*发现枚举和迭代器很像。
*
*其实枚举和迭代式一样的，因为枚举的名称以及方法的名称都过长，所以被迭代器
*取代了，所以枚举郁郁而终了。
*
*ArrayList与Vector的区别：
*1.ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行
*快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要
*增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的
*中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它
*适合随机查找和遍历，不适合插入和删除。
*
*	2.Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，
*即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但
*实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
*
*3.LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访
*问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作
*表头和表尾元素，可以当作堆栈、队列和双向队列使用。
*
*
*关于ArrayList和Vector区别如下：
*1.ArrayList在内存不够时默认是扩展50%+1个，Vector是默认扩展1倍。
*2.Vector提供indexOf(obj,start)接口，ArrayList没有。
*3.Vector属于线程安全级别的，但是大多数情况下不使用Vector，因为线程安全需
*要更大的系统开销。
*

*/
importjava.util.*;
publicclassVectorDemo{
publicstaticvoidmain(String[]args)
{
Vectorv=newVector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");

/*
*Enumeration<E>elements()返回此向量的组件的枚举。
*
*booleanhasMoreElements()测试此枚举是否包含更多的元素。
*
*EnextElement()如果此枚举对象至少还有一个可提供的元素，则返回此
*枚举的下一个元素。
*/
Enumerationen=v.elements();
while(en.hasMoreElements())
{
sop(en.nextElement());
}
}
publicstaticvoidsop(Objectobj)
{
System.out.println(obj);
}
}

/**7：LinkedList（不同步）
*
*publicclassLinkedList<E>extendsAbstractSequentialList<E>implementsList<E>,
*Deque<E>,Cloneable,Serializable，List接口的链接列表实现。实现所有可选的列表操
*作，并且允许所有元素（包括null）。除了实现List接口外，LinkedList类还为在列表的
*开头及结尾get、remove和insert元素提供了统一的命名方法。这些操作允许将链接列表
*用作堆栈、队列或双端队列。
*
*此类实现Deque接口，为add、poll提供先进先出队列操作，以及其他堆栈和双端队列操作。
*
*LinkedList的特有方法：
*	addFirst();
*	addLast();
*
*	getFirst();
*	getLast();
*	get方法获取元素，但不删除元素
*
*	removeFirst();
*	removeLast();
*	remove：也获取元素，但是元素被删除了，如果集合中没有元素，会出现NoSuchElementException
*
*在JDK1.6版本以后，出现了替代方法：
*	offer();			将指定元素添加到此列表的末尾（最后一个元素）。
*	offerFirst();		在此列表的开头插入指定的元素。
*	offerLast();		在此列表末尾插入指定的元素。
*
*	peek();				获取但不移除此列表的头（第一个元素）。
*	peekFisrt();		获取但不移除此列表的第一个元素；如果此列表为空，则返回null。
*	peekLast();			获取但不移除此列表的最后一个元素；如果此列表为空，则返回null。
*
*	pollFirst();		获取并移除此列表的第一个元素；如果此列表为空，则返回null。
*	pollLast();			获取并移除此列表的最后一个元素；如果此列表为空，则返回null。
*	获取元素，但是元素被删除了，如果集合中没有元素，会返回null。
*
*/
importjava.util.*;

publicclassLinkedDemo{
publicstaticvoidmain(String[]args)
{
LinkedListlink=newLinkedList();
link.addFirst("java001");
link.addFirst("java002");
link.addFirst("java003");
link.addFirst("java004");

/*
sop("添加过元素后的集合是："+link);
sop("头是："+link.getFirst());
sop("头是："+link.getFirst());
sop("尾是："+link.getLast());
sop(link.removeFirst());
sop(link.removeLast());
sop("size="+link.size());
*/

link.offer("java999");
link.offer("javeEEi");
while(!link.isEmpty())
{
//sop(link.removeFirst());	//正着取了元素，并删除元素
sop(link.removeLast());		//倒着取元素，并删除元素

}
sop("link中还有的元素有："+link);
}
publicstaticvoidsop(Objectobj)
{
System.out.println(obj);
}
}

/**8：LinkedList练习
*使用LinkedList模拟一个堆栈或者队列数据结构
*
*堆栈：先进后出	如同一个杯子
*队列：先进先出	FirstInFirstOut	如同一个水管
*/
importjava.util.*;
/**
*描述一种队列结构的对象
*
*/
classDuilie	//描述一种数据结构
{
privateLinkedListlink;
Duilie()
{
link=newLinkedList();
}
publicvoidmyAdd(Objectobj)
{
link.addFirst(obj);
}
publicObjectmyGet()
{
//returnlink.removeFirst();	//堆栈：先进后出
returnlink.removeLast();		//队列：先进先出
}
publicbooleanisNull()
{
returnlink.isEmpty();
}

}

publicclassLinkedTest
{
publicstaticvoidmain(String[]args)
{
Duiliedl=newDuilie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while(!dl.isNull())
{
/**
*符合先进先出的规则
*/
System.out.println("依次取出："+dl.myGet());
}
}
}

/**9：ArrayList练习
*去除ArrayList中的重复的元素
*
*/
importjava.util.*;
publicclassArrayListTest{
publicstaticvoidmain(String[]args)
{
ArrayListal=newArrayList();
al.add("java001");
al.add("java002");
al.add("java001");
al.add("java003");
al.add("java001");
al.add("java002");
al.add("java004");
//al.add("java004");

/*
*结论：在迭代时，循环中next()调用一次，就要hasNext判断一次，以下方法不可取
Iteratorit=al.iterator();
while(it.hasNext())
{
sop(it.next()+"。。。"+it.next());	//这里next();只能写一次
//当集合里的元素个数为偶数时，有输出
//当集合里元素的个数为奇数时，就会报错。会抛出异常：NoSuchElementException.没有这个元素异常

}
*/

sop("添加了元素后的al集合内容有："+al);
al=singleElement(al);
sop("删除了重复元素后的集合al里的元素有："+al);

}

/**
*
*@paramal	一个参数
*@return	返回值类型是ArrayList类型的
*/
publicstaticArrayListsingleElement(ArrayListal)
{
ArrayListnewAl=newArrayList();
Iteratorit=al.iterator();	//搞一个迭代器
while(it.hasNext())
{
Objectobj=it.next();
//Objectobj=it.next();	//这样写是不对的，指针已经向下移动了一次
if(!newAl.contains(obj))
{
newAl.add(obj);
}
}
returnnewAl;
}
publicstaticvoidsop(Objectobj)
{
System.out.println(obj);
}
}

/**10：ArrayList练习2
*将自定义对象作为元素存到ArrayList集合中，并去除重复元素
*
*比如：存人对象。同姓名同年龄，视为同一个人。为重复元素
*
*思路：
*	1.对人描述，将数据封装进人对象
*	2.定义容器，将人存入
*	3.取出
*
*List集合判断元素是否相同，依据是元素的equals方法。
*
*/
importjava.util.*;
classPerson
{
privateStringname;
privateintage;
Person(Stringname,intage)
{
this.name=name;
this.age=age;
}
/*
*真正的开发过程中是有setName，setAge方法的
*此处老毕省略
*/
publicStringgetName()
{
returnname;
}
publicintgetAge()
{
returnage;
}
publicbooleanequals(Objectobj)
{
if(!(objinstanceofPerson))
{
returnfalse;
}
Personp=(Person)obj;	//给obj降级
//System.out.println(this.name+"....."+p.name);
returnthis.name.equals(p.name)&&this.age==p.age;
//这里的equals方法不是Person里面的equals方法
//Person里面的equals方法比较的是对象，而此处比较的是字符串
}

}
publicclassArrayListTest2
{
publicstaticvoidmain(String[]args)
{
ArrayListal=newArrayList();
al.add(newPerson("lisi01",30));
/*讲解：在向al里面存的时候，接受的对象是任意Objectobj的
*在传Person的时候，就相当于：Objectobj=newPerson("lisi01",31);类型提升
*
*/
al.add(newPerson("lisi01",32));
al.add(newPerson("lisi01",30));
al.add(newPerson("lisi02",36));
al.add(newPerson("lisi03",32));
//al.add(newPerson("lisi02",36));
al.add(newPerson("lisi03",32));
al.add(newPerson("lisi04",30));

al=singleElement(al);
/*问题：ArrayList这个容器知道对象相同的条件吗？
*
*/
sop("remove02:"+al.remove(newPerson("lisi02",36)));
/*
*remove()方法的底层也是equals方法，就是Person里面的equals方法
*/

Iteratorit=al.iterator();
while(it.hasNext())
{
//Objectobj=it.next();
//Personp=(Person)obj;	//替换为如下写法
Personp=(Person)it.next();
sop(p.getName()+"....."+p.getAge());
/*next();在返回的时候，是Object型的，里面是没有getName()方法的
*
*/
}
}
/**
*利用一个临时集合容器newAl保存不重复的元素，然后将其返回
*@paramal
*@return
*/
publicstaticArrayListsingleElement(ArrayListal)
{
ArrayListnewAl=newArrayList();	//临时集合存储器
Iteratorit=al.iterator();
while(it.hasNext())
{
Objectobj=it.next();
/*
*contains()方法的底层原理就是调用equals方法，
*这个可以在contains()源代码中看到。
*/
if(!newAl.contains(obj))
{
newAl.add(obj);
}
}
returnnewAl;
}
publicstaticvoidsop(Objectobj)
{
System.out.println(obj);
}
}

/**List总结：
*
*List接口：
*　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索
*引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
*和下面要提到的Set不同，List允许有相同的元素。
*	除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返
*回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，
*允许添加，删除，设定元素，还能向前或向后遍历。实现List接口的常用类有LinkedList，
*ArrayList，Vector和Stack。
*
*LinkedList类
*LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert
*方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）
*或双向队列（deque）。
*注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。
*一种解决方法是在创建List时构造一个同步的List：
*　　Listlist=Collections.synchronizedList(newLinkedList(...));
*
*ArrayList类
*ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
*size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需
*要O(n)的时间。其他的方法运行时间为线性。每个ArrayList实例都有一个容量（Capacity），即用
*于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。
*当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
*和LinkedList一样，ArrayList也是非同步的（unsynchronized）。
*
*Vector类
*Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList
*创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，
*另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛
*出ConcurrentModificationException，因此必须捕获该异常。
*
*Stack类
*Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作
*堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，
*search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
*
*/