本文详细介绍了Java List集合的不同实现（ArrayList、LinkedList和Vector），包括它们的关系、特点、遍历方式、扩容机制，以及删除元素的正确方法。特别关注了ArrayList的删除问题和迭代器的使用技巧。
list集合想必大家都是不陌生的，我们用的也是非常的多，但是可能大家在使用中，也不是对list集合有非常详细的讲解，今天小编就详细的带大家了解list集合。
目录
一.集合之间的关系
下方是一张UML图，vector，ArrayList，LinkedList继承List，今天也是详细讲解该三个集合，下一篇文章在给大家详细Set集合。
二.List集合
List集合特点：
元素有序的，且可重复。(元素有序不是指，我们存进Lits集合中的什么1,3,7,6他给我们从小到大，或者从大到小这样子，所谓的有序是我们该集合有下标，下标从0开始，然后我们按照什么顺序增加到list集合的，那么他就是什么样子的顺序)。
List集合遍历：
根据下标，foreach，迭代器遍历数据。
Lits集合扩容：
Lits集合当我们实例出来，它的默认初始容量为10，当往List集合里面增加的数据超过10个以后，他就会扩容增加0.5倍，扩容以后就是15。
新容量 = 原容量 + 原容量 * 0.5
注：vector，ArrayList，LinkedList都是继承List，所以和Lits集合以上三点都是一样的。
三.ArrayList集合
ArrayList集合是继承List的集合的，所以Lits集合具备的一些特点，ArrayList也是具备的。
ArrayList集合的特点：
- 简单数据结构，超出容量会自动扩容，也是和List集合的扩容是一样的。
- ArrayList集合动态数组，为什么说是动态数组，因为数组一般能存放多少数据，一般都是定好的，而ArrayList数组是可以根据数据扩容的，所以是一个动态的数组。
- 内部实现是基于基础的对象数组的，也就是ArrayList集合存放的是对象。
- ArrayList集合不适合随机的删除和增加。
ArrayList删除几种删除
for循环删除方法01
这种方法存在一个非常致命的问题，我这里的判断是删除为3的数据，集合中有两个为3的，但是只删除了一个3，得到的结果为[1, 2, 3, 4, 5, 6]
为什么没有将2个3全部删除？
因为在进行删除的时候会，本来集合数据为[1，2，3，3，4，5，6]，但是在我们删除3的时候，集合立马就会变成[1，2，3，4，5，6]第二个3的下标网上移动了，而for循环已经走到下标为3的，而第一个3被在删除的那一刻第二个3的下标本来是3，但是立马下标为2了，所以这就是为什么结果为[1, 2, 3, 4, 5, 6]，所以这种方法非常大的bug存在，因为想删除的数据没有删除成功。
package patterndemo02; import java.util.ArrayList; import java.util.List; import org.junit.Before; import org.junit.Test; public class Test01 { private List<Integer> list=new ArrayList<Integer>(); /** * 第一种删除方法 */ @Before public void list() { //往集合中增加数据 list.add(1); list.add(2); list.add(3); list.add(3); list.add(4); list.add(5); list.add(6); } @Test public void test01() { for(int i=0;i<list.size();i++) { //判断当找到该对象值为3的删除 if(list.get(i)==3) { list.remove(i); } } System.out.println(list); } }得到结果
for循环删除方法02
这种方法将3全部删除了，因为首先判断为3的进行删除，但是i--的特点在于，第一遍不会立马执行i=i-1，等第二次的执行才会执行i=i-1，所以第一遍正常删除第一个三，第二遍删除第二个3所以结果为[1，2，4，5，6]
package patterndemo02; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import org.junit.Before; import org.junit.Test; public class Test01 { private List<Integer> list=new ArrayList<Integer>(); /** * 第一种删除方法 */ @Before public void list() { //往集合中增加数据 list.add(1); list.add(2); list.add(3); list.add(3); list.add(4); list.add(5); list.add(6); } @Test public void test02() { for(int i=0;i<list.size();i++) { if(list.get(i)==3) { list.remove(i--); } } System.out.println(list); } }得到结果：
for循环删除方法03
大家看这个图更好理解，图片画的有点丑。
package patterndemo02; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import org.junit.Before; import org.junit.Test; public class Test01 { private List<Integer> list=new ArrayList<Integer>(); /** * 第一种删除方法 */ @Before public void list() { //往集合中增加数据 list.add(1); list.add(2); list.add(3); list.add(3); list.add(4); list.add(5); list.add(6); } @Test public void test03() { for(int i=list.size()-1;i>=0;i--){ if(list.get(i)==3){ list.remove(i); } } } }得出结果
foreach删除方法
这种方法就是非常严重的问题，因为报错，所以不要使用foreach删除。
public void test04() { for(Integer i:list){ if(i==3) list.remove(i); } System.out.println(list); }这种方法有一个非常有意思的地方，就是他可以删除倒数第二个元素，不会报错，会删除成功，这也算是一个小bug。
@Test public void test04() { for(Integer i:list){ if(i==3) { list.remove(5); } } System.out.println(list); }
为什么使用foreach删除报错？？？
首先foreach在本质上创建了迭代器，我们先看下源码。
private class Itr implements Iterator<E> { int cursor; // index of next element to return int lastRet = -1; // index of last element returned; -1 if no such int expectedModCount = modCount; Itr() {} //1. public boolean hasNext() { return cursor != size; } //2. public E next() { checkForComodification(); int i = cursor; if (i >= size) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) throw new ConcurrentModificationException(); cursor = i + 1; return (E) elementData[lastRet = i]; } //3. public void remove() { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { ArrayList.this.remove(lastRet); cursor = lastRet; lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } //4. final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } }注意看这个方法
//4. final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }
modCount：修改次数当list调动add方法时，add方法会对 modCount 实现++操作，如上例，共调用了add()4次，
则modCount=4。
而在迭代器初始化过程中会将这个值赋给迭代器的 expectedModCount，
则此时：modCount==expectedModCount==4。
当我们对list修改，则
modCount+1，此时，modCount==5，而
expectedModCount依然为 4，因为：
modCount != expectedModCount，所以抛出异常！
注：
所以我们使用迭代器来进行删除，因为迭代器可以维持这两个数相同，使用使用迭代器就不会出现像使用foreach这种情况的出现。
迭代器删除01
使用迭代器进行删除集合中的数据，首先不会存在数据想要删除的数据，没有被删除，或者多删，报错这种情况不会出现，使用迭代器不报错的原因，是因为迭代器可以维持那两个数的相等，所以不会像foreach出现那种情况。
@Test public void test05() { Iterator<Integer> it=list.iterator(); while(it.hasNext()) { Integer vaule=it.next(); if(vaule==3) { it.remove(); } } }得到的结果：[1, 2, 4, 5, 6]
迭代器删除元素02
第二种使用迭代器的方法，但是这种方法咋就是一整个漏住，会直接报错。
为什么报错嘞?
迭代器其实在另外一个线程复制了一个一摸一样的集合进行遍历的。当用集合的remove方法删除元素时，迭代器是不会知道的，所以就会抛出异常。
@Test public void test06() { Iterator<Integer> it=list.iterator(); while(it.hasNext()){ Integer value=it.next(); if(value==3){ list.remove(value); } } System.out.println(list); }
list集合删除方法
这句语句是删除下标为2的元素
list.remove(2);这句是删除元素为2的
list.remove(Integer.valueOf(2));
四.LinkedList集合
- 和List集合用法一样
- 线程不安全
- LinkedList集合实现双向链表接口，实现从头元素到尾元素的链表和从尾到头元素的链表，目标为了增加元素的检索效率
- 适合做随机的增加或者删除
五.Vector集合
- 线程安全
- Vector中所有的方法都是线程同步的，都带有synchronized关键字，所以他的并行性能慢，不建议使用
为什么性能慢？
打个比方，比如一个厕所有三个位置，有一个人去上厕所了，他就直接把最外面的那个门给关了，他一个人进去上厕所，但是他只需要一个位置，但是他把大门锁了，其他人只能在外面等待，结果他自己就上一个位置，其他两个都空着。也就是Vector进去一个他就会上锁，等里面执行完成，在到另外一个。也就是同步锁的一个原理。
六.CopyOnWriteArrayList集合
- 线程安全，相比Veator性能更加好
- 适合读多，写少的的场景
- 写时复刻
- 最终一致性
CopyOnWriteArrayList集合写时复刻和最终一致性什么意思？
CopyOnWriteArrayList集合这个集合，我觉得是非常有意思的，当我们需要对该数据进行操作时，他会将原本集合中的数据复制过去，然后在复制过去的集合里的元素进行操作，这就是写时复刻，等修改完成，这个修改过的集合就会给到原本的数组哪里，这是最终一致性。
今天的学习就到这里啦！！！下篇文章为大家带来set集合的一个详细讲解。
扫一扫
2002
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
