Java collections framework

一、原生数组带来的问题

• 传统数组 CRUD 需要使用数据结构
• 传统数组扩容所需要的时间较多

二、集合家族

Java 提供集合框架，是一个包含一系列实作可重复使用集合的数据结构的类别和界面集合。
集合可分为三种：

• 有序列表(ordered lists)
• 映射表(maps)
• 集(sets)

三、家族、接口

接口定义规则方法
实现接口的类必须遵守规则

四、ArrayList

【Java 学习笔记】Java 思维—List 接口与 ArrayList 实现类

五、Linked 链表

• List 和 Deque 接口的双向链表实现。实现所有可选列表操作，并允许所有元素（包括 null）。链表中包含前驱节点和后继节点。
• 所有操作都按照双向链表的预期执行。索引到列表中的操作将从开头或结尾遍历列表，以更接近指定索引的为准。

六、Iterator 迭代器

迭代是重复反馈过程的活动，目的是接近并达到某些目标。

public class FlemingIterator {
    @Test
    public void test {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Fleming")
        arrayList.add("Tom")
        arrayList.add("Jack")
        arrayList.add("Rose")
        arrayList.add("Lili")
    }
}
1
2
3
4
5
6
7
8
9
10
11

1. 普通 for 循环——能读，能修改

for(int i = 0; i < arrayList.size(); i ++) {
    arrayList.remove("Jack");
}
1
2
3

2. 增强 for 循环——只能读取

// 出现java.util.ConcurrentModificationException异常
for (String e : arrayList) {
    arrayList.remove(e);
}
1
2
3
4

ArrayList 中删除数据时不能使用 forEach，可以使用迭代器

Iterator<String> iterator = arrayList.iterator();
while (iterator.hasNext()) {
    String value = iterator.next();
    if (value.equals(Rose)) {
        arrayList.remove(value);
    }
}
1
2
3
4
5
6
7

若有嵌套循环时，不使用迭代器，使用 forEach

public class FlemingIterator {
    @Test
    public void test1 {
        LinkedList<Integer> linkedList_1 = new LinkedList<>();
        linkedList_1.add(1)
        linkedList_1.add(2)
        linkedList_1.add(3)
    }
    public void test2 {
        LinkedList<Integer> linkedList_2 = new LinkedList<>();
        linkedList_2.add(4)
        linkedList_2.add(5)
        linkedList_2.add(6)
    }
}

    // 出现java.util.NoSuchElementException异常
    for (Iterator<Integer> integer_1 = linkedList_1.iterator(); iterator_1.hasNext();) {
        for (Iterator<Integer> integer_2 = linkedList_2.iterator(); integer_2.hasNext;) {
            if (iterator_1.next() < iterator_2.next()) {
                System.out.println(iterator_1.next());
            }
        }
    }

    // 出现java.util.NoSuchElementException异常
    for (Integer value_1 : linkedList_1) {
        for (Integer value_2 : linkedList_2) {
            if (value_1 < value_2) {
                System.out.println(value_1);
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

增强 for 循环是一个小型，隐性的迭代器

七、for、forEach、Iterator 三者性能

• ArrayList 为顺序存储，三者性能差别不大
• LinkedList 为链式存储，forEach、Iterator 性能明显强于 for

八、Set 下属 HashSet

Set 集合无序，且不允许出现重复元素

@Test
public void test1() {
    HashSet<String> hashSet = new HashSet<>();

    hashSet.add("Fleming");
    hashSet.add("Tom");
    hashSet.add("Rose");
    hashSet.add("Rose");

    System.out.println(hashSet);
    // 输出Tom,Rose,Fleming,无序且不重复
}
1
2
3
4
5
6
7
8
9
10
11
12

Hash 哈希 单项散列函数
JDK1.8 以前，Hash 表底层是数组和链表
JDK1.8 以后，Hash 表底层是数组、链表和红黑树

九、Set 下属 LinkedHashSet

有序，元素不重复元素

@Test
public void test1() {
    LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();

    linkedHashSet.add("1");
    linkedHashSet.add("2");
    linkedHashSet.add("3");
    linkedHashSet.add("4");
    linkedHashSet.add("4");

    System.out.println(linkedHashSet);
    // 输出1，2，3，4，有序且不重复
}
1
2
3
4
5
6
7
8
9
10
11
12
13

十、Map 下属 HashMap 与 泛型 Entry

HashMap 属于 AbstractMap

@Test
public void test1() {
    //      key, value
    HashMap<Integer,String> hashMap = new HashMap<>();

    hashMap.put(100000,"Fleming");
    hashMap.put(100001,"Tom");
    hashMap.put(100002,"Rose");

    System.out.println(hashMap);
    // 输出100001=Tom,100000=Frank,100002=Rose
    String value = hashMap.get(100002);
    System.out.println(value);
    // 输出Rose
    System.out.println(hashMap.containsKey(100000));
    // 包含指定的Key则返回true
    System.out.println(hashMap.containsValue(Fleming));
    // 包含指定的Value则返回true
    hashMap.replace(100000,"Change");
    System.out.println(hashMap);
    // 输出100001=Tom,100000=Change,100002=Rose
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

@Test
public void test2() {
    //      key, value
    HashMap<Integer,String> hashMap = new HashMap<>();

    hashMap.put(100000,"Fleming");
    hashMap.put(100001,"Tom");
    hashMap.put(100002,"Rose");

    Set<Integer> Keys = hashMap.keySet();
    System.out.println(keys);
    // 输出100001,100000,100002
    // 将key保存为set

    Set<Entry<Integer,String>> entrySet = hashMap.entrySet();
    System.out.println(entrySet);
    // 输出100001=Tom,100000=Fleming,100002=Rose
    // 将键值对保存为set
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

@Test
public void test1() {
    //      key, value
    HashMap<Integer,String> hashMap = new HashMap<>();

    hashMap.put(100000,"Fleming");
    hashMap.put(100001,"Tom");
    hashMap.put(100002,"Rose");

    hashMap.put(100001,"Change");
    System.out.println(hashMap);
    // key已经存在，编译虽然能够通过，但覆盖是危险的
    System.out.println(hashMap.get(100005));
    // 返回null
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

十一、map 转换为 set 后遍历

@Test
public void test1() {
    //      key, value
    HashMap<Integer,Double> hashMap = new HashMap<>();

    hashMap.put(100000,"98.8");
    hashMap.put(100001,"56.5");
    hashMap.put(100002,"32.3");

    Set<Integer> keys = hashMap.keySet();
    ArrayList<Integer> arrayList = new ArrayList<>();

    Set<Entry<Integer,Double>> entrySet = hashMap.entrySet();
    System.out.println(entrySet);

    Iterator<Entry<Integer,Double>> iterator = entrySet.iterator();

    while (Integer.hasNext()) {
        int value = Integer.next().getValue();
        if (value >= 90) {
            arrayList.add(value);
        }
    }
    System.out.println(arrayList);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

十二、LinkedHashMap

• 有序的 HashMap