List集合详细讲解

最新推荐文章于 2024-08-26 15:21:39 发布

客行.

最新推荐文章于 2024-08-26 15:21:39 发布

阅读量1.4w

点赞数 11

文章标签：大数据

本文链接： https://blog.csdn.net/m0_65725031/article/details/125483564

版权

本文详细介绍了Java List集合的不同实现（ArrayList、LinkedList和Vector），包括它们的关系、特点、遍历方式、扩容机制，以及删除元素的正确方法。特别关注了ArrayList的删除问题和迭代器的使用技巧。

摘要由CSDN通过智能技术生成

list集合想必大家都是不陌生的，我们用的也是非常的多，但是可能大家在使用中，也不是对list集合有非常详细的讲解，今天小编就详细的带大家了解list集合。

一.集合之间的关系

二.List集合

三.ArrayList集合

for循环删除方法01

for循环删除方法02

for循环删除方法03

foreach删除方法

迭代器删除01

迭代器删除元素02

list集合删除方法

四.LinkedList集合

五.Vector集合

六.CopyOnWriteArrayList集合

一.集合之间的关系

下方是一张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集合的一个详细讲解。