[知识整理]Java集合（一） - List
一、实现List的几个类：
ArrayList、LinkedList、CopyOnWriteArrayList、Vector
二、几个List底层的数据结构：
ArrayList - 数组列表
LinkedList - 双链表列表和队列(同时实现List和Queue接口)
Vector - 数组列表(加锁)
CopyOnWriteArrayList - 数组列表(读写分离)
三、List的几种基本操作比较
1、add操作比较
/**
* 比较add操作
* @param minTimes 最小次数
* @param maxTimes 最大次数
* @param stepLen 步长
*/
public static void compareAddMethod(int minTimes, int maxTimes, int stepLen) {
Date begin = null;
Date end = null;
int times = minTimes;
while(times < maxTimes) {
//add: Vector
Vector<Integer> vector = new Vector<Integer>();
begin = new Date();
for(int i=0; i<times; i++) {
vector.add(i);
}
end = new Date();
System.out.println("Vector add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
//add: ArrayList
ArrayList<Integer> arrayList = new ArrayList<Integer>();
begin = new Date();
for(int i=0; i<times; i++) {
arrayList.add(i);
}
end = new Date();
System.out.println("ArrayList add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
//add: LinkedList
LinkedList<Integer> linkedList = new LinkedList<Integer>();
begin = new Date();
for(int i=0; i<times; i++) {
linkedList.add(i);
}
end = new Date();
System.out.println("LinkedList add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
//add: CopyOnWriteArrayList
if(times<=100000) {
CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>();
begin = new Date();
for(int i=0; i<times; i++) {
copyOnWriteArrayList.add(i);
}
end = new Date();
System.out.println("CopyOnWriteArrayList add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
}
System.out.println("-------------------------------");
times+=stepLen;
}
运算结果：
minTimes = 0, maxTimes = 100000, stepLen = 30000
| times | Vector(ms) | ArrayList(ms) | LinkedList(ms) | CopyOnWriteArrayList(ms) |
| 0 | 0 | 0 | 0 | 0 |
| 30000 | 3 | 2 | 2 | 339 |
| 60000 | 3 | 4 | 1 | 992 |
| 90000 | 1 | 1 | 0 | 2257 |
结果分析：这里可以看出随着增加执行次数的增加CopyOnWriteArrayList所耗时增加较多，这是由于CopyOnWriteArrayList的读写策略造成。CopyOnWriteArrayList进行写操作，先对原底层数组进行复制，然后在复制数组进行写操作，最后复制数组对原数组引进行替换。这里的耗时消耗在复制数组上面，数组元素越多，所消耗的时间就越多。
minTimes = 0, maxTimes = 10000000, stepLen = 1000000
| times | Vector(ms) | ArrayList(ms) | LinkedList(ms) |
| 0 | 0 | 0 | 0 |
| 1000000 | 37 | 20 | 29 |
| 2000000 | 613 | 396 | 603 |
| 3000000 | 80 | 56 | 174 |
| 4000000 | 169 | 27 | 112 |
| 5000000 | 195 | 44 | 91 |
| 6000000 | 235 | 43 | 80 |
| 7000000 | 261 | 56 | 103 |
| 8000000 | 287 | 60 | 226 |
| 9000000 | 362 | 64 | 209 |
结果分析：这里ArrayList的插入比LinkedList快的原因是每次添加元素都是从数组末尾添加，数组直接通过索引在数组末尾添加元素，和LinkedList链表相比省却了寻找节点的时间，若是换成随机添加删除节点的操作，ArrayList就会比LinkedList慢了。而Vector虽然和ArrayList的底层数据结构一样(可变长的数组)，但是由于Vector是线程安全的，这导致执行效率会比较慢。
2、remove操作比较
/**
* 比较remove操作
* @param minTimes 最小次数
* @param maxTimes 最大次数
* @param stepLen 步长
*/
public static void compareRemoveMethod(int minTimes, int maxTimes, int stepLen) {
Date begin = null;
Date end = null;
int times = minTimes;
while(times < maxTimes) {
//remove: Vector
Vector<Integer> vector = new Vector<Integer>();
for(int i=0; i<times; i++)
vector.add(i);
begin = new Date();
for(int i=0; i<times; i++)
vector.remove(0);
end = new Date();
System.out.println("Vector remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
//remove: ArrayList
ArrayList<Integer> arrayList = new ArrayList<Integer>();
for(int i=0; i<times; i++)
arrayList.add(i);
begin = new Date();
for(int i=0; i<times; i++)
arrayList.remove(0);
end = new Date();
System.out.println("ArrayList remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
//remove: LinkedList
LinkedList<Integer> linkedList = new LinkedList<Integer>();
for(int i=0; i<times; i++)
linkedList.add(i);
begin = new Date();
for(int i=0; i<times; i++)
linkedList.remove(0);
end = new Date();
System.out.println("LinkedList remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
//remove: CopyOnWriteArrayList
if(times<=100000) {
CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>();
for(int i=0; i<times; i++)
copyOnWriteArrayList.add(i);
begin = new Date();
for(int i=0; i<times; i++)
copyOnWriteArrayList.remove(0);
end = new Date();
System.out.println("CopyOnWriteArrayList remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
}
System.out.println("-------------------------------");
times+=stepLen;
}
}
运算结果：
minTimes = 0, maxTimes = 100000, stepLen = 30000
| times | Vector(ms) | ArrayList(ms) | LinkedList(ms) | CopyOnWriteArrayList(ms) |
| 0 | 0 | 0 | 0 | 0 |
| 30000 | 90 | 90 | 5 | 229 |
| 60000 | 356 | 351 | 1 | 921 |
| 90000 | 832 | 834 | 0 | 3199 |
结果分析：不出意外，CopyOnWriteArrayList的插入删除操作依旧是耗时最长的。值得注意的是，这里LinkedList的优势体现出来了，删除插入随机节点时链表操作比数组操作是更有效率的。
3、读取操作比较
/**
* 比较读取操作
* @param minTimes 最小次数
* @param maxTimes 最大次数
* @param stepLen 步长
*/
public static void compareReadMethod(int minTimes, int maxTimes, int stepLen) {
Date begin = null;
Date end = null;
int times = minTimes;
while(times < maxTimes) {
//remove: Vector
Vector<Integer> vector = new Vector<Integer>();
for(int i=0; i<times; i++)
vector.add(i);
begin = new Date();
for(int i=0; i<times; i++)
vector.get(i);
end = new Date();
System.out.println("Vector get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
//get: ArrayList
ArrayList<Integer> arrayList = new ArrayList<Integer>();
for(int i=0; i<times; i++)
arrayList.add(i);
begin = new Date();
for(int i=0; i<times; i++)
arrayList.get(i);
end = new Date();
System.out.println("ArrayList get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
//get: LinkedList
if(times<=100000) {
LinkedList<Integer> linkedList = new LinkedList<Integer>();
for(int i=0; i<times; i++)
linkedList.add(i);
begin = new Date();
for(int i=0; i<times; i++)
linkedList.get(i);
end = new Date();
System.out.println("LinkedList get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
}
//get: CopyOnWriteArrayList
CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>();
for(int i=0; i<times; i++)
copyOnWriteArrayList.add(i);
begin = new Date();
for(int i=0; i<times; i++)
copyOnWriteArrayList.get(i);
end = new Date();
System.out.println("CopyOnWriteArrayList get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms");
System.out.println("-------------------------------");
times+=stepLen;
}
}
运算结果：
minTimes = 0, maxTimes = 100000, stepLen = 30000
| times | Vector(ms) | ArrayList(ms) | LinkedList(ms) | CopyOnWriteArrayList(ms) |
| 0 | 0 | 0 | 0 | 0 |
| 30000 | 2 | 2 | 334 | 0 |
| 60000 | 1 | 1 | 1313 | 0 |
| 90000 | 0 | 0 | 2945 | 0 |
结果分析：这里为什么LinkedList耗时比较长就不需要说明，这里Vector如果在同时频繁写操作的时候读写耗时便会比较长，而由于CopyOnWriteArrayList使用读写分离测的策略（写操作在复制数组中进行，读操作在原数组里面进行）平衡了线程安全和执行性能的矛盾。
四、小结
1、在List元素数量比较少的时候没必要纠结采用哪个List，因为规模小时根本体现不出什么差别，此时要注意是否选取线程安全的List，一般情况是不采取线程安全的List，而是在ArrayList和LinkedList之间选择。
2、Vector - 底层数据结构为可变长数组，数组长度按100%增长，线程安全，写效率低，读效率在多线程环境下也低。
3、ArrayList - 底层数据结构为可变长数组，数组长度按50%增长，线程不安全，随机插入删除操作效率低，随机读取修改元素效率高。
4、LinkedList - 底层数据结构为双向链表，线程不安全，随机插入删除操作效率高，随机读取修改元素效率低。
5、CopyOnWriteArrayList - 底层数据结构为可变长数组，线程安全，写效率低，读效率在多线程环境下也高，但是由于读写分离，读数据可能出现过时的情况（不可重复读）
6、这里CopyOnWriteArrayList读写分离的思想值得我学习。
[知识整理]Java集合（一） - List的更多相关文章
- [知识整理]Java集合
Mark Java集合图
- [知识整理]Java集合（二） - Set
一.实现Set的几个类 HashSet.LinkedHashSet.TreeSet.ConcurrentSkipListSet.CopyOnWriterArraySet 二.对应底层的数据结构 Has ...
- 《Java基础知识》Java集合（Collection）
作为一个Developer,Java集合类是我们在工作中运用最多的.最频繁的类.相比于数组(Array)来说,集合类的长度可变,更加适合于现代开发需求: Java集合就像一个容器,可以存储任何类型的数 ...
- 《Java基础知识》Java集合（Map）
Java集合主要由2大体系构成,分别是Collection体系和Map体系,其中Collection和Map分别是2大体系中的顶层接口. 今天主要讲:Map主要有二个子接口,分别为HashMap.Tr ...
- Java基础知识（JAVA集合框架之List与Set）
List和Set概述数组必须存放同一种元素.StringBuffer必须转换成字符串才能使用,如果想拿出单独的一个元素几乎不可能.数据有很多使用对象存,对象有很多,使用集合存. 集合容器因为内部的数据 ...
- 面试知识整理-Java基础
三大特征:封装,继承,多态 多态:简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情. 抽象:抽象是将一类对象的共同特征总结出来构造类的过程 包装,可以讲基本类型当做对象来使用,抽象只关心对 ...
- 学习:java集合
java是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台(即JavaEE, JavaME, Jav ...
- Java集合--HashMap分析
HashMap在Java开发中有着非常重要的角色地位,每一个Java程序员都应该了解HashMap. 本文主要从源码角度来解析HashMap的设计思路,并且详细地阐述HashMap中的几个概念,并深入 ...
- Java集合框架相关知识整理
1.常见的集合有哪些? Collection接口和Map接口是所有集合框架的父接口 Collection接口的子接口包括:Set接口和List接口 Map接口的实现类主要有:HashMap ...
随机推荐
- Click模块化路由器
[概述] Click是一种基于软件控制的模块化路由器.其架构可以大致视为一系列数据包处理模块(称为elements)组成的.一个Click路由器可以看成一张由elements作为顶点,数据包传递路径作 ...
- Python中__init__方法
注意1.__init__并不相当于C#中的构造函数,执行它的时候,实例已构造出来了. 1 2 3 4 5 class A(object): def __init__(self,name): ...
- AndroidManifest.xml的android:name是否带.的区别
android项目里面的AndroidManifest.xml,会有这样的定义 <activity android:name=".Main" ...
- 慕课网-Java入门第一季-6-8 使用 foreach 操作数组
来源:http://www.imooc.com/code/1864 foreach 并不是 Java 中的关键字,是 for 语句的特殊简化版本,在遍历数组.集合时, foreach 更简单便捷.从英 ...
- OCP认证之Oracle的SQL语言基础（一）
一.Oracle命令类别 数据操纵语言(DML):select;insert;delete;update;merge 数据定义语言(DDL):create;alter;drop;truncate 事物 ...
- 关于Jquery中ajax介绍
jQuery 底层 AJAX 实现.简单易用的高层实现见 $.get, $.post 等.$.ajax() 返回其创建的 XMLHttpRequest 对象.大多数情况下你无需直接操作该函数,除非你需 ...
- hbase 协处理器
一.服务端1.安装Protobuf2.RPC proto 定义文件:Examples.protooption java_package = "org.apache.hadoop.hbase. ...
- 使用onclick跳转到其他页面/跳转到指定url
☆如果是本页显示可以直接用location,方法如下: ①onclick="javascript:window.location.href='URL'" ②onclick=&quo ...
- 【WCF全析（一）】--服务协定及消息模式
上周微软开发布会说.NET支持完全跨平台和并开放Core源码的新闻,让我们顿时感到.NET要迎来它的春天.虽然早在几年前.NET就能开发Android和IOS,但是这次的跨平台把Linux都放到了微软 ...
- 全站 HTTPS 来了(转载)
转载:本文为腾讯Bugly原创文章. 最近大家在使用百度.谷歌或淘宝的时候,是不是注意浏览器左上角已经全部出现了一把绿色锁,这把锁表明该网站已经使用了 HTTPS 进行保护.仔细观察,会发现这些网站已 ...