集合（二）：List接口。
2016-05-25 00:00
337 查看
摘要:List接口。ArrayList，LinkedList,Vector
一：List接口：继承自Collection，如下：
[code=plain]publicinterfaceListextendsCollection{}
1.ArrayList（实现类）：
ArrayList是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List,RandomAccess,Cloneable,java.io.Serializable这些接口。
ArrayList继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
ArrayList实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。
ArrayList实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
ArrayList实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输，和Vector不同，ArrayList中的操作不是线程安全的。所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。
[code=plain]publicclassArrayListextendsAbstractList
implementsList,RandomAccess,Cloneable,java.io.Serializable
{}
1.1ArrayList中的一些基本简单方法使用：
[code=plain]publicclassTest01List{
@Test
publicvoidtestArrayList(){
//使用ArrayList()来存放数据。
List<Person>list=newArrayList<Person>();//父类引用指向子类对象。
list.add(newPerson("Berg",22));
list.add(newPerson("BergBerg",21));
System.out.println("总共有"+list.size()+"个元素。");
for(inti=0;i<list.size();i++){
//list可通过索引来访问，所以使用get（索引）来取值。
System.out.println(list.get(i));
}
//迭代list
Iterator<Person>iterator=list.iterator();
while(iterator.hasNext()){
Personp=iterator.next();
System.out.println("iterator："+p);
}
//移除元素，按索引移除
list.remove(0);
System.out.println("移除第一个元素后：");
System.out.println("总共有"+list.size()+"个元素。");
for(inti=0;i<list.size();i++){
System.out.println(list.get(i));
}
list.add(newPerson("Cccc",19));
System.out.println("总共有"+list.size()+"个元素。");
Object[]obj=list.toArray();
System.out.println("\n******将list集合转化为数组*****:");
for(inti=0;i<obj.length;i++){
System.out.println(obj[i]);
}
//全部清空。
list.clear();
System.out.println("总共有"+list.size()+"个元素。");
}
}
1.2List的“快速随机访问”和“通过Iterator迭代器访问”的效率。(三种遍历方式)
[code=plain]publicclassTest02ArrayList{
publicstaticvoidmain(String[]args){
Listlist=newArrayList();
for(inti=0;i<100000;i++)
list.add(i);
//通过索引值遍历
iteratorByRandomAccess(list);
//通过迭代器遍历
iteratorByIterator(list);
//通过for循环遍历
iteratorByForEach(list);
}
publicstaticvoiditeratorByRandomAccess(Listlist){
longstartTime;
longendTime;
startTime=System.currentTimeMillis();
for(inti=0;i<list.size();i++){
list.get(i);
}
endTime=System.currentTimeMillis();
longinterval=endTime-startTime;
System.out.println("iteratorByRandomAccess："+interval+"ms");
}
publicstaticvoiditeratorByIterator(Listlist){
longstartTime;
longendTime;
startTime=System.currentTimeMillis();
for(Iteratoriter=list.iterator();iter.hasNext();){
iter.next();
}
endTime=System.currentTimeMillis();
longinterval=endTime-startTime;
System.out.println("iteratorByIterator："+interval+"ms");
}
publicstaticvoiditeratorByForEach(Listlist){
longstartTime;
longendTime=0;
startTime=System.currentTimeMillis();
for(Objectobj:list)
endTime=System.currentTimeMillis();
longinterval=endTime-startTime;
System.out.println("iteratorByForEach："+interval+"ms");
}
}
[code=plain]更多学习之ArrayList详细介绍(示例)：http://www.jb51.net/article/42764.htm
2.LinkedList（实现类）：
LinkedList也和ArrayList一样实现了List接口，但是它执行插入和删除操作时比ArrayList更加高效，因为它是基于链表的。基于链表也决定了它在随机访问方面要比ArrayList逊色一点。
[code=plain]publicclassLinkedList<E>
extendsAbstractSequentialList<E>
implementsList<E>,Deque<E>,Cloneable,java.io.Serializable
{}
LinkedList是一个继承于AbstractSequentialList的双向链表。它也可以被当做堆栈、队列或双端队列进行操作。
LinkedList实现List接口，能对它进行队列操作。
LinkedList实现Deque接口，即能将LinkedList当做双端队列使用。
LinkedList实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList实现Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
LinkedList是非同步的。
参照API，对LinkedList一些基本方法学习：
[code=language-java]publicclassTest03LinkedList{
publicstaticvoidmain(String[]args){
//使用LinkedList()来存放数据。
List<String>list=newLinkedList<String>();//父类引用指向子类对象。
list.add("Berg");
list.add("Smith");
list.add("Xujun");
list.add("RedSun");
System.out.println("总共有"+list.size()+"个元素。");
//1.首先先迭代遍历这个集合,并打印输出当前元素的下标位置。
Iterator<String>iterator=list.iterator();
printResult(list);
//2.在此列表中指定的位置插入指定的元素,然后在迭代输出。
list.add(2,"China");
printResult(list);
//3.分别将某个元素添加到列表的头部和尾部：
((LinkedList)list).addFirst("firstElement");
((LinkedList)list).addLast("lastElement");
printResult(list);
System.out.println("\n---------------------");
//4.返回此列表中的元素的列表迭代器:list.listIterator()
ListIterator<String>listIterator=list.listIterator();
while(listIterator.hasNext()){//正向遍历列表
Stringstring=listIterator.next();
System.out.println("当前元素为："+string);
}
while(listIterator.hasPrevious()){//反向遍历列表
Stringstr=listIterator.previous();
System.out.println("当前一个对象元素："+str);
}
//5.在当前位置前添加一个元素:
// listIterator.add("addNewElement");
// printResult(list);
////
//6.用新元素取代next或previous上次访问的元素。如果在next或previous上次调用之后列表结构被修改了，将抛出一个IllegalStateException异常。
listIterator.set("setNewElement");
printResult(list);
}
privatestaticvoidprintResult(Listlist){
Iterator<String>iterator=list.iterator();
System.out.println("\n------------------------");
while(iterator.hasNext()){
Stringstr=iterator.next();
System.out.println("当前迭代的元素是："+str+",及当前元素位置即下标值为："+list.indexOf(str));
}
System.out.println("------------------------\n");
}
}
更多学习之LinkedList的实现原理：http://tan4836128.iteye.com/blog/1717809。
Java源码分析之LinkedList：http://blog.csdn.net/jzhf2012/article/details/8540543
LinkedList和ArrayList的使用及性能分析：http://www.jb51.net/article/42767.htm
3.Vector（实现类）:
Vector是矢量队列，它是JDK1.0版本添加的类。继承于AbstractList，实现了List,RandomAccess,Cloneable这些接口。
Vector继承了AbstractList，实现了List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
Vector实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
Vector实现了Cloneable接口，即实现clone()函数。它能被克隆。
和ArrayList不同，Vector中的操作是线程安全的；但是，Vector不支持序列化，即没有实现java.io.Serializable接口。即：
[code=plain]publicclassVector<E>
extendsAbstractList<E>
implementsList<E>,RandomAccess,Cloneable,java.io.Serializable{}
对Vector的一些基本方法的使用，参照API：
[code=plain]publicclassTest04Vector{
publicstaticvoidmain(String[]args){
//默认初始容量大小为10，这个可参考源码。
List<String>list=newVector(1);
list.add("Berg");
list.add("china");
//1.返回指定索引处的组件。跟get(intindex)功能完全相同
Stringstr=(String)((Vector)list).elementAt(1);
System.out.println("返回的对象值："+str);
((Vector)list).addElement("TheVector");
//2.返回此向量的组件的枚举。
Enumeration<String>enumeration=((Vector)list).elements();
//2.1测试此枚举是否包含更多的元素。
while(enumeration.hasMoreElements()){
//2.2如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。
Stringstring=enumeration.nextElement();
System.out.println("枚举对象值："+string);
}
//3.返回此向量的当前容量
intsize=((Vector)list).capacity();
System.out.println("当前容量为："+size);
//4.将指定对象作为此向量中的组件插入到指定的index处。
((Vector)list).insertElementAt("insertNewElement",2);
//5.返回此List的部分视图，元素范围为从fromIndex（包括）到toIndex（不包括）。
List<String>list1=((Vector)list).subList(0,2);
printResult(list1);
printResult(list);
}
privatestaticvoidprintResult(List<String>list){
Iterator<String>iterator=list.iterator();
System.out.println("\n------------------------");
System.out.println("size:"+list.size());
while(iterator.hasNext()){
Stringstr=iterator.next();
System.out.println("当前迭代的元素是："+str+",及当前元素位置即下标值为："+list.indexOf(str));
}
System.out.println("------------------------\n");
}
}
Vector源码解析和实例代码：http://www.jb51.net/article/42765.htm（t挺好的。。。）
4.总结：ArrayList，LinkedList，Vector的区别：
4.1线程安全方面：
Vector是线程安全，ArrayList与LinkedList线程不安全。
4.2底层数据结构的实现：
LinkedList是双向链表，而ArrayList与Vector是数组。
4.3存储性能和特性来讲：
ArrayList与Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，他们都允许直接按序号索引元素，但是插入元素要涉及数据元素移动等内存操作，所以索引数据快而插入数据慢。Vector由于使用了synchronized方法，性能上较ArrayList差，而LinkedList使用双向链表存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时值需要记录本项的前后项即可，所以插入速度较快。
一：List接口：继承自Collection，如下：
1.ArrayList（实现类）：
ArrayList是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List,RandomAccess,Cloneable,java.io.Serializable这些接口。
ArrayList继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
ArrayList实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。
ArrayList实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
ArrayList实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输，和Vector不同，ArrayList中的操作不是线程安全的。所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。
1.1ArrayList中的一些基本简单方法使用：
2.LinkedList（实现类）：
参照API，对LinkedList一些基本方法学习：
Vector是矢量队列，它是JDK1.0版本添加的类。继承于AbstractList，实现了List,RandomAccess,Cloneable这些接口。
Vector继承了AbstractList，实现了List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
Vector实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
Vector实现了Cloneable接口，即实现clone()函数。它能被克隆。
和ArrayList不同，Vector中的操作是线程安全的；但是，Vector不支持序列化，即没有实现java.io.Serializable接口。即：
[code=plain]publicclassVector<E>
extendsAbstractList<E>
implementsList<E>,RandomAccess,Cloneable,java.io.Serializable{}
对Vector的一些基本方法的使用，参照API：
[code=plain]publicclassTest04Vector{
publicstaticvoidmain(String[]args){
//默认初始容量大小为10，这个可参考源码。
List<String>list=newVector(1);
list.add("Berg");
list.add("china");
//1.返回指定索引处的组件。跟get(intindex)功能完全相同
Stringstr=(String)((Vector)list).elementAt(1);
System.out.println("返回的对象值："+str);
((Vector)list).addElement("TheVector");
//2.返回此向量的组件的枚举。
Enumeration<String>enumeration=((Vector)list).elements();
//2.1测试此枚举是否包含更多的元素。
while(enumeration.hasMoreElements()){
//2.2如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。
Stringstring=enumeration.nextElement();
System.out.println("枚举对象值："+string);
}
//3.返回此向量的当前容量
intsize=((Vector)list).capacity();
System.out.println("当前容量为："+size);
//4.将指定对象作为此向量中的组件插入到指定的index处。
((Vector)list).insertElementAt("insertNewElement",2);
//5.返回此List的部分视图，元素范围为从fromIndex（包括）到toIndex（不包括）。
List<String>list1=((Vector)list).subList(0,2);
printResult(list1);
printResult(list);
}
privatestaticvoidprintResult(List<String>list){
Iterator<String>iterator=list.iterator();
System.out.println("\n------------------------");
System.out.println("size:"+list.size());
while(iterator.hasNext()){
Stringstr=iterator.next();
System.out.println("当前迭代的元素是："+str+",及当前元素位置即下标值为："+list.indexOf(str));
}
System.out.println("------------------------\n");
}
}
Vector源码解析和实例代码：
4.总结：ArrayList，LinkedList，Vector的区别：
4.1线程安全方面：
Vector是线程安全，ArrayList与LinkedList线程不安全。
4.2底层数据结构的实现：
LinkedList是双向链表，而ArrayList与Vector是数组。
4.3存储性能和特性来讲：
ArrayList与Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，他们都允许直接按序号索引元素，但是插入元素要涉及数据元素移动等内存操作，所以索引数据快而插入数据慢。Vector由于使用了synchronized方法，性能上较ArrayList差，而LinkedList使用双向链表存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时值需要记录本项的前后项即可，所以插入速度较快。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Shelve Instance 操作详解 - 每天5分钟玩转 OpenStack（38）
- python玩转大数据-（一）
- log2
- Java 代码块的执行顺序
- CentOS 6.4下安装Oracle 11gR2(x64)
- ORA-28000: the account is locked的解决办法
- oracle默认初始化用户名密码和密码修改
- 忘记oracle的sys用户密码怎么修改
- Linux下建立Oracle服务及其开机自启动
- 企业管理器控制台本地无法访问
- linux下Oracle的安装(二)
- centos7 关闭firewall安装iptables并配置
- 开源的服务发现可供选择的技术选型
- 详解Zoosk千万用户实时通信背后的开源技术[转]
- json字符串，json对象
- java获取真实ip地址
- js 数组快速查询指定字符串方法
- Ubuntu Android 开发(一) JDK 安装
- Ubuntu Android 开发(二) Android SDK 安装
- Ubuntu Android 开发(三) 使用SDK更新SDK 镜像