Java集合详解——List

程序员文章站 2022-07-05 09:41:53

Java集合详解1集合大纲集合框架结构图集合与数组的区别集合大纲集合框架结构图集合与数组的区别长度区别数组长度固定集合可变内容区别数组可以是基本类型，也可以是引用类型集合只能是引用类型元素内容数组只能存储同一种数据类型集合可以存储不同数据类型（集合一般也存储同一种数据类型）......

Java集合详解1——List

集合大纲

集合大纲

集合框架结构图

Java集合详解——List

可以看出：List和Set都是继承自Collection，Map为独立接口
Set下有HashSet，LinkedHashSet，TreeSet
List下有ArrayList，Vector，LinkedList
Map下有Hashtable，LinkedHashMap，HashMap，TreeMap
Collection接口下还有个Queue接口，有PriorityQueue类

集合与数组的区别

长度区别

数组长度固定
集合可变

内容区别

数组可以是基本类型，也可以是引用类型
集合只能是引用类型

元素内容

数组只能存储同一种数据类型
集合可以存储不同数据类型（集合一般也存储同一种数据类型）

集合中的方法

Java集合详解——List

List、Set和Map

List

Java集合详解——List
List 有序、可重复
常用的实现List接口的主要有ArrayList、Vector、LinkedList 三个

ArrayList
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
底层源码

	/**
     * Default initial capacity.默认大小
     */
    private static final int DEFAULT_CAPACITY = 10;
    //最大长度（2 147 483 647-8）
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//扩容机制：oldCapacity >> 1  移位运算，此处相当于oldCapacity除以2，但是 >> 这种写法更加高效，JDK1.6：newCapacity = ( oldCapacity * 3 ) / 2 +1 ;
	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);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    public boolean add(E e) {//添加
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    public E get(int index) {//获取指定位置的元素
        rangeCheck(index);

        return elementData(index);
    }
    public E set(int index, E element) {//替换指定位置的元素
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
    //在指定位置添加元素，如果当前位置存在元素，将当前元素和后续元素已到右边
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
    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 remove(Object o) {//如果指定对象出现，删除出现的第一个，如果不包含，则不改动
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
    public void clear() {//清空列表
        modCount++;
        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;
        size = 0;
    }

Vector
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
底层源码

	//初始容量为10
	public Vector() {this(10);}
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
	//传一个参数（容量大小） 容量大小即底层数组大小
public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

	//传两个参数（容量大小，容量修正） 容量修正即扩容时的增加量
	public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }
	//扩容机制：如果构造时写入了初始大小和容量修正，则按照参数增加，否则就是old+old
	//JDK1.6：扩容是newCapacity = ( capacityIncrement > 0 ) ? ( oldCapacity + capacityIncrement ) : (  oldCapacity  * 2 );
	 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    //从0开始查找是否含有对象o，如果存在，返回第一次出现的位置
    public int indexOf(Object o) {
        return indexOf(o, 0);
    }
    //加了synchronized所以是线程安全的，从指定位置开始查找
    public synchronized int indexOf(Object o, int index) {
        if (o == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    //返回指定索引处的元素
    public synchronized E elementAt(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
        }

        return elementData(index);
    }
    //再指定位置插入，原位置的元素将被丢弃
    public synchronized void setElementAt(E obj, int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        elementData[index] = obj;
    }
    //添加元素
    public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

LinkedList
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高
底层源码

	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;
        }
    }
    /**
     * Links e as first element.链表的第一个元素
     */
    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++;
    }

    /**
     * Links e as last element.向链表尾部添加一个元素
     */
    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++;
    }
    //将元素插入到非空节点succ前
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }
    public E getFirst() {//获取头节点
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }
    public E getLast() {//获取尾节点
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }
    public boolean add(E e) {//添加
        linkLast(e);
        return true;
    }
    public boolean remove(Object o) {//移除指定元素
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
     public E get(int index) {//获得指定位置的原
        checkElementIndex(index);
        return node(index).item;
    }
    public E set(int index, E element) {//替换指定位置的元素
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }
    public void add(int index, E element) {//向指定位置添加元素
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, 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;
        }
    }

