【笔记】集合框架

发表于 更新于 分类于 阅读次数：

前言

java.util.Collection
集合，用于存储一组元素。提供了维护集合的相关操作。

元素是否重复是依靠元素自身equals方法比较的结果而定的。

集合的继承结构

graph TD
A[Collection接口] --> B[List接口]
    A --> C[Set接口]
    A --> D[Map接口]
    B --> E[ArrayList子类]
    B --> F[LinkedList子类]
    C --> G[HashSet子类]
    D --> H[HashMap子类]

List

  • 可重复集，并且有序。特点是可以根据下标操作元素。

  • 常用实现类：

ArrayList：底层使用数组实现，查询更快
LinkedLise：底层使用链表实现，增删更快（首位增删效果明显）

Set

  • 不可重复集

Map

  • 也叫哈希表、散列表
  • 常用于存 键值对 结构的数据
  • 其中的键不能重复，值可以重复

基本方法

创建 ArrayList 对象

1
Collection c = new ArrayList();

使用泛型创建

1
Collection<String> c = new ArrayList<String>();

简写

1
Collection<String> c = new ArrayList<>();
直接给定数组长度
  • 因为ArrayList底层维护的是一个数组，所以可以在创建对象时直接给定数组长度

<len>：定义数组长度

1
Collection<String> c = new ArrayList<>(<len>);

向集合中添加元素

  • 线性集合默认追加到末尾

  • 返回值为布尔值

<value>：元素

1
c.add(<value>);

集合元素个数

  • 返回值为整数值
1
c.size();

判断是否为空

  • 返回值为布尔值
1
c.isEmpty();

清空集合元素

1
c.clear();

判断元素是否已存在

  • 返回值为布尔值
1
c.contains(<value>);

删除元素

  • 返回值为布尔值
1
c.remove(<value>);

取并集

  • 返回值为布尔值
1
2
3
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
c1.addAll(c2);

判断当前集合是否包含给定集合

  • 返回值为布尔值
1
c1.containsAll(a2);

从c1中删除两集合共有元素

  • 返回值为布尔值
1
c1.removeAll(c2);

迭代器遍历

获取用于当前集合的迭代器

1
Iterator it = c.iterator();

遍历每一个元素

1
2
3
4
while(it.hasNext()) {
    Object obj = it.next();
    ...
}

for each 循环遍历

1
2
3
for(Object obj:c) {
    ...
}

泛型

  • 泛型又称为参数化类型，是将当前类的属性的类型，方法参数的类型以及方法返回值的类型的定义权移交给使用者。使用者在创建当前类的同时将泛型的实际类型传入。

  • 泛型的原型是Object，定义了泛型只是编译器在做一些验证工作。当我们对泛型类型设置时，会检查是都满足类型要求。当我们获取一个泛型类型对值时，会自动进行类型转换。

List中的方法

将元素插入指定位置

  • 返回值为布尔值

<index>：想要操作元素的下标

1
2
List list = new ArrayList();
list.add(<index>, <value>);

删除指定位置元素

  • 返回被删除的元素
1
list.remove(<index>);

取子集

  • 返回值为集合

<index_first>：取子集的开始下标
<index_last>：取子集的结尾下标

1
list.subList(<index_first>, <index_last>);
  • 对子集修改就是修改原集合内容

删除集合中给定区间的元素

1
list.subList(<index_first>, <index_last>).clear();

转换

集合转换为数组

  • 返回值为数组
1
c.toArray(new Object[c.size()]);

数组转换为集合

  • 只能转换为List集合

  • 返回值为集合

1
2
Object[] array = {};
Arrays.asList(array);

修改元素

向集合中添加一个元素
  • 实际上下面的代码会抛出异常。原因在于，该集合是由数组转换过来的，那么该集合就表示原来的数组，所以对集合的操作就是对数组的操作。那么添加元素会导致原数组扩容，那么就不能表示原来的数组了。所以不允许向该集合添加新元素。
修改集合元素
  • 数组元素也会改变
若希望增删元素
  • 需要另创建一个集合

排序

  • 排序集合使用的是集合的工具类Collections的静态方法sort

  • 排序仅能对List集合进行

1
Collections.sort(list);

自定义排序规则

  • 当实现了Comparable接口后，需要重写下面的方法，该方法的作用是定义当前对象与给定参数对象比较大小的规则
  • 返回值为一个int值，该值表示大小关系。它不关注具体的取值是多少，而关注的是取值范围。
  • 当返回值>0时：当前对象比参数对象大
  • 当返回时<0时：当前对象比参数对象小
  • 当返回值=0时：两个对象相等。
1
2
3
public int compareTo() {
    ...
}

重载方法

  • sort方法要求集合元素必须实现Comparable接口，该接口用于规定实现类是可以比较的。其有一个抽象方法是用来定义大小的规则。
  • 我们想使用sort方法排序集合，但是该方法要求我们的集合元素必须实现Comparable接口并且定义比较规则，这种我们想使用某个功能，而它要求我们修改程序的现象称为“侵入性”。修改的代码越多，侵入性越强，越不利于程序的扩展。
  • 重载的sort方法要求传入一个额外的比较器，该方法不再要求集合元素必须实现Comparable接口，并且也不在使用集合元素自身的比较规则排序类，而是根据给定的这个额外的比较器的比较规则对集合元素进行排序。
1
2
3
4
5
6
class MyComparator implements Comparator<String> {
    public int compare() {
        return 0;
    }
}
Collections.sort(list, new MyComparator());
  • 实际开发中也推荐使用这种方式排序集合元素，若集合元素是自定义的。创建比较器时也推荐使用匿名内部类的形式。
1
2
3
4
5
6
Comparator<String> comparator = new Comparator<String>() {
    public int compare() {
        return 0;
    }
};
Collections.sort(list, comparator);

LinkedList的额外方法

添加首尾元素

<value>：对应数据类型的元素

1
2
addFirst(<value>);
addLast(<value>);

获取首尾元素

1
2
list.getFirst();
list.getLast();

修改指定下标的元素

<index>：下标值

1
list.setFirst(<index>, <value>);

删除首尾元素

1
2
list.removeFirst();
list.removeLast();

Map集合

添加键值对

1
list.put(<key>, <value>);

是否有指定key

1
list.containsKey(<key>);

是否有指定value

1
list.containsValue(<value>);

根据key获取value

1
list.get(<key>);

根据key删除键值对

  • 返回value
1
list.remove(<key>);

把map里的所有value放入Collection

1
Collection c = map.values();

把map里的所有key放入Set

1
Set set = map.keySet();

把map里的键值对封装为Entry对象放入Set

1
Set set = map.entrySet();

工具类

批量加入数据

<elements>：任意数量的数据，多个数据间用逗号隔开

1
Collections.addAll(list, <elements>);

获取集合中的最大值

1
Collections.max(list);

获取集合中的最小值

1
Collections.min(list);

位置反转

1
Collections.revers(list);

排序

  • 默认从小到大排序
1
Collections.sort(list);

交换

  • 把指定元素按照下标位置交换

<index_1>、<index_2>：两个元素的下标

1
Collections.swap(list, <index_1>, <index_2>);

完成