格物志

格物致知 知行合一

0%

集合

发表于 更新于 分类于
本文字数： 4.7k 阅读时长 ≈ 4 分钟

一，概念

集合是一种容器

特点：

  1. 集合的长度是可变的
  2. 同一个集合中可以存储不同数据类型的值
  3. 可以通过泛型来明确集合中存储的数据类型，一旦指定了泛型，那么该集合就只能存储这种数据类型了
  4. 集合找那个只能存储引用数据类型，不能存储基本数据类型，如果要在集合中存储基本数据类型，要使用基本数据类型的包装类

二，集合的体系

Collection：集合的顶层父接口，提供了集合的基本操作

List：接口，有序可重复

​ ArrayList：数组结构

​ LinkedList：链表结构

Set：接口，不可重复

​ HashSet：哈希表

​ TreeSet：树形结构

​ LinkedHashSet：链表+哈希表

三，List集合

概念：List 集合是Collection 接口的一个子接口

特点：

  1. 允许重复元素
  2. 有序的集合

3.1 ArrayList 集合

概念：ArrayList 集合是 List 接口的一个数组结构的实现类。有序可重复。

构造函数：

  1. new ArrayList()：构造一个初始容量为 10 的空列表
  2. new ArrayList(int capacity)：构造一个具有指定初始容量的空列表
  3. new ArrayList(Collection<? extends E> c)：根据参数集合构造一个新集合，参数集合的泛型必须是当前所创建集合泛型的类型或它的子类（设置泛型的上限）

常用方法：

  1. add(E e)：将元素添加到集合的末尾，返回布尔值；如果是 List 的 add() 返回值一定是 true，如果是 Set 的add() ，当元素已存在时会返回 false
  2. add(int index, E e)：将元素添加集合中的指定位置，返回 void
  3. remove(E e)：从集合中移除指定对象，返回是否移除成功的布尔值
  4. remove(int index)：从集合中移除指定位置上的对象，返回被移除的对象
  5. set(int index, E e)：用指定元素替换集合中指定位置上的元素
  6. get(int index)：通过下标返回元素
  7. size()：返回集合的大小
  8. addAll(Collecrtion c)
  9. addAll(int index, Collection c)
  10. containsAll(Collection c)：判断参数集合中的所有元素是否都存在于调用者集合中
  11. a . retainAll( b )：将 a、b两个集合的交集替换掉 a 集合中的所有元素，返回 true 表示 a 集合发生了改变
  12. a . removeAll( b )：从 a 集合中移除 a、b 集合的交集，返回 true 表示 a 集合发生了改变
  13. clear()
  14. contains(E e)
  15. indexOf(Object o)
  16. lastIndexOf(Object o)
  17. isEmpty()

3.2 LinkedList 集合

概念：LinkedList 集合是 List 接口的一个实现类，它的存储结构是链表结构，LinkedList 的特点是增删快，查询慢。

注：在 ArrayList 中所具备的方法，在 LinkedList 中都有，如果想要调用 LinkedList 中的特有方法，不可以使用多态的形式创建 LinkedList 对象。

LinkedList 的特有方法：

  1. addFirst(E e)
  2. addLast(E e)
  3. remove()
  4. removeFirst()
  5. removeLast()
  6. peek()
  7. peekFirst()
  8. peekLast()
  9. pop()
  10. poll()
  11. push(E e)

四，Set 集合

概念：Set 集合是Collection 接口的一个子接口

特点：

  1. 不允许重复元素
  2. 没有下标，没有使用下标作为参数的相关方法，因此 Set 集合不能使用普通for循环遍历

4.1 HashSet 集合

概念：HashSet 集合 Set 接口的一个实现类

特点：

  1. 无序，存取顺序不保证一致
  2. 不允许有重复元素
  3. 没有下标，没有使用下标作为参数的相关方法，因此 Set 集合不能使用普通for循环遍历
  4. 底层的数据结构是哈希表，哈希表的特点是查询快
    1. java8之前，哈希表 = 数组 + 链表
    2. java8及之后，哈希表 = 数组 + 链表（当链表的长度超过8个时，链表会转换成红黑树）

存储原理：

向HashSet存储数据时，会判断集合中是否已经存在与要存储的数据具有相同哈希值的元素，如果没有，则直接存储。如果有，则会使用equals来比较，如果结果为true，则不存储，结果为false，则存储。

构造函数：

  1. new HashSet()：构造一个初始容量为 16 的空列表
  2. new HashSet(int capacity)：构造一个具有指定初始容量的空列表
  3. new HashSet(Collection<? extends E> c)：根据参数集合构造一个新集合，参数集合的泛型必须是当前所创建集合泛型的类型或它的子类（设置泛型的上限）

4.2 TreeSet 集合

概念：TreeSet 是 Set 接口的一个实现类

特点：

  1. 无序，存取顺序不保证一致
  2. 不允许有重复元素
  3. 没有下标，没有使用下标作为参数的相关方法，因此 Set 集合不能使用普通for循环遍历
  4. 能实现自动排序

注：

  1. 如果TreeSet中存储的是自定义数据类型，那么该类必须实现Comparable接口，否则会发生 ClassCastException

  2. 如果自定义的排序方式中属性的差值为0，那么在TreeSet中会视为是同一个对象，由于Set不能存储重复元素，因此只会存储一个。

解决办法：

  1. 多条件的排序，第一个条件相同时，对第二个条件进行排序
  2. 使用允许存储重复元素的List集合，实现 Comparable 接口，重写 compareTo() 方法，使用 Collections 的sort() 方法进行排序

