单列集合的学习

于 2020-04-16 21:41:32 发布
阅读量149 收藏
点赞数
分类专栏： java相关学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41842356/article/details/105567759
版权

单列集合

1、list、set、map的区别

​ 答：list接口存储一组不唯一（可以有多个元素引用相同的对象），有序的对象。set存储唯一的元素，且是无序的。map是使用键值对来存储的，key值不能重复

2、ArrayList与LinkedList区别

​ 相同：都是线程不安全的

​ 不同：ArrayList的底层是基于Object[]数组，而LinkList底层是基于双向链表的数据结构（JDK1.6之前是双向循环链表，JDK1.7之后取消为双向链表）

​ 对于插入元素以及删除元素来说，ArrayList默认是在数组的末尾插入元素，此时时间复杂度为O（1),如果指定位置插入，则时间复杂度为O（n-i），因为进行插入删除操作时，n-i位元素需要向后推移一位。LinkedList插入删除元素时时间复杂度近似O(1)，指定位置进行插入删除时，时间复杂度为O(n)，因为要移动到某个位置进行插入删除操作

​ 对于快速访问元素上，ArrayList更具有优势，可以通过元素的下标快速定位到元素的值

​ 内存占用方面上看，ArrayList主要体现在list后面的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在每一个元素都需要花费更大的内存空间来存储前驱元素以及后继元素

3、ArrayList与Vector的区别

​ Vector的线程安全，而ArrayList的线程不安全，因此当从效率来讲，优先选择ArrayList

4、ArrayList的扩容机制

​ 以无参方法构造的ArrayList，初始化赋值的是一个空数组，当在执行add操作时，进行扩容操作，将数组设置为规定的初始化容量10，当继续进行添加元素，数组的容量不够时，继续进行扩容操作，将原数组的容量+容量右移1位的值（即扩充到原来的1.5倍），当扩容后的容量仍旧小于需要的容量时，数组容量等于需要的容量，当新的容量大于Integer,MAX_VALUE-8时，将需要的容量与Integer,MAX_VALUE-8进行比较，大于则新容量为Integer,MAX_VALUE，小于则新容量为Integer,MAX_VALUE-8。这相当于一个阈值控制操作，最小阈值不能低于需要的长度，最高阈值不能高于Integer.MAX_VALUE。每进行一次add操作的时候都会调用下ensureCapacityInternal方法判断是否需要扩容。

​ 具体的源码如下：MAX_VALUE

​ 初始化的构造函数

 /**
     * 默认初始容量大小
     */
    private static final int DEFAULT_CAPACITY = 10;
    

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     *默认构造函数，使用初始容量10构造一个空列表(无参数构造)
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    /**
     * 带初始容量参数的构造函数。（用户自己指定容量）
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {//初始容量大于0
            //创建initialCapacity大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {//初始容量等于0
            //创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {//初始容量小于0，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }


   /**
    *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
    *如果指定的集合为null，throws NullPointerException。 
    */
     public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

进行add时的扩容机制

  /**
     * 将指定的元素追加到此列表的末尾。 
     */
    public boolean add(E e) {
   //添加元素之前，先调用ensureCapacityInternal方法
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[size++] = e;
        return true;
    }
    
     //得到最小扩容量
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              // 获取默认的容量和传入参数的较大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
     //判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //调用grow方法进行扩容，调用此方法代表已经开始扩容了
            grow(minCapacity);
    }

扩容的核心

 /**
     * 要分配的最大数组大小
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * ArrayList扩容的核心方法。
     */
    private void grow(int minCapacity) {
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
        //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
       // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
       //如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
        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();
        //对minCapacity和MAX_ARRAY_SIZE进行比较
        //若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
        //若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
        //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

5、关于ArrayList的ensureCapaCity方法

在ArrayList的源码里，没有调用到ensureCapacity的方法，那这个是给用户调用的。主要是提前告知ArrayList进行扩容操作，当进行大容量的数据扩充的时候，提前告知需要扩充的容量，这样就可以避免每次容量不够时都需要花费时间去扩充容量。

  /**
    如有必要，增加此 ArrayList 实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。
     *
     * @param   minCapacity   所需的最小容量
     */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);    //进行扩容操作，将容量提前扩充到需要的长度
        }
    }

6、LinkedList

