ArrayList详解、Vector和CopyOnWriteArrayList和LinkedList

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量88 收藏
点赞数
分类专栏： # Java集合 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39774936/article/details/133821329
版权

ArrayList介绍

ArrayList 的底层是动态数组，它的容量能动态增长。ArrayList 继承了 AbstractList ，并实现了 List 接口。

ArrayList 在JDK1.8 前后的实现区别：

  • JDK1.7：像饿汉式，直接创建一个初始容量为10的数组
  • JDK1.8：像懒汉式，一开始创建一个长度为0的数组，当添加add第一个元素时再创建一个初始容量为10的数组

底层原理介绍

初始属性

//集合默认容量10；
private static final int DEFAULT_CAPACITY = 10;

//空数组
private static final Object[] EMPTY_ELEMENTDATA = {};

//默认容量的空的数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 集合中真实存储数据的数组
transient Object[] elementData; // non-private to simplify nested class access

 //集合中元素的个数，注意，这里不是数组的长度
private int size;

构造方法

public ArrayList() {
	//将属性中默认的空的数组赋值给了 存储数据的变量
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
	
	//等价于this.elementData = {}
}

//有参构造
public ArrayList(int initialCapacity) {
	//给定初始容量，就创建一个这个容量大小的数组
   if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
   } else if (initialCapacity == 0) {
        //如果传递的是0 就将{}赋值给elementData 
        this.elementData = EMPTY_ELEMENTDATA;
		//等价于this.elementData = {}
   } else {
   	 //如果传递的是负数，就会抛异常
        //java.lang.IllegalArgumentException: Illegal Capacity: -20
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
   }
}

添加add方法

假设使用的是空参构造，第一次添加元素 add(1)

public boolean add(E e) {
    //确保内部容量 0 + 1
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //将要添加的元素添加到数组有数据的下一个位置
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {//第一次添加： minCapacity = 1
	//有参构造的情况：new Object[10] != {}，不会执行if内的语句。即使有参构造给的是0，也不会执行，因为此时elementData = EMPTY_ELEMENTDATA，不等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    // 无参构造的情况下：{} = {} 会执行Math.max语句
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
	//比较大小，此时 minCapacity = 10
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //明确数组的容量
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;//记录当前集合操作的次数
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);//扩容操作
}

grow扩容方法

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
	
    //动态扩容，扩容为原来的1.5倍，右移一位即原来的一半
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
		
	//判断新容量是否会超过最大限制
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:    
    elementData = Arrays.copyOf(elementData, newCapacity);//数组的复制操作
}

扩容方法流程：

  1. 首先获取数组长度
  2. 将数组新容量扩容为原数组容量的1.5倍取整
  3. 将新容量和当前所需最小容量做对比，(最小容量是在add方法中得到的，minCapacity=size+1，即原数组中元素数量加1)，而newCapacity=elementData.length*1.5，一般来说肯定是1.5倍比+1的大。但是这里要考虑当数组为空时的情况。数组为空又分为两种情况：①指定了数组容量为0 ②没有显式指定数组大小。
    • 当数组为空时进行插入操作，因为元素个数size为0，数组容量也为0，那么就会进行扩容操作，对于空数组，扩容1.5倍后你的容量还是为0，那么此时就会小于我所需的最小容量（也就是1）,此时会令 newCapacity = minCapacity;
    • 而对于①，传入到grow方法的minCapacity = 1 ，因此它扩容后的容量就是1
    • 对于②，在ensureCapacityInternal方法中，使minCapacity = DEFAULT_CAPACITY（10），因此扩容后的数组长度就是DEFAULT_CAPACITY，也就是10。
    • 原因在于在有参构造方法中使this.elementData = EMPTY_ELEMENTDATA;（无参构造方法中this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;），此时在ensureCapacityInternal方法中会对this.elementData进行判断，因此对于①，传入到grow方法的minCapacity = 1；而对于②，minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity)，即minCapacity = 10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
	//比较大小，此时 minCapacity = 10
    minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
  1. 最后判断新容量大小是否大于默认数组的最大值（Integer.MAX_VALUE-8），则赋予它整型的最大值
  2. 扩容之后，会调用Arrays.copyOf()方法对数组进行拷贝。

实际上，对数组的copy需要创建一个新数组，并对原数组进行复制的操作，这会造成资源消耗。因此在添加大量元素前，建议使用ensureCapacity操作先增加 ArrayList 实例的容量，先进行稍少量数组数据的copy，再添加元素

