Day07

集合

1. 概念：对象的容器，定义了对多个对象进行操作的常用方法。可以实现数组的功能。

2. 集合和数组的区别：

   1. 数组长度固定，集合长度不固定
   2. 数组可以存储基本类型和引用类型，集合只能存储引用类型

3. 位置：java.util.*

4. 不能保存基本类型

Collection体系集合

1. Collection父接口 （Demo01、Demo02 引用传递 ）

   1. 特点：代表一组任意类型的对象，无序、无下标、不能重复。
   2. 方法：
      • boolean add(Object obj) // 添加一个对象
      • boolean addAll(Collection c) // 将一个集合中的所有对象添加到此集合中
      • void clear() // 清空此集合中的所有对象
      • boolean contains(Object o) // 坚持此集合中是否包含o对象
      • boolean equals(Object o) // 比较此集合是否与指定对象相等
      • boolean isEmpty() // 判断此集合是否为空
      • boolean remove(Obejct o) // 在此集合中移除o对象
      • int size() // 返回此集合中的元素个数
      • Object[] toArray() //将此集合转换为数组
   3. 迭代器 Iterator

2. List子接口 （Demo03、Demo04 对数字进行操作注意事项）

   1. 特点：有序、有下标、元素可以重复。
   2. 方法：
      • void add(int index, Object o) // 在index位置插入对象o
      • boolean addAll(int index, Collection c) // 将一个集合中的元素添加到此集合中的index位置
      • Object get(int index) // 返回集合中指定位置的元素
      • List subList(int fromIndex, int toIndex) // 返回fromIndex和toIndex之间的集合元素
   3. 迭代器+列表迭代器 ListIterator

3. List实现类：

   • ArrayList【重点】 demo05：

     • 数组结构实现，查询快、增删慢

     • JDK1.2版本，运行效率快、线程不安全

     • 迭代器+列表迭代器

     • 源码分析：

       • DEFAULT_CAPACITY = 10 默认容量大小。注意：如果没有向集合中添加任何元素时，容量为0，添加一个元素后，容量为10，每次扩容大小是原来的1.5倍

       • elementData 存放元素的数组

       • size 实际的元素个数

       • add(); 添加元素

         •     
           // 解释:如果没有向集合中添加任何元素时，容量为0，若添加默认容量为10
           	public boolean add(E e) {
                   ensureCapacityInternal(size + 1);  // Increments modCount!!
                   elementData[size++] = e;
                   return true;
               }
           
               private static int calculateCapacity(Object[] elementData, int minCapacity) {
                   if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                       return Math.max(DEFAULT_CAPACITY, minCapacity);
                   }
                   return minCapacity;
               }
           
               private void ensureCapacityInternal(int minCapacity) {
                   ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
               }
           
               private void ensureExplicitCapacity(int minCapacity) {
                   modCount++;
           
                   // overflow-conscious code
                   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); 
                   // 增加一个元素后的操作，容量变为10
                   // copyOf(要复制的数组, 要返回的数组长度) 原来的1.5倍
               }
           
           

   • Vector demo06 ：

     • 数组结构实现，查询快、增删慢
     • JDK1.0版本，运行效率慢、线程安全
     • 枚举器 vector.elements();

   • LinkedList demo07：

     • 双向链表结构实现，增删快（数据不需要移动，改指向关系就可以实现删除）、查询慢

     • 迭代器+列表迭代器

     • 源码分析：

       • int size: 集合的大小

       • Node first; 链表的头节点

       • Node last; 链表的尾结点

         •     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++;
               }
           
               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;
                   }
               
           

         • Node类型

4. 泛型

   • 本质是参数化类型，把类型作为参数传递。
   • 常见形式：泛型类、泛型接口、泛型方法 generic
   • 语法：<T,…> T称为类型占位符，表示一种引用类型
   • 好处：
     • 提高代码的重用性
     • 防止类型转换异常，提高代码安全性

5. 泛型集合 demo08

   • 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致
   • 特点：
     • 编译时即可坚持，而非运行时抛出错误
     • 访问时，不必类型转化（拆箱）
     • 不同泛型之间引用不能相互赋值，泛型不存在多态

6. set子接口 demo09

   • 特点：无序、无下标、元素不可重复
   • 方法：全部继承Collection中的方法
   • 迭代器 iterator

7. set实现类

   • HashSet【重点】： demo10

     • 基于HashCode实现元素不重复

     • 

     •  * 存储过程(重复的依据)： demo11
        * 1.根据 hashcode 计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步。
        * 2.再执行 equals 方法，如果 equals 方法为true，则认为重复，否则，形成链表。 // 重写 hashcode 和 equals
            
               //  为什么hashcode算法里面用的是31
               // （1）31是一个质数，减少散列冲突  （2）31提高执行效率  31*i=(i<<5)-1
       

     • 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入

   • TreeSet：

     • 基于排列顺序实现元素不重复

     • 实现了SortedSet接口，对集合元素自动排序

     • 元素对象的类型必须实现Comparable接口，指定排序规则

     • 通过CompareTo方法确定是否为重复元素

     •  * 存储结构：红黑树
        * 要求：元素必须要实现Comparable接口，compareTo()方法返回值为0，认为是重复元素
            // demo12 字符串
            // demo13 类
       

8. Comparator接口

   •  * Comparator:实现定制比较（比较器） 在主函数创建集合时，便可定义加入TreeSet集合的对象类的比规则  
          // demo14 demo15案列	
      * Comparable:可比较的，对于加入TreeSet集合的对象类，需要继承Comparable接口并重写compareTo()方法