​ LinkedList底层是一个双向链表，当数据量很大或者进行频繁的删除插入操作时比较适合LinkedList。linkedList的每个节点用内部类Node表示，当链表为空时，first和last都是一个null值

//Node节点的代码
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;
        }
    }

增加元素，提供add(E e) 、 addFirst(E e)、addLast(E e) 、**add(int index, E element)**方法，其中add是在链表的末尾添加元素，addFirst是在链表的头部添加元素，add(int index, E element)是链表的指定位置插入元素

删除元素提供remove(Object o)、 remove(int index)、removeFirst()、removeLast()、remove()，这里需要注意的是，remove()方法是删除链表头部的元素。源码如下：

 public E remove() {
        return removeFirst();
    }
    //调用removeFirst的方法，相当于removeFirst

获取元素的方法get(int index)、getFirst()、getLast()、

7、Set集合

​ 特征：无序，且元素不可重复

HashSet

​ 底层为维护了一个HashMap，所以存储元素是存储到hash表中，根据存储元素的hashCode值来计算出元素所存储的位置，如果hashCode计算出的位置存在别的元素，则通过对象的equals方法比较该对象，如果返回true，则添加的元素相同，不添加，返回false，则添加到该HashCode值中的链表中

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;
    //维护一个hashMap，再构造函数初始化对象的时候进行初始化HashMap
    private transient HashMap<E,Object> map;

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

    /**
     * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
     * default initial capacity (16) and load factor (0.75).
     */
    public HashSet() {
        map = new HashMap<>();
    }
     public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }
    
    //add元素操作，相当于用HashMap将元素当成key值put到哈希表
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

LinkedHashSet

继承于HashSet,底层实现跟HashSet一样，也是采用哈希表来实现。所不同的时，底层还维护了一个链表，但add进一个元素的时后，就将链表指向这个元素。遍历该Set集合的时候，元素是按先后顺序排列返回

TreeSet

能够确保加进去的元素是有序的。底层采用红黑树，具体的add流程如下图：

img

大致是说TreeSet的add元素流程，会先进行头节点的插入，之后元素的插入时与头节点进行比较，大于则在头节点的右边，小于则在左边，等于则不加入。取出时是按左中右的顺序取出，即从小到大的顺序取出元素。实现TreeSet的有序性

因为TreeSet的这个特性，所以TreeSet不能随意添加对象元素，如果要添加对象元素，该对象元素必须实现Comparable接口，并重写它的compareTo方法。此时TreeSet添加对象元素，会根据compareTo返回的结果来判断对象的大小。如果返回0则判断对象相等，不加进红黑树中，1则大于，-1则小于

这种排序方法也属于TreeSet的定制排序

TreeSet有两种排序规则，一种是自然排序，即刚刚的从小到大，另一种是定制排序，通过自己实现Comparable或Comparator接口来定制自己的排序。

//定制从大到小的排序，在进行TreeSet的实例化的时候，传入定制的比较器
 TreeSet<Integer> nums = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return -(o1-o2);
            }
        });
        //向集合中添加元素
        nums.add(5);
        nums.add(2);
        nums.add(15);
        nums.add(-4);
        //输出集合，可以看到元素已经处于排序状态
        System.out.println(nums);//[15, 5, 2, -4]

EnumSet

是一个专门为存储枚举定义的集合，存储的所有元素都必须为指定枚举的枚举值。是有序的，顺序为元素在枚举中定义的顺序元素，该类没有构造器来创造该对象，可以通过以下方法创造

EnumSet allOf(Class elementType)：创建一个包含指定枚举类里所有枚举值的EnumSet集合。
EnumSet complementOf(EnumSet s)：创建一个其元素类型与指定EnumSet里元素类型相同的EnumSet集合，新的集合里包含原集合不包含的枚举值。
EnumSet copyOf(Collection c)：使用一个普通集合来创建EnumSet集合；
EnumSet copyOf(EnumSet s):复制原集合；
EnumSet noneOf(Class elementType):创建一个元素类型为指定枚举类型的空EnumSet；
EnumSet of(E first，E...rest):创建一个包含一个或多个枚举值的EnumSet集合。传入的枚举值必须是同一枚举类。
EnumSet range(E from,E to):创建一个包含从from到to枚举值范围所有枚举值的EnumSet集合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值