remove方法

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
	//判断要删除的索引是否是最后一个，，如果不是最后一个，就需要进行数组的复制操作
        System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
	//然后把最后一个元素置为空
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

遍历时删除（添加）常见陷阱

for循环遍历list

删除某个元素后，list的大小发生了变化，而索引也在变化，所以会导致遍历的时候漏掉某些元素。比如当删除第1个元素后，继续根据索引访问第2个元素时，因为删除的关系后面的元素都往前移动了一位，所以实际访问的是第3个元素。因此，这种方式可以用在删除特定的一个元素时使用，但不适合循环删除多个元素时使用。

for(int i=0;i<list.size();i++){
    if(list.get(i).equals("del"))
        list.remove(i);
}

解决办法：

//从list最后一个元素开始遍历
for(int i=list.size()-1;i>+0;i--){
    if(list.get(i).equals("del"))
        list.remove(i);
}

增强for循环

删除元素后继续循环会抛异常java.util.ConcurrentModificationException，因为元素在使用的时候发生了并发的修改

for(String x:list){
    if(x.equals("del"))
        list.remove(x);
}

解决方法：但只能删除一个"del"元素

//解决：删除完毕马上使用break跳出，则不会触发报错
for(String x:list){
    if (x.equals("del")) {
         list.remove(x);
         break;
    }
}

iterator遍历

这种方式可以正常的循环及删除。但要注意的是，使用iterator的remove方法，如果用list的remove方法同样会报上面提到的ConcurrentModificationException错误。

Iterator<String> it = list.iterator();
while(it.hasNext()){
    String x = it.next();
    if(x.equals("del")){
        it.remove();
    }
}

FailFast机制

上面提到的ConcurrentModificationException异常，都是有这个机制的存在
fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A遍历集合时，即出现expectedModCount != modCount 时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。

if (modCount != expectedModCount)
    throw new ConcurrentModificationException();

fail-fast 机制并不保证在不同步的修改下抛出异常，他只是尽最大努力去抛出，所以这种机制一般仅用于检测 bug

解决 fail-fast的解决方案：

1. 在遍历过程中所有涉及到改变modCount值得地方全部加上synchronized或者直接使用Collections.synchronizedList，这样就可以解决(实际上Vector结构就是这样实现的)。但是不推荐，因为增删造成的同步锁可能会阻塞遍历操作。

List<Integer> arrsyn = Collections.synchronizedList(arr);
  1. 使用CopyOnWriteArrayList来替换ArrayList。推荐使用该方案。CopyOnWriteArrayList是兼顾了并发的线程安全

CopyOnWriteArrayList

Vector无论是add方法还是get方法都加上了synchronized修饰，当多线程读写List必须排队执行，很显然这样效率比较是低下的，CopyOnWriteArrayList是读写分离的，好处是提高线程访问效率。

原理：

  1. CopyOnWriteArrayList的动态数组机制 – 它内部有个volatile数组(array)来保持数据。在“添加/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给volatile数组。这就是它叫做CopyOnWriteArrayList的原因！
  2. 每一个CopyOnWriteArrayList都和一个监视器锁lock绑定，通过lock，实现了对CopyOnWriteArrayList的互斥添加/删除。
//add方法加锁
public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

//get方法根据index直接获取数组元素，不加锁
public E get(int index) {
    return elementAt(getArray(), index);
}

缺点：

  • CopyOnWriteArrayList的写效率比Vector慢。当CopyOnWriteArrayList写元素时是通过备份数组的方式实现的，当多线程同步激烈，数据量较大时会不停的复制数组，内存浪费严重。如果原数组的内容比较多的情况下，可能导致young gc或者full gc
  • 弱一致性：不能用于实时读的场景，像拷贝数组、新增元素都需要时间，所以调用一个set操作后，读取到数据可能还是旧的，虽然CopyOnWriteArrayList 能做到最终一致性，但是还是没法满足实时性要求；

小结： CopyOnWriteArrayList合适读多写少的场景

CopyOnWriteArrayList是Fail Safe的

采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发Concurrent Modification Exception。

缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。

LinkedList介绍

对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高；底层使用双向链表存储

//存储链表的第一个节点
transient Node<E> first;

//存储链表的最后一个节点
transient Node<E> last;

add方法