构造函数：

  1. new TreeSet()：构造一个新的空 set，该 set 根据其元素的自然顺序进行排序

  2. new TreeSet(Comparator c)：构造一个新的空 TreeSet，它根据指定比较器进行排序

    1
    2
    3
    4
    5
    TreeSet<Doctor> ds = new TreeSet<Doctor>(new Comparator<Doctor>(){
        public int compare(Doctor d1,Doctor d2){
            return d2.num - d1.num;
        }
    });

  3. new TreeSet(Collection<? extends E> c)：根据参数集合构造一个新集合，参数集合的泛型必须是当前所创建集合泛型的类型或它的子类（设置泛型的上限）

4.3 LinkedHashSet 集合

概念：LinkedHashSet 是 Set 接口的一个实现类

特点：

  1. LinkedHashSet 的数据结构是哈希表加上链表，它在 HashSet 的基础上添加了一条链表来保存元素的存储顺序，因此 LinkedHashSet 的有序的

  2. 有序，保证存取顺序一致

  3. 没有下标，没有使用下标作为参数的相关方法，因此 Set 集合不能使用普通for循环遍历

构造函数：

  1. new LinkedHashSet()：构造一个初始容量为 16 的空列表
  2. new LinkedHashSet(int capacity)：构造一个具有指定初始容量的空列表
  3. new LinkedHashSet(Collection<? extends E> c)：根据参数集合构造一个新集合，参数集合的泛型必须是当前所创建集合泛型的类型或它的子类（设置泛型的上限）

五，迭代器

概念：迭代器是遍历集合元素的通用方法

原理：先判断是否有下一个可以迭代的元素，如果没有，则不获取，迭代结束；如果有，则获取下一次元素。继续判断。

可迭代的接口：Iterable，提供了 iterator() 方法用于获取迭代器对象

迭代器接口：Iterator，提供了两个方法：

  1. hasNext()：判断集合中是否存在下一个可获取的元素，返回布尔值
  2. next()：获取下一个元素
1
2
3
4
5
6
7
ArrayList<String> list = new ArrayList<String>();
list.add("贾宝玉");
list.add("林黛玉");
list.add("薛宝钗");
for(Iterator<String> it = list.iterator();it.hasNext();){
    System.out.println(it.next());
}

六，Collecctions

概念：Collecctions 由在 集合 上进行操作或返回 集合 的静态方法组成。

常用方法：

  1. addAll(Collection<? super T> c ，T … e)：将可变参数 e 中的所有元素添加到集合 c 中

  2. binarySearch(List l，T t)：使用二分搜索法查询集合中指定元素的下标，

    前提是：1.升序排列 2.没有重复元素

  3. binarySearch(List l，T t，Comparator c)

  4. copy(List a，List b)：将 b 集合中的所有元素赋值到 a 集合从第一个元素开始，如果 a 的长度小于 b 的长度会发生 IndexOutOfBoundsException

  5. fill(List l，T … t)：使用 t 替换 集合中的所有元素

  6. max(Collection c)：获取集合中最大值

  7. min(Collection c)：获取集合中最小值

    如果要获取自定义类型中对象属性的最大最小值，可以使用重载形式：

    max(Collection c，Comparator c)、min(Collection c，Comparator c)

  8. replaceAll(List l，T oldValue，T newValue)：使用 newValue 替换 list 中的所有 oldValue

  9. *reverse()：倒置

  10. *swap(List l，int i，int j)：将集合中下标 i 和下标 j 位置上的元素交换

  11. *shuffle(List l)：打乱集合

  12. *sort(List l)：字符串和基本类型默认按照字典顺序排序，自定义数据类型的属性排序时需要实现 Comparable 接口

  13. *sort(List l，Comparator c)：字符串和基本类型默认按照字典顺序排序，自定义数据类型的属性排序时，需要传入 Comparator 的实现类对象。

七，Map

7.1 概念和特点

Collection 单列集合

Map 是双列集合，在 Map 中存储元素时，要将一个元素以键值对的一一对应的映射关系存储到集合中

Map的特点：

  1. Map 中的一个元素包含两个部分：键（key）、值（value）
  2. key 和 value 的类型的任意的
  3. key 是唯一的，value 是可以重复
  4. Map 中存储的是映射关系，该映射关系由键和对应的值产生
  5. Map 没有下标

7.2 Map 的方法

  1. put(k，v)：将 k、v形成的键值对添加到集合中，当 key 重复时，返回被替换的 value
  2. remove(k)：将键所对应的键值对删除，返回被删除的值
  3. remove(k，v)：只有当k、v的映射关系存在集合于中才会删除
  4. replace(k，v)：将 v 替换指定 k 上的值
  5. replace(key，oldValue，newValue)：只有当 key 和 oldValue 的映射关系存在集合于中才会将 newValue 替换掉 oldValue
  6. get(k)：根据键返回对应的值
  7. size()：返回集合的大小
  8. clear()：清空集合
  9. containsValue(v)：判断是否存在指定的值
  10. containsKey(k)：判断是否存在指定的键
  11. isEmpty()：判断集合是否为空
  12. equals(map)：比较两个 Map 中的元素是否完全相同
  13. values()：返回 Map 中值组成 Collection 集合
  14. keySet()：获取 Map 中所有键组成的 Set 集合
  15. entrySet()：获取 Map 中所有映射关系组成的 Set 集合

z

222222222