List的遍历

	//1、for循环遍历
	for(int i=0; i<list.size(); i++){
            System.out.println(list.get(i)+"  ");
    }
    //2、foreach循环遍历
    for (String l:list) {
            System.out.println(l);
        }
    //3、迭代器遍历
    Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    //4、流式编程遍历
    list.stream().forEach(System.out::println);

建议使用Foreach语法遍历或者迭代器遍历。

线程安全的List：CopyOnWriteArrayList

Java集合详解——List

Copy-On-Write即COW通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。对CopyOnWrite容器进行并发的读的时候，不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，延时更新的策略是通过在写的时候针对的是不同的数据容器来实现的，放弃数据实时性达到数据的最终一致性。
底层源码

	/** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();
    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;
   
 //添加
    public boolean add(E e) {
   final ReentrantLock lock = this.lock;
 //1. 使用Lock,保证写线程在同一时刻只有一个
   lock.lock();
   try {
   //2. 获取旧数组引用
       Object[] elements = getArray();
       int len = elements.length;
   //3. 创建新的数组，并将旧数组的数据复制到新数组中
       Object[] newElements = Arrays.copyOf(elements, len + 1);
   //4. 往新数组中添加新的数据          
   newElements[len] = e;
   //5. 将旧数组引用指向新的数组
       setArray(newElements);
       return true;
   } finally {
       lock.unlock();
   }
}

采用ReentrantLock，保证同一时刻只有一个写线程正在进行数组的复制，否则的话内存中会有多份被复制的数据；
数组引用是volatile修饰的，因此将旧的数组引用指向新的数组，根据volatile的happens-before规则，写线程对数组引用的修改对读线程是可见的。
由于在写数据的时候，是在新的数组中插入数据的，从而保证读写实在两个不同的数据容器中进行操作。

//在指定位置添加，如果当前位置存在，则右移
public void add(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (index > len || index < 0)
                throw new IndexOutOfBoundsException("Index: "+index+
                                                    ", Size: "+len);
            Object[] newElements;
            int numMoved = len - index;
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                newElements = new Object[len + 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            newElements[index] = element;
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }
    //移除指定位置元素
    public E remove(int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            E oldValue = get(elements, index);
            int numMoved = len - index - 1;
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                Object[] newElements = new Object[len - 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                setArray(newElements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

COW与读写锁

相同点：1. 两者都是通过读写分离的思想实现；
2.读线程间是互不阻塞的
不同点：对读线程而言，为了实现数据实时性，在写锁被获取后，读线程会等待或者当读锁被获取后，写线程会等待，从而解决“脏读”等问题。也就是说如果使用读写锁依然会出现读线程阻塞等待的情况。而COW则完全放开了牺牲数据实时性而保证数据最终一致性，即读线程对数据的更新是延时感知的，因此读线程不会存在等待的情况。

COW的缺点

CopyOnWrite容器有很多优点，但是同时也存在两个问题，即内存占用问题和数据一致性问题。所以在开发的时候需要注意一下。
内存占用问题：因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。如果这些对象占用的内存比较大，比如说200M左右，那么再写入100M数据进去，内存就会占用300M，那么这个时候很有可能造成频繁的minor GC和major GC。
数据一致性问题：CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

下一篇：Java集合详解2——Set

本文地址：https://blog.csdn.net/qq_41510551/article/details/109561893

相关标签： Java基础列表数据结构 java 链表

上一篇： Kafka producer端开发代码实例

下一篇：使用带 head 头的单向链表实现

Java集合详解——List

Java集合详解1——List

集合大纲

集合框架结构图

集合与数组的区别

集合中的方法

List、Set和Map

List

List的遍历

线程安全的List：CopyOnWriteArrayList

Python3.5集合及其常见运算实例详解

Java8增强的Map集合

Java 集合系列（四）—— ListIterator 源码分析

java生成随机字符串数组（java代码大全及详解）

python中list常用操作实例详解

详解JAVA里面获取map的key和value的方法

JAVA多线程编程实例详解

Java 遍历取出Map集合key-value数据的4种方法

java操作(DOM、SAX、JDOM、DOM4J)xml方式的四种比较与详解

详解在LINUX上部署带有JAR包的JAVA项目