Java基础之集合List（ArrayList， LinkedList 和 Vector 的区别）

最新推荐文章于 2024-05-13 17:24:10 发布
最新推荐文章于 2024-05-13 17:24:10 发布
阅读量1.1k 收藏 7
点赞数 1
分类专栏： Java开发手册 后端 文章标签： JAVA ArrayList LinkedList和Vector ArrayList LinkedList和Vector的区别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzq199528/article/details/100076085
版权

List

List是一个接口，实现类常用的有 ArrayList,LinkedList和Vector

ArrayList

1. 基于数组实现的的， 根据容量大小利用Arrays.copyOf方法实现动态扩容。
源码

    // elementData 动态数组
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    // DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是{} 空数组， DEFAULT_CAPACITY是10
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
    // 可见list数组的默认长度为10
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }    

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

简单的实现原理

public class ListDemo {

    // 定义初始数组
    String[] arr = {};

    // 数组扩容
    public void dilatation(int capacity) {
        arr = Arrays.copyOf(arr, capacity);

    }

    public static void main(String[] a) {
        ListDemo listDemo = new ListDemo();
        System.out.println(listDemo.arr.length);
        System.out.println(Arrays.toString(listDemo.arr));
        // 扩容后给数组赋值
        listDemo.dilatation(1);
        listDemo.arr[0] = "222";
        System.out.println(listDemo.arr.length);
        System.out.println(Arrays.toString(listDemo.arr));
          // 扩容后给数组赋值
        listDemo.dilatation(2);
        listDemo.arr[1] = "333";
        System.out.println(listDemo.arr.length);
        System.out.println(Arrays.toString(listDemo.arr));
    }

}
2. ArrayList 是有序的，可以看到新增的数据是根据size，集合的大小插入的
源码
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
3. ArrayList 中查询更快捷，因为是根据数组下标进行查询。
源码
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }
    
    E elementData(int index) {
        return (E) elementData[index];
    }
4. ArrayList 添加删除操作效率低，是因为每次增加或删除时要对数组容量进行修改。 System.arraycopy()实现数组的复制
System.arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);

src 原数组
srcPos 原数组复制的起始位置（下标）
dest 目标数组
destPos 目标数组的起始位置（下标）
length 复制数组的长度


举例
    public static void main(String[] a) {
        // 我要将 4,7,9 替换成了7,9,8
        Integer[] arr = {2,6,5,4,7,9,8,1,3};

        // 将 arr源数组从第下标4 开始复制3位 也就是 7,9,8  替换arr目标数组中下标3 开始的三位4,7,9。也就是将 4,7,9 替换成了7,9,8
        System.arraycopy(arr, 4, arr, 3, 3 );

        System.out.println(Arrays.toString(arr));
    }


源码
    // 删除
    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;
    }
    // 添加
    
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    // DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是{} 空数组， DEFAULT_CAPACITY是10
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
    // 可见list数组的默认长度为10
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }    

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }
5. ArrayList 对于修改效率高，因为是根据下标直接获取到目标对象，直接修改
源码
    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

LinkedList

LinkedList源码中有这样几个对象属性

  1. first 第一个节点
  2. last 最后一个节点

节点类有这样几个信息

  1. item 本身的信息
  2. next 下一个节点对象
  3. prev 上一个节点对象