public boolean add(E e) {
    linkLast(e);//默认add方法是在尾部插入元素
    return true;
}

void linkLast(E e) {
    final Node<E> l = last;//旧的尾部元素
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;//尾部元素为 newNode
    if (l == null)//说明集合中没有元素
        first = newNode;
    else
        l.next = newNode;//旧的尾部元素  指向 newNode，即添加newNode
    size++;
    modCount++;
}

//同理。链表头部添加元素
 private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}

get方法

get方法是根据索引获取元素的

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

//找到具体索引位置的  Node
Node<E> node(int index) {
    // assert isElementIndex(index);

	//类似二分法，size >> 1 即元素数量的一半
    if (index < (size >> 1)) {//索引小于一半，就从头开始找
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {//否则就从尾部开始找
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

remove方法

public boolean remove(Object o) {
	// 如果要删除的元素为 null
   if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
   } else {// 不为 null
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                 unlink(x);
                 return true;
            }
        }
   }
   //链表中没这个元素
   return false;
}

E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
	//要删除节点的下一个节点
    final Node<E> next = x.next;
	//要删除节点的前一个节点
    final Node<E> prev = x.prev;

    if (prev == null) {
		//没有前一个节点，说明删除的是第一个节点
        first = next;
    } else {
		//有前一个节点，就让前一个节点的next指向x的下一个节点
        prev.next = next;
		//当前节点的pre引用指向空，方便gc
        x.prev = null;
    }
	
    if (next == null) {
		//没有后一个节点，说明删除的是最后一个节点
        last = prev;
    } else {
		//有后一个节点，就让后一个节点的pre指向x的前一个节点
        next.prev = prev;
		//当前节点的next指向空，方便gc
        x.next = null;
   }
	
	//x的值指向null，方便gc
    x.item = null;
    size--;//数量-1
    modCount++;
    return element;
}

linklist是有序的，可重复存储数据的，并且可以存储null值，但remove方法在找到需要删除的元素时，就return了，因此只能删除找到的第一个元素

LinkedList<String> list = new LinkedList();
list.add("1");
list.add(null);
list.add(null);
list.add("1");
System.out.println(list);
list.remove(null);
list.remove("1");
System.out.println(list);
//输出：
[1, null, null, 1]
[null, 1]

ArrayList和Vector和CopyOnWriteArrayList和LinkedList

继承关系结构图：

ArrayList和Vector和CopyOnWriteArrayList的区别：

  • ArrayList非线程安全的，如果需要考虑到线程安全问题，那么可以使用Vector和CopyOnWriteArrayList；
  • Vector和CopyOnWriteArrayList的区别是：Vector增删改查方法都加了synchronized，保证同步，但是每个方法执行的时候都要去获得锁，性能就会大大下降，而CopyOnWriteArrayList 只是在增删改上加锁，但是读不加锁，在读方面的性能就好于Vector，CopyOnWriteArrayList支持读多写少的并发情况。

ArrayList和LinkedList的区别：

  • ArrayList基于动态数组实现；
  • LinkedList基于链表实现。对于随机index访问的get和set方法，ArrayList的速度要优于LinkedList。因为ArrayList直接通过数组下标直接找到元素；LinkedList要移动指针遍历每个元素直到找到为止。
  • 新增和删除元素，LinkedList的速度要优于ArrayList。因为ArrayList在新增和删除元素时，可能扩容和复制数组；LinkedList只需要修改指针即可。
