Java集合详解1——List

Myth丶恋晨 2022-11-20 04:53 220阅读 0赞

### Java集合详解1——List ###

*  集合大纲
 *   *  集合框架结构图
     *  集合与数组的区别
     *  集合中的方法
     *  List、Set和Map
     *   *  List
         *  List的遍历
         *  线程安全的List：CopyOnWriteArrayList

# 集合大纲 #

## 集合框架结构图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]

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

## 集合与数组的区别 ##

1.  **长度区别**

*  数组长度固定
 *  集合可变

1.  **内容区别**

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

1.  **元素内容**

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

## 集合中的方法 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]

## List、Set和Map ##

### List ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]  
**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 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]

*  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][Java_2_Set]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/5ae2e37e98b945b99aa7f2247e35731d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/78bf4509560849f0bae419dd2ee16d5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/251a063a8a0240368166e3a14ae6aefd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/fac8408656f04a97a60cdd03c23e7919.png
[Java_2_Set]: https://blog.csdn.net/qq_41510551/article/details/109579064