集合的体系结构

独步夜间

于 2023-08-07 23:05:37 发布

阅读量194

点赞数 3

文章标签： java

本文链接：https://blog.csdn.net/weixin_63072748/article/details/132156931

版权

本文详细介绍了Java集合框架中的单列和双列体系结构，包括Collection、List（如ArrayList和LinkedList）、Set（如HashSet、LinkedHashSet和TreeSet）以及Map（如HashMap、LinkedHashMap和TreeMap）的基本定义、特点和操作方法，强调了线程安全性和效率的区别。

摘要由CSDN通过智能技术生成

集合分为两大体系分别是：

1.单列集合体系：

1.Collection：

定义：单列集合的根接口

特点：1. 长度可变 2. 只能存引用数据类型 3. 无索引

功能：
- 增：
  - add(T t)
  - addAll(Collection c)
- 删：
  - remove(T t)
  - removeAll(Collection c)
- 改：
  - 无索引，没有修改
- 查：
  - size()
  - 无索引，没有查询
- 遍历：
  - Iterator iterator()
List<E>:
- 定义：有索引的单列集合的根接口
- 特点：
  - 1. 元素可重复
  - 2. 元素有索引
  - 3. 存取有序
- 功能：Collection继承过来的一套无索引的功能 + 自身特有的一套有索引的功能
  - 增：
    - add(int index , E e)
    - addAll(int index , Collection c)
  - 删：
    - remove(int index)
      - 注意：优先按照索引删
  - 改：
    - set(int index , E e)
  - 查：
    - get(int index)
  - 遍历：
    - ListIterator listIterator()
- 子类：
  - ArrayList<E>
    - 数据结构：数组
    - 特点：查找快,增删慢
    - JDK1.8扩容原理：
      - 1.无参构造创建ArrayList对象：底层是：{}
      - 2. 添加第 1 个元素时，扩容capacity为：10
      - 3. 添加第 11 个元素时，扩容capacity为：原来的1.5倍
      - 4.....
    - 面试题：当向ArrayList中添加第1024个元素时，此时capacity = 1234
  - LinkedList<E>
    - 数据结构：双向链表
    - 特点：增删块，查找慢
    - 节点： Node(prev , item , next)
  - Vector<E>
    - 数据结构：数组
    - 方法上都有：synchronized
    - 线程安全，效率低于ArrayList

Set<E>:
- 定义：无索引的单列集合的根接口
- 特点：
  - 1. 元素不可重复，唯一
  - 2. 无索引
  - 3. 存取无序
- 子类：
  - HashSet<E>
    - 底层： hash(数组 + 链表)
    - 特点：查找和增删都快，存取无序
    - 说明：存入的常用类类型 + 自定义类型（重写hahsCode() , equals()）
    - 扩容原理：
      - 1. 使用无参构造创建hashset集合时： table 的默认容量为： 1 << 4 , 默认扩容因子： 0.75F
      - 2. 当存入第13个均匀分布的元素时，第1次扩容为：原来的2倍
      - 3. 当存入第25个均匀分布的元素时，第2次扩容为：原来的2倍
    - hash的优化：
      - 1. table数组的长度保证是：2的指数次幂
      - 2. 将hash % table.length 替换为： hash & (table.length-1)
      - 3. 当table的长度 >= 64 并且单链表的节点的个数超过8个，就变成红黑树
    - 方法：
      - 只有从Collection接口继承过来的一套无索引的功能
  - LinkedHashSet<E>
    - 底层： linked + hash
    - 特点：存取有序
    - 方法：
      - 根HashSet一模一样
  - TreeSet<E>
    - 底层：红黑二叉树
    - 特点：排序
    - 补充：有内部和外部比较器
      - 内部比较器：
        
        自定义类中实现：Comparable<E> 接口，重写：compareTo()
        
        比较规则：升序
        
        this.属性 < o.属性返回： -1
        
        this.属性 == o.属性返回：0
        
        this.属性 > o.属性返回： 1
      - 外部比较器：
        
        new TreeSet（Comparator comparator）
        
        比较规则：升序
        
        o1.属性 < o2.属性返回： -1
        
        01.属性 == o2.属性返回：0
        
        o1.属性 > o2.属性返回： 1
    - 方法：
      - 根HashSet一模一样

双列集合体系
- Map
  - 双列集合的顶层根接口
  - 特点：
    - 1. 存入的元素是：键值对，键： key , 值：value
    - 2. 键是唯一的
  - 方法：
    - 增：
      - put(K key , V value)
    - 删：
      - remove(K key)
        
        常用
      - remove(K key , V value)
    - 改：
      - put(K key , V value)
    - 查：
      - size()
      - Object get(K key)
    - 遍历：
      - 方式一：1. 拿到所有的key，遍历key，通过key找value
        
        Set ketSet()
      - 方式二：1. 拿到所有的Entry<K,V>,遍历entry,通过getKey() , getValue()
        
        Set entrySet()
      - ForEach
        
        map.forEach((k,v) -> System.out.println(k +"----"+v));
  - 常用子类：
    - HashMap<K,V>
      - 底层： hash(数组+链表)
      - 特点：查找和增删都快，存取无序
      - put（K,V）的原理：
        
        1. 判断key是否为null
        
        2. 为null，找到table[0]位置的节点，判断号位置有没有key为null的节点，有，就将value替换，没有就将key---value键值对封装成节点Node对象，存入0号索引位置单链表的最后
        
        3.不为null,通过key.hashCode() 得到hash值，然后再通过：hash & (table.length-1)得到索引位置index
        
        4. 将key---value 和当前inde位置的每一个节点的key使用hashCode() 和equals()比较
        
        key相同：value替换老值
        
        key不相同：将key---value封装成Node节点对象存入链表的最后
      - get(K key)的原理
        
        1. 判断key是否为null
        
        为null，直接找table[0]的链表，从first首节点开始，找到key为null的节点就将value返回，没找到就返回null
        
        2.key不为null
        
        通过key.hashCode ,将 hash & (table.length-1)得到索引
        
        从first首节点开始，找到键为key的节点就将value返回，没找到就返回null
    - LinkedHashMap<K,V>
      - 底层： linked + hash (双链表 + 数组 + 单链表)
      - 特点：
        
        存取有序
      - 方法：
        
        跟HashMap一样
    - TreeMap<K,v>
      - 底层：红黑二叉树
      - put(K key , V value)原理：
        
        TreeMap.Entry内部类
        
        1. 无参构造创建TreeMap时，底层是空树
        
        2. 添加第1个key--value时，将key---value封装成Entry<K,V>对象，将root 指向这个节点的地址即可
        
        3. 添加第2个key--value时，将key---value封装成Entry<K,V>对象，将添加的key和root中的key进行compareTo()比较，如果key < root.key :放左边，如果key> root.key :放右边，
        
        ....
    - Hashtable
      - HashMap 和Hashtable的方法以及用法一模一样
      - 线程安全，效率低