java-集合学习之单列集合List、Set

集合

• 集合理解
  1. 可以动态保存任意多个对象，使用方便
  2. 集合主要分为 单列集合、双列集合（键值对）

集合框架体系

• 单列集合 collecttion
  

• 双列集合 map
  

Collection接口和常用方法

• Collection接口常用方法

  add: 添加单个元素
  remove: 删除指定元素
  contains: 查找元素是否存在
  size: 获取元素个数
  isEmpty: 判断是否为空
  cLear: 清空
  addAll: 添加多个元素
  containsALL: 查找多个元素是否都存在
  removeALL: 删除多个元素

• Collection 遍历集合方式

  • 1. iterator迭代器
       Iterator接口方法：

    hasNext()：判断是否有下一个元素
    next()：返回下一个元素
    remove()：从基础集合中移除选代器返回的最后一个元素（可选操作)。

  • 2. 增强for循环

    增强for，底层仍然是迭代器，
    增强for可以理解成就是简化版本的 迭代器遍历

List接口的常用方法

1. List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复。
2. List集合中的每个元素都有其对应的顺序索引，即支持索引（索引从0开始）。
3. List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

• List 集合里添加了一些根据索引来操作集合元素的方法
  1.void add(int index, Object ele):在index位置插入ele元素
  2.boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
  3.Object get(int index):获取指定index位置的元素
  4.int indexof(Object obj):返回obi在集合中首次出现的位置
  5.int lastIndexof(Object obj):返回obj在当前集合中未次出现的位置
  6.Object remove(int index):移除指定index位置的元素，并返回此元素
  7.Object set(int index, Object ele):设置指定index位置的元素为ele相当于是替换.
  8.List subList(int fromlndex, int tolndex):返四从fromIndex至tolndex位置的子集合（前闭后开）

• List常用实现子类为ArrayList、LinkLsit、Vector

  1. ArrayList和Vector基本等同，除了ArrayList线程不安全（没有sychornized关键字）多线程情况不建议用ArrayList
  2. ArrayList是由数组来实现数据存储的

ArrayList底层结构和源码分析

1. ArrayList中维护了一个Object类型的数组elementData
transient Object[] elementData;（transient 表示该属性不会被序列化，表示瞬间短暂的）
2. 当创建ArrayList对象时，如果使用的无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，若再次扩容，则扩容elementData为1.5倍。
3. 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果扩容，则直接扩容elementData为1.5倍。

源码分析：

Vector介绍·底层结构、源码

1. Vector底层也是一个对象数组
protected Object[] elementData;
2. Vector 是线程同步的，即线程安全，Vector类的操作方法带有synchronized
3. 在开发中，需要线程同步安全时，考虑使用Vector

Vector参构造器
使用无参构造器，也会调用有参构造器赋值默认容量为10
Vector 底层扩容方法：
capacityIncremen ：可以指定扩容量，如果不指定，默认扩容2倍

• ArrayList和Vector比较
  

LinkedList介绍·底层结构、源码分析

1. LinkedList 底层实现了双向链表和双端队列特点
2. 可以添加任意元素（元素可以重复、null）
3. 线程不安全，没有实现同步

• LinkedList底层维护了一个双向链表。
• LinkedList中维护了2个属性first和last分别指向 首节点和尾节点
• 每个节点（Node），里面又维护了prev、next、item三个属性，其中通过 prev 指向前一个，通过next 指向后一个节点。最终实现双向链表。

LinkedList底层结构

//无参构造器创建LinkedLIst
LinkedList<Object> linkedList = new LinkedList<>();
//源码使用public LinkedList() {}
//添加数据
linkedList.add(2);

1. LinkedList linkedList = new LinkedListO:public LinkedList()
   2.这时 LinkeList 的属性 first = null last = null
   3.执行 添加
   
   4.将新的结点，加入到双向链表的最后

• ArrayList和LinkedList比较
  1. 如果改查的操作多时，选择ArrayList
  2. 如果增删的操作多时，选择LinkedList
  3. 在一个项目中可以根据业务灵活度来选择，一个模块用ArrayList，一个模块用LinkedList

Set接口和常用方法

• Set是无序的（添加和取出的顺序不一样，但是取出顺序是固定的，多次取出顺序是一样的），没有索引

• Set不允许添加重复元素，所以最多包含一个null

• Set接口常用的实现类有 hashSet、TreeSet

• Set和List一样是Collection的子接口，因此常用方法和Collection接口一样