源码
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
1. 基于链表实现，每一个节点中都会保存当前节点，上一个节点和下一个节点。
2. 添加更快捷，因为不需要跟ArrayList一样需要考虑容量问题。只需要创建新的节点，就行了。
源码
    public boolean add(E e) {
        linkLast(e);
        return true;
    }
    
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
3. 删除我不认为会快捷多少。因为链表也不能直接找到要删除的节点，只能根据第一个节点和最后一个节点来找
源码
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }
    
        Node<E> node(int index) {
        // assert isElementIndex(index);

        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;
        }
    }
    
        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 {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

源码说明：

  1. 调用remove(int index) 删除
  2. 程序或根据node(int index) 找到要删除的节点。这块我认为数据量大的时候也是很耗时的。
    先根据集合大小和查找对象的位置决定是从最后一个开始比对还是从第一个节点开始比对。最终获取要删除的节点
  3. unlink(Node x) 删除节点方法。根据x节点的信息，取出上一个节点（prev）和下一个节点（prev）。将上一个节点保存的下一个节点修改为x节点的下一个节点，将下一个节点的上一个节点修改为x节点的上一个节点，最后删除此节点
4. 修改数据 也要执行node(int index) 找到要修改的节点，然后直接修改此节点的item信息
5. 查询会比ArrayList慢很多了。也是因为执行node(int index) 在数据量大时比较耗时
6. LinkedList也是有序的

总结 ArrayList 和 LinkedList 的区别

  1. ArrayList是基于数组实现的，LinkedList是基于链表实现的
  2. 在ArrayList中查找和修改数据会比LinkedList中快很多
  3. LinkedList新增数据会比ArrayList快很多
  4. 对于删除我觉得两个都是很费时的。ArrayList删除时，是将删除元素之后的数据，复制进原数组从删除元素开始的位置，在将列表最后一个元素设为null。而LinkedList因为不能直接定位到要删除的节点。所以也是比较费时。

Vector

Vector也是一个类似于ArrayList的是的可变长度的数组类型，它的内部也是使用数组来存放数据对象的。
但不同于ArrayList的是Vector类中的操作集合的方法基本都是synchronized关键字修饰的。也就是线程安全的

    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    public synchronized E set(int index, E element) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
    .
    .
    .

List遍历

        List<String> list = new ArrayList<>();
        list.add("sss");
        list.add("ddd");

        // 第一种（jdk1.8）
        list.forEach(str -> {
            System.out.println(str);
        });

        // 第二种
        for (String s : list) {
            System.out.println(s);
        }

        // 第三种
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
lzq199528
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合排序 Collections.sort用法
hjl21的博客
08-06 7921
大半夜,一同学来问这段代码.问了三个问题. 一,这个排序Sort()怎么用? 二,接口作为方法的参数是什么意思? 三,入参直接new Comparator(){}是怎么回事? 先回答第二,三个问题: 二,接口入参,意思就是:你需要传入一个实现了该接口的对象. 三,入参直接new Comparator(){};这是个匿名内部类(不知道的去问度娘),这个有什么用?没啥用!这跟你去新建个类,实现Comparator接口的compare方法,然后再new 对象放到参数里的效果是一样的.匿名内部类的用途.
JAVA中的List、Vector、ArrayList的差异
qq_42653444的博客
05-05 256
JAVA中的LinkedList、Vector、ArrayList的差异 SDK提供了有序集合接口java.util.List的几种实现，其中三种最为人们熟知的是Vector、ArrayList和LinkedList。有关这些List类的性能差别是一个经常被问及的问题。在这篇文章中，我要探讨的就是LinkedList、Vector、ArrayList之间的性能差异。为全面分析这些类之间的性能差异，...
ConcurrentHashMap的实现原理(JDK1.7和JDK1.8)
jiaoyajieqianyi的博客
11-19 961
http://youzhixueyuan.com/concurrenthashmap.html HashMap、CurrentHashMap 的实现原理基本都是BAT面试必考内容，阿里P8架构师谈：深入探讨HashMap的底层结构、原理、扩容机制深入谈过hashmap的实现原理以及在JDK 1.8的实现区别，今天主要谈CurrentHashMap的实现原理，以及在JDK1.7和1.8的区别。 ...
Java 集合排序：Collections.sort() 方法详解
最新发布
一个普通人
05-13 1537
是 Java 中类的一个静态方法，用于对实现了List接口的集合进行排序。该方法使用默认的自然顺序或者通过提供的Comparator接口来进行排序。除了使用默认的自然顺序外，我们还可以通过提供自定义的Comparator来实现排序。
concurrentHashMap原理
qq_56800327的博客
08-29 334
concurrentHashMap的原理
使用Collections.sort方法来对自定义对象进行排序
热门推荐
Clang’s Blog
01-28 1万+
Collections.sort() 可以通过传入一个Comparator来排序，这个Comparator里面有一个compare方法。如果返回值是0，则认为这两个对象相等；如果返回值是小于0的整数，则认为第一个对象小于第二个对象。要实现这一点，需要在调用该方法时传入一个比较器，该比较器用于指定如何比较对象中的值。请注意，如果需要按照降序排序，可以在compare方法中返回p2.getAge() - p1.getAge()。这样就可以按照person对象的age属性进行排序，也可以按照其他属性排序。
ArrayList LinkedList Vector区别
08-22
ArrayList LinkedList Vector 区别 ArrayList、LinkedList、Vector 是 Java 中常用的数据结构实现类，它们都实现了 List 接口，但它们在存储方式、性能、线程安全性等方面有着不同特点。 首先，ArrayList 和 ...
Java中Vector与ArrayList的区别详解
09-05
Java中的ArrayList和Vector都是列表（List）接口的实现类，它们在功能上相似，但在细节上存在一些重要的差异。这两个类都是基于数组实现的，但它们的性能特点、线程安全性和扩容策略有所不同。 1. **扩容策略**： ...
Java 各种集合的区别ArrayList Vector LinkedList map区别
03-30
今天，我们将深入了解 Java 中的集合类别，包括 ArrayList、Vector、LinkedList 和 Map 等。 ArrayList ArrayList 是一种基于数组的集合类别，它可以存储大量的数据。ArrayList 的特点是：它可以动态地增加或减少...
浅谈 java中ArrayList、Vector、LinkedList的区别联系
09-03
在Java编程语言中，ArrayList、Vector和LinkedList是三个常见的列表实现，它们都实现了List接口，因此都支持元素的增删改查操作。然而，它们在内部实现和性能特性上存在显著差异。 首先，ArrayList和Vector都是基于...
Java中的Vector和ArrayList区别及比较
09-03
Java中的`Vector`和`ArrayList`都是`List`接口的实现类，它们都用于存储可变大小的有序对象集合。然而，尽管它们有许多相似之处，但也存在显著的区别，主要体现在API、同步、数据增长和使用模式这四个方面。 1. API...
Java 中的vector和list的区别和使用实例详解
08-29
在大家还没有了解vector,list,deque的知识之前，我先给大家介绍下stl，本文重点给大家介绍vector和list的区别及使用，感兴趣的的朋友一起看看吧
Map集合之ConcurrentHashMap
桐花思雨
01-21 689
ConcurrentHashMap 与 HashTable 与 HashMap 的比较 HashMap 在并发环境下，可能会形成环状链表(扩容时可能造成)，导致 get 操作时，cpu 空转，所以，在并发环境中使用 HashMap 是非常危险的。并且它是线程不安全的 HashTable HashTable 是线程安全的。HashTable 线程安全的策略实现代价却比较大，get/put 所有相关操作都是 synchronized 的，这相当于给整个哈希表加了一把大锁，多线程访问时候，只要有一个线程访问或操作
老生常谈的ConcurrentHashMap实现原理详解
hello__word__的博客
10-12 1783
Jdk 1.7 之前，ConcurrentHashMap 通过加锁保证线程安全，并引入锁分段机制以减小加锁的粒度，从而提升性能。Jdk 1.8 中的 ConcurrentHashMap 实现则引入了 CAS 机制以尽量避免加锁操作，虽然仍然有部分同步代码，不过锁的粒度相对于分段锁而言更加细粒度。另外一个重要的设计就是在结点个数达到阈值时会自动将链表转换成红黑树，从而进一步提升性能。 存储结构设计 在存储结构设计上，新的 ConcurrentHashMap 相对于之前看起来更加的简洁。如下图，在一个 Node
Vector、ArrayList、LinkedList区别
qq_56754651的博客
08-02 225
都实现了集合框架中的List，有序集合，具体功能比较近似，都能提供按照位置进行定位，添加或删除的操作，都提供迭代器以遍历其内容。在行为、性能、线程安全等方面有所区别。 是什么： 1.Vector 是Java 早期提供的线程安全的动态数组（同步是有额外开销的），Vector内部是使用对象数组来保存数据，可以根据需要自动增加容量，当数组已满时，会创建新的数组，并拷贝原有数组数据，扩容时会提高1倍。 2.ArrayList 是线程不安全的动态数组，性能好很多，与V...
ConcurrentHashMap：使用方法和底层原理详解
jakelihua
04-07 2668
ConcurrentHashMap是Java集合框架中的一个线程安全的哈希表实现，它提供了比Hashtable和同步的HashMap更高的并发性能。ConcurrentHashMap在JDK 1.5中引入，通过采用分段锁的方式实现了高效的并发访问。它可以在保证线程安全的同时，提供较高的并发性能，因此是多线程环境下使用频率较高的数据结构之一。
ConcurrentHashMap实现原理
qq_39625353的博客
06-29 2514
map是大家日常coding最常用的容器之一，但是大家熟知的hashMap是线程不安全，所以在多线程情况下，需要一个安全的并发容器，大家首选的肯定是ConcurrentHashMap，但是他的原理到底是怎么实现的，下面简单看一下源码，因为jdk1.7和1.8的实现不一样，所以分开分析 1. ConcurrentHashMap 1.7 1. 存储结构 Java 7 中 ConcurrentHashMap 的存储结构如上图，ConcurrnetHashMap 由很多个 Segment 组合，而每一个
ConcurrentHashMap底层实现原理
huangqingfeng的博客
04-19 6654
1. ConcurrentHashMap的整体架构 如图，这是ConcurrentHashMap在jdk1.8中的存储结构，它是由数据，单项链表，红黑树来构成，当我们去初始化一个ConcurrentHashMap实例的时候，默认会初始化一个长度等于16的数组，由于ConcurrentHashMap它的核心仍然是Hash表，所以必然会存在Hash冲突的问题，所以ConcurrentHashMap采用链式寻址的方式，来解决Hash表的冲突，当Hash冲突比较多的时候，会造成链表长度较长的问题，这种会使得Con
java ArrayList LinkedList vector区别
07-23
Java中的ArrayList、LinkedList和Vector是三种常见的集合类，它们都实现了List接口，但在实现和使用上有一些区别。 1. 实现方式： - ArrayList是基于数组实现的动态数组，可以动态调整数组的大小。 - LinkedList是基于链表实现的，每个元素都包含一个指向前一个和后一个元素的引用。 - Vector也是基于数组实现的动态数组，类似于ArrayList，但是它是线程安全的。 2. 线程安全性： - ArrayList和LinkedList不是线程安全的，多个线程同时访问时需要外部同步控制。 - Vector是线程安全的，它的每个方法都使用了synchronized关键字进行同步，可以在多线程环境下使用。 3. 性能： - ArrayList的性能比LinkedList好，因为它直接通过索引访问元素，而LinkedList需要遍历链表才能找到指定位置的元素。 - Vector由于需要进行同步控制，性能相对较差。 4. 插入和删除操作： - ArrayList在末尾插入和删除元素的性能较好，但在中间或开头插入和删除元素时，需要移动其他元素。 - LinkedList在任意位置插入和删除元素的性能较好，因为只需更改节点的引用。 5. 使用场景： - 如果需要频繁访问集合中的元素，并且对数据的增删操作较少，可以选择ArrayList。 - 如果需要频繁进行插入和删除操作，或者需要使用栈、队列等数据结构，可以选择LinkedList。 - 如果需要在多线程环境中使用，可以选择Vector。 总结：ArrayList适用于读取操作频繁的场景，LinkedList适用于频繁插入、删除操作的场景，Vector适用于多线程环境。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值