Seven_97H
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArrayList和LinkedList详解
JSDHBIV的博客
06-13 226
ArrayList和LinkedList详解（基于jdk1.8）ArrayList集合ArrayList源码解析继承关系属性构造方法默认值扩容机制常用方法LinkedList集合LinkedList源码剖析继承关系属性构造方法默认值扩容机制常用方法ArrayList和LinkedList的区别应用场景 ArrayList集合 ArrayListList实现自AbstractList抽象类，是基于数组实现List接口的实现类。 特点：可以存储重复的数据，存入的数据是有序的（插入有序），可以存储NULL值。 A
ArrayList和LinkedList实现
zl5186888的博客
09-23 282
在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；Java基础，ArrayList和LinkedList在实际中已经使用很多了，探究一下他的底层实现。在add 中出现了modCount++，在 AbstractList中定义，
ArrayList和CopyOnWriteArrayList
a141210104的专栏
10-18 925
fail-Fast 机制，CopyOnWriteArratList 实现原理
9.2 ArrayList&CopyOnWriteArrayList详解
Mao_yafeng的博客
10-23 701
ArrayList是Java集合框架中的一个重要的类，它继承于AbstractList，实现了List接口，是一个长度可变的集合，提供了增删改查的功能，允许null的存在。ArrayList类还是实现了RandomAccess接口，可以对元素进行快速访问。实现了Serializable接口，说明ArrayList可以被序列化 。ArrayList线程不安全，线程安全的版本是CopyOnWriteArrayList。
ArrayList LinkedList Vector区别
08-22
ArrayList LinkedList Vector 区别 ArrayList、LinkedList、Vector 是 Java 中常用的数据结构实现类，它们都实现了 List 接口，但它们在存储方式、性能、线程安全性等方面有着不同特点。 首先，ArrayList 和 ...
java ArrayList和Vector的区别详解
09-01
在Java集合框架中，ArrayList和Vector是两种常用的动态数组实现，它们都继承自AbstractList，并且实现了List接口。虽然它们在基本功能上相似，但在线程安全性和扩容策略上存在显著差异。 首先，让我们来看看...
ArrayList LinkedList Vector性能测试
05-03
在Java编程语言中，ArrayList、LinkedList和Vector是三种常见的动态数组实现，它们都在java.util包中，用于存储和管理对象的集合。这三个类都实现了List接口，提供了多种操作方法，但它们在内部实现和性能特性上有所...
对ArrayList和LinkedList底层实现原理详解
08-26
ArrayList和LinkedList底层实现原理详解 ArrayList 底层实现方式的知识点： 1. ArrayList 底层实现方式：ArrayList 通过数组实现，一旦我们实例化 ArrayList 无参数构造函数默认为数组初始化长度为 10。 2. add ...
Java中ArrayList和LinkedList区别
12-22
在Java编程语言中，ArrayList和LinkedList都是集合框架中两种重要的列表实现，它们分别基于不同的数据结构，具有不同的特性和性能特点。以下是对这两个类的详细分析： 1. 数据结构： - ArrayList是基于动态数组的...
ArrayList和CopyOnWriteArrayList详解和源码剖析【扩容机制】
Charte的博客
03-15 1384
在此列表中的指定位置插入指定的元素。 先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
Java中的ArrayList和CopyOnWriteArrayList
旧巷里的旧少年
01-06 258
ArrayList是List接口的基本实现之一，它是Java Collections Framework的一部分。我们可以使用迭代器遍历ArrayList元素。 我们看看一下ArrayList的示例程序： package com.roin.concurrent; import java.util.ArrayList; import java.util.Iterator; import java...
【Java 并发编程】CopyOnWriterArrayList 详解
迪曼奥特迦-博客
09-22 377
CopyOnWriteArrayList 体现了写时复制的思想，增删改操作都是在复制的新数组中进行的；CopyOnWriteArrayList 的取值方法是弱一致性的，无法确保实时取到最新的数据；CopyOnWriteArrayList 的增删改方法通过可重入锁确保线程安全；CopyOnWriteArrayList 线程安全体现在多线程增删改不会抛出异常，并不能确保数据的强一致性；
CopyOnWriteArrayList解决同时添加删除
weixin_33795093的博客
12-06 1309
CopyOnWriteArrayList，因何而存在？ ArrayList的一个线程安全的变体，其所有可变操作（add、set 等）都是通过对底层数组进行一次新的复制来实现的，代价昂贵。 CopyOnWriteArrayList，是因”并发”而生。 CopyOnWriteArrayList，改了其中的某对象的某个值， 【场景一】对于Array...
CopyOnWriteArrayList特殊点, 对比ArrayList
weixin_39921298的博客
06-25 309
CopyOnWriteArrayList特殊点, 对比ArrayList ArrayList可以使用迭代器进行删除元素, CopyOnWriteArrayList不能使用迭代器的remove方法删除, 只能使用集合的remove方法删除 public class Demo15 { public static void main(String[] args) { // 使用ArrayList的iterator删除元素 List<String> list1
Java内存模型
最新发布
weixin_44267758的博客
07-19 316
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
arraylist和linkedlist vector
04-29
ArrayList、LinkedList和Vector都是Java中的集合类，用于存储和操作一组对象。 ArrayList和Vector都是基于动态数组实现的。它们支持快速随机访问，但在插入和删除元素时性能较差，因为需要移动后续元素。ArrayList...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值