• Set接口的遍历方式和Collection一样（Iterator、增强for），但是不能用索引的方式来获取

        Set set = new HashSet();

        set.add("aaa");
        set.add("bbb");
        set.add("bbb");//重复添加元素还是只有一个
        set.add("ccc");
        set.add("xxx");
        set.add("zzz");
        set.add(null);
        set.add("yyy");

        System.out.println(set);

        //遍历
        //方式1--迭代器
        System.out.println("======迭代器=====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }

        //方式2--增强for
        System.out.println("======增强for=====");
        for (Object o :
                set) {
            System.out.println(o);
        }

HashSet介绍

1. HashSet实际上是HashMap
   

2. 可以存放null，但只能有一个null

3. HashSet不保证元素是有序的，因为是hash后，再确定索引

4. HashSet不能有重复元素

• HashSet底层机制分析

  1. HashSet底层是HashMap，HashMap底层是（数组+链表+红黑树）
     
     1.HashSet 底层是 HashMap
     2.添加一个元素时，先得到hash值 -会转成-> 索引值
     3.找到存储数据表table，看这个索引位置是否已经存放的有元素如果没有， 直接加入如果有， 调用 equals 比较，如果相同，就放弃添加，如果不相同，则添加到最后

     HashSet.add()和HashMap.put()方法核心的方法：

  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                 boolean evict) {
      //定义辅助变量  tab（hashmap的数组）
      Node<K,V>[] tab; Node<K,V> p; int n, i;
      if ((tab = table) == null || (n = tab.length) == 0)
          //扩容长度，初始值16
          n = (tab = resize()).length;
      //根据key 得到hash 去计算该key应该存放到table表的那个索引位置
      //并把这个位置的对象，赋给 p
      //(n - 1) & hash会得到一个 [0,(n-1)] 的数
      if ((p = tab[i = (n - 1) & hash]) == null)
          tab[i] = newNode(hash, key, value, null);
      else {
          Node<K,V> e; K k;
          //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样，
          //并且 p指向的key和准备添加的key是同一个对象，或者p指向的key的equals()和准备添加的key比较后相同
          if (p.hash == hash &&
                  ((k = p.key) == key || (key != null && key.equals(k))))
              e = p;
          //再判断 p 是不是一颗红黑树
          else if (p instanceof HashMap.TreeNode)
              e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
          else {
                  //table对应索引位置已经是链表了
                  //依次和该链表元素比较，都不相同则加入该链表的最后，判断当前链表是否达到8个结点，如果有则树化
                      //是否树化还要table.length是否大于64
                  //如果该链表有一个元素和准备添加的元素相同，直接break
              for (int binCount = 0; ; ++binCount) {
                  if ((e = p.next) == null) {
                      p.next = newNode(hash, key, value, null);
                      if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                          treeifyBin(tab, hash);
                      break;
                  }
                  if (e.hash == hash &&
                          ((k = e.key) == key || (key != null && key.equals(k))))
                      break;
                  p = e;
              }
          }
          if (e != null) { // existing mapping for key
              V oldValue = e.value;
              if (!onlyIfAbsent || oldValue == null)
                  e.value = value;
              afterNodeAccess(e);
              return oldValue;
          }
      }
      ++modCount;
      if (++size > threshold)
          resize();
      afterNodeInsertion(evict);
      return null;
  }
  

2. HashSet扩容机制
   HashSet中table数组默认初始长度为16，并设置有一个临界值threshold = table.length * 0.75（初始即为12） ；当table中数据有12个时就开始为table扩容2倍，新临界值也增加2倍。
   threshold 临界值，table中元素数量大于临界值时就扩容。
   

3. HashSet树化
   在Java8中，如果一条链表的元素个数超过 TREEIFY THRESHOLD(默认是 8)，并且table的大小 >=MIN TREEIFY CAPACITY(认64)就会进行树化(红黑树)。
   当链表的元素超过8个，但table长度未到64时，每再添加一个元素，table就会扩容2倍，直到到达64。

LinkedHashSetd 是HashSet子类

• LinkedHashSet底层是一个LinkedHashMap，底层维护的是一个数组+双向链表
• LinkedHashSet根据元素的hashCode值来决定元素存储位置，同时使用链表维护元素的次序，使得元素看起来是以插入顺序保存的。
• LinkedHashSet 不允许添加重复元素。

示意图

1. 在LinkedHastSet 中维护了一个hash表和双向链表( LinkedHashSet 有 head 和 tail )
2. 每一个节点有 before 和 after 属性,这样可以形成双向链表
3. 在添加一个元素时，先求hash值，在求索引，确定该元素在table的位置，然后将添加的元素加入到双向链表（如果已经存在，不添加。原则和HashSet一样）
4. 这样的话，我们遍历LinkedHashSet 也能确保插入顺序和遍历顺序一致