Java Collections Framework 教程

1
2
3
4
5

import java.utils.Arrays;
int[] arr1;
System.out.println(Arrays.toString());
int[][] arr2;
System.out.println(Arrays.deepToString());

1
2
3
4

// int[] 转 List<Integer>
// 不可添加、删除、修改
int[] arr;
List<Integer> list = List.of(arr);

1
2
3

// int[] 转 Integer[]
int[] arr;
Integer[] arr2 = IntStream.of(arr).boxed()

1
2
3
4

// Integer[] 转 List<Integer>
// 不可添加、删除、修改
Integer[] arr;
List<Integer> list = List.of(arr);

1
2
3

// List<Integer> 转 Integer[]
List<Integer> list;
int[] arr2 = list.stream().mapToInt().toArray(Integer::new);

1
2
3
4
5

myColl.stream()
    .filter(e -> e.getAttribute() == "Attribute")
    .forEach(e -> System.out.println(e.toString()));

myColl.forEach(System.out::println);

1
2
3

for (Object o : myColl) {
    System.out.println(o);
}

1
2
3
4
5
6

// 定义
public interface Iterator<E> {
    boolean hasNext(); // 是否存在下个元素
    E next();          // 迭代器后移，同时返回下个元素
    void remove();     // 删除当前元素
}

1
2
3

for (Iterator<E> it = myColl.iterator(); it.hasNext();) {
    System.out.println(it.next());
}

1
2
3
4
5
6

for (Iterator<E> it = myColl.iterator(); it.hasNext();) {
    E e = it.next();
    if (judge(e)) {
        it.remove();
    }
}

1
2
3

for (int i = 0; i < myColl.size(); i++) {
    System.out.println(myColl.get(i));
}

1

import java.util.List;

1

import java.util.ArrayList;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

for (int i = 0; i < list.size(); i++) {
    if (list.get(i) == target) {
        list.remove(i);
        i--; // 集合删除元素后，后面元素整体前移一位。
    }
}

for (Iterator<Integer> it = list.iterator(); it.hasNext();) {
    int val = it.next();
    if (val == target) {
        it.remove();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 初始化1
List<Integer> list1 = new ArrayList<>();
list1.add(1);
// 初始化2，推荐
List<Integer> list2 = new ArrayList<>() {{
    add(1);
}};
// 初始化3，不能修改
List<Integer> list3 = Arrays.asList(1, 2, 3);
// 初始化4，不能修改
List<Integer> list4 = List.of(1, 2, 3);
// 初始化5，推荐
List<Integer> list5 = Stream.of(1, 2, 3).collect(Collectors.toList());
// 初始化6，推荐
List<Integer> list6 = new ArrayList<>(List.of(1, 2, 3));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

List<Integer> list1 = new ArrayList<>(List.of(1, 2, 2, 3, 2));
// 去重1
LinkedHashSet<Integer> deDuplicator = new LinkedHashSet<>(list1);
List<Integer> list2 = new ArrayList<>(deDuplicator);
// 去重2
List<Integer> list3 = list1.stream().distinct().collect(Collectors.toList());
// 去重3
List<Integer> list4 = new ArrayList<>();
HashSet<Integer> hashset = new HashSet<>();
for (int x : list1) {
    if (hashset.add(x)) {
        list4.add(x);
    }
}

1

import java.util.LinkedList;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 尾部添加
boolean add​(E e)        // 一般 List 使用
boolean offer​(E e)      // 一般 Queue 使用
void addLast​(E e)       // 一般 LinkedList 使用
boolean offerLast​(E e)  // 一般 Deque 使用

// 首部添加
void addFirst​(E e)      // 一般 LinkedList 使用
boolean offerFirst​(E e) // 一般 Deque 使用
void push​(E e)          // 一般 栈 使用

// 指定位置添加
void add​(int index, E element)

// 添加集合
boolean addAll​(Collection<? extends E> c)
boolean addAll​(int index, Collection<? extends E> c)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 尾部删除
E removeLast()  // 一般 LinkedList 使用
E pollLast()    // 一般 Deque 使用

// 首部删除
E remove()      // 一般 List 使用
E poll()        // 一般 Queue 使用
E removeFirst() // 一般 LinkedList 使用
E pollFirst()   // 一般 Deque 使用
E pop()         // 一般 栈 使用

// 指定位置删除
E remove​(int index)

// 指定元素删除
boolean remove​(Object o)
boolean removeFirstOccurrence​(Object o)
boolean removeLastOccurrence​(Object o)

// 清空
void clear()

1

E set​(int index, E element)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 尾部
E getLast()   // 一般 List 使用
E peekLast()  // 一般 List 使用

// 指定位置
E get​(int index)

// 首部
E getFirst()  // 一般 List 使用
E peekFirst() // 一般 List 使用
E peek()      // 一般 Queue 使用

boolean contains​(Object o)
int indexOf​(Object o)
int lastIndexOf​(Object o)

1
2

ListIterator<E> listIterator​(int index)
Iterator<E> descendingIterator()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 列表迭代器定义
public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();
    E next();
    int nextIndex(); // 返回下个元素下标

    boolean hasPrevious();
    E previous();
    int previousIndex();

    void remove();
    void set(E e); // 修改当前迭代器指向元素
    void add(E e); // 添加到当前迭代器指向元素之前（next 之前，previous 之后），能被
}

1
2
3
4
5
6
7
8
9

// 正向
for (ListIterator<E> it = myList.listIterator(); it.hasNext();) {
    E e = it.next();
}

// 逆向
for (ListIterator<E> it = myList.listIterator(myList.size()); it.hasPrevious();) {
    E e = it.previous();
}

1
2
3
4
5
6

List<Integer> list = List.of(1, 2, 3);
// 方法1
Integer[] array1 = list.toArray(new Integer[0]);
// 方法2
Integer[] array2 = list.toArray(Integer[]::new);
// 不能转为 int[]

1
2
3
4

// int[] 不能转换
Integer[] array = { 1, 2, 3 };
List<Integer> list = List.of(array);
// 转换后的 list 只读，不能增删或修改

1
2
3
4
5
6
7
8

// 定义
Queue<Integer> queue = new LinkedList<>();
// 向队尾添加元素
queue.offer(1);
// 删除队首元素并返回
int first1 = queue.poll();
// 取队首元素
int first2 = queue.peek();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 定义
Deque<Integer> deque = new LinkedList<>();
// 队尾添加
deque.offerLast(1);
// 队首添加
deque.offerFirst(1);
// 队尾删除并返回
int last1 = deque.pollLast();
// 队首删除并返回
int first1 = deque.pollFirst();
// 取队尾元素
int last2 = deque.peekLast();
// 取队首元素
int first2 = deque.peekFirst();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

// 默认最小堆，元素值小的优先
Queue<Integer> q = new PriorityQueue<>();
// 自定义最大堆，元素值大的优先
Queue<Integer> q1 = new PriorityQueue<>((a, b) -> b - a);
q.offer(1);
int top = q.peek();
while (!q.isEmpty()) {
    int x = q.poll();
}
q.clear();
q.size();

1
2
3
4
5

// 自定义类
class Stu {
    String name;
    int score;
}

1
2
3
4
5
6

class A implements Comparable<A> {
    @Override
    public int compareTo(A a) {
        // ...
    }
}

1
2
3
4
5
6
7
8

import java.util.Comparator;

class A implements Comparator<A> {
    @Override
    public int compare(A a, A b) {
        // ...
    }
}

1
2
3

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 定义1
Queue<Stu> q1 = new PriorityQueue<>(new StuComp<Stu>());
// 显式定义排序类
class StuComp implements Comparator<Stu> {
    @Override
    public int compare(Stu s1, Stu s2) {
        if (s1.score != s2.score) {
            // 成绩高的优先
            return s2.score - s1.score;
        } else {
            // 再按名字字母排序
            return s1.name.compareTo(s2.name);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 定义2: 匿名类隐式定义排序类
Queue<Stu> q1 = new PriorityQueue<>(new Comparator<Stu>() {
    @Override
    public int compare(Stu s1, Stu s2) {
        if (s1.score != s2.score) {
            // 成绩高的优先
            return s2.score - s1.score;
        } else {
            // 再按名字字母排序
            return s1.name.compareTo(s2.name);
        }
    }
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 定义3: 修改类定义
class Stu implements Comparator<Stu> {
    String name;
    int score;

    @Override
    public int compare(Stu s1, Stu s2) {
        if (s1.score != s2.score) {
            // 成绩高的优先
            return s2.score - s1.score;
        } else {
            // 再按名字字母排序
            return s1.name.compareTo(s2.name);
        }
    }
}

1
2
3
4
5
6
7
8
9

import java.util.HashSet;

HashSet<Integer> set = new HashSet<>();
set.add(1);
set.contains(1);
set.remove(1);
set.clear();
set.size();
set.isEmpty();

1
2
3
4
5

import java.util.TreeSet;

TreeSet<Integer> set = new TreeSet<>();
TreeSet<Integer> set2 = new TreeSet<>();
set2.addAll(Set.of(1, 3, 5));

1
2

set.add(1);       // [1]
set.addAll(set2); // [1, 3, 5]

1
2
3

set.contains(1);             // true
set.first();                 // 1
set.last();                  // 5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 第一个大于等于指定值的元素，不存在返回 null
Integer a1 = set.ceiling(0);  // 1
Integer a2 = set.ceiling(1);  // 1
Integer a3 = set.ceiling(4);  // 5
Integer a4 = set.ceiling(7);  // null
// 第一个大于指定值的元素，不存在返回 null
Integer a5 = set.higher(0);  // 1
Integer a6 = set.higher(1);  // 3
Integer a7 = set.higher(4);  // 5
Integer a8 = set.higher(7);  // null

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 第一个小于等于指定值的元素，不存在返回 null
Integer a9 = set.floor(0);    // null
Integer a10 = set.floor(1);   // 1
Integer a11 = set.floor(4);   // 3
Integer a12 = set.floor(7);   // 5
// 第一个小于指定值的元素，不存在返回 null
Integer a13 = set.lower(0);   // null
Integer a14 = set.lower(1);   // null
Integer a15 = set.lower(4);   // 3
Integer a16 = set.lower(7);   // 5

1
2
3
4
5

set.pollFirst(); // 1
set.pollLast();  // 5
set.remove(3);   // true
set.remove(4);   // false
set.clear();

1
2

set.size();
set.isEmpty();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

TreeSet<Integer> set = new TreeSet<>();
set.addAll(Set.of(1, 2, 3));                       // [1, 2, 3]
// 范围子集
Set<Integer> set1 = set.subSet(1, 2);              // [1]
Set<Integer> set2 = set.subSet(1, false, 2, true); // [2]
// 首部子集
Set<Integer> set3 = set.tailSet(2);                // [1]
Set<Integer> set4 = set.tailSet(2, true);          // [1, 2]
// 尾部子集
Set<Integer> set3 = set.tailSet(2);                // [2, 3]
Set<Integer> set4 = set.tailSet(2, false);         // [3]
// 逆序
Set<Integer> set7 = set.descendingSet();           // [3, 2, 1]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// foreach
for (int x : set) {
    //
}
// foreach 逆序
for (int x : set.descendingSet()) {
    //
}
// iterator
for (Iterator<Integer> it = set.iterator(); it.hasNext();) {
    it.next();
}
// iterator 逆序
for (Iterator<Integer> it = set.descendingIterator(); it.hasNext();) {
    it.next();
}

1
2

import java.util.HashMap;
import java.util.Map;

1
2
3

// 定义
Map<String, Integer> map = new HashMap<>();
Map<String, Integer> otherMap = new HashMap<>();

1
2
3
4
5
6
7
8

// 添加元素，始终覆盖原值
map.put("Alice", 80);
// 存在返回原值，否则添加该元素，返回 null
map.putIfAbsent("Alice", 60); // 80
// 添加所有元素，始终覆盖原值
map.putAll(otherMap);
// 自增 map[key]++
map.put("Alice", map.getOrDefault("Alice", 0) + 1); // 81

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 根据键查询值，不存在返回 null
map.get("Alice"); // 81
// 存在返回原值，否则返回指定值
map.getOrDefault("Bob", 0);
// 存在返回原值，否则添加该元素，并返回新值
map.computeIfAbsent("Alice", key -> 90); // 81
map.computeIfAbsent("Bob", key -> 90);   // 90
// 修改已存在的值，并返回新值
map.computeIfPresent("Alice", (key, value) -> value + 10); // 91
// 查询键
map.containsKey("Bob"); // true

1
2
3
4

// 删除
map.remove("Alice");
// 清空
map.clear();

1
2
3
4

// 是否为空
map.isEmpty();
// 大小
map.size();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 遍历1
for (String key : map.keySet()) {
    int value = map.get(key);
}
// 遍历2
for (Map.Entry<String, Integer> ent : map.entrySet()) {
    String key = ent.getKey();
    int value = ent.getValue();
}
// 只遍历 value
for (int value : map.values()) {
}

1
2

import java.util.Map;
import java.util.TreeMap;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Stu implements Comparable<Stu> {
    String name;
    int score;

    @Override
    public int compareTo(Stu s) {
        // x.compareTo(y) < 0 等价于 x < y
        if (score != s.score) {
            return s.score - score;
        } else {
            return name.compareTo(s.name);
        }
    }
}

Map<Stu, Integer> map = new TreeMap<>();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import java.util.Comparator;

class Stu {
    String name;
    int score;

    String getName() {
        return name;
    }

    int getScore() {
        return score;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 实现1 匿名类
Map<Stu, Integer> map1 = new TreeMap<>(new Comparator<Stu>() {
    @Override
    public int compare(Stu a, Stu b) {
        // compare(x, y) < 0 等价于 x < y
        if (a.score != b.score) {
            return b.score - a.score;
        } else {
            return a.name.compareTo(b.name);
        }
    }
});

1
2
3

// 实现2 lambda 表达式
Comparator<Stu> cmp = (Stu a, Stu b) -> a.score != b.score ? b.score - a.score : a.name.compareTo(b.name);
Map<Stu, Integer> map2 = new TreeMap<>(cmp);

1
2

// 实现3 lambda 表达式
Map<Stu, Integer> map3 = new TreeMap<>((Stu a, Stu b) -> a.score != b.score ? b.score - a.score : a.name.compareTo(b.name));

1
2

// 实现4 Comparator 类方法
Map<Stu, Integer> map4 = new TreeMap<>(Comparator.comparing(Stu::getScore).reversed().thenComparing(Stu::getName));

1

import java.util.Arrays;

1
2
3
4
5
6
7

int[] arr = {1, 3, 5};
Arrays.binarySearch(arr, -1); // -1
Arrays.binarySearch(arr, 0);  // -1
Arrays.binarySearch(arr, 1);  // 0
Arrays.binarySearch(arr, 2);  // -2
Arrays.binarySearch(arr, -4); // -1
Arrays.binarySearch(arr, 8);  // -4

1
2
3
4
5

int[][] a = { { 1, 2 }, { 3, 4 } };
int[][] b = { { 1, 2 }, { 3, 4 } };
System.out.println(a == b);                  // false
System.out.println(a.equals(b));             // false
System.out.println(Arrays.deepEquals(a, b)); // true

1
2
3

int[] a = { 1, 2, 3 };
// 前缀和
Arrays.parallelPrefix(a, (x, y) -> x + y); // [1, 3, 6]

1
2
3
4
5
6

int[][] a = { { 1, 2 }, { 3, 4 } };
int[][] b = { { 1, 2 }, { 3, 4 } };
System.out.println(a);                       // [[I@36aa7bc2
System.out.println(Arrays.toString(a));      // [[I@76ccd017, [I@182decdb]
System.out.println(Arrays.toString(a[0]));   // [1, 2]
System.out.println(Arrays.deepToString(a));  // [[1, 2], [3, 4]]

1

import java.util.Collections;

1
2
3
4
5
6
7
8

// 创建空集合
// 返回的集合是不可变集合，无法向其中添加或删除元素。
List<String> list1 = Collections.emptyList();
List<String> list2 = List.of();
Map<String, Integer> map1 = Collections.emptyMap();
Map<String, Integer> map2 = Map.of();
Set<String> set1 = Collections.emptySet();
Set<String> set2 = Set.of();

1
2
3
4
5
6
7
8

// 创建单元素集合
// 返回的集合是不可变集合，无法向其中添加或删除元素。
List<String> list1 = Collections.singletonList("one");
List<String> list2 = List.of("one");
Map<String, Integer> map1 = Collections.singletonMap("one", 1);
Map<String, Integer> map2 = Map.of("one", 1);
Set<String> set1 = Collections.singleton("one");
Set<String> set2 = Set.of("one");

1
2
3
4
5
6
7

// 排序
// 必须传入可变 List
Collections.sort(list);

// 洗牌
// 必须传入可变 List
Collections.shuffle(list);

1
2
3
4
5
6
7

// 数组转 List
// 1.重新分配空间
List<Integer> myList = new ArrayList<>(Arrays.asList(1, 2, 3));
// 2.使用同一片空间
List<Integer> myList = Arrays.asList(1, 2, 3);
// 禁止调整大小，若 add 或 remove
// 则抛出 UnsupportedOperationException 异常

1
2
3
4

// 转换为字符串
String str = myColl.stream()
    .map(Object::toString)
    .collect(Collectors.joining(", "));

1
2
3

// 求和
int sum = myColl.stream()
    .collect(Collectors.summingInt(E::getValue));

1
2
3

// 删除容器中所有指定元素
myColl.removeAll(Collections.singleton(e));
myColl.removeAll(Collections.singleton(mull));

1
2
3

// 容器转数组，要求容器中元素类型统一
String[] arrStr = myColl.toArray(new String[0]);
Integer[] arrInt = myColl.toArray(new Integer[0]);

1
2
3
4
5
6
7
8
9

// 1.容器去重
Collection<E> noDups = new HashSet<>(myColl);
Collection<E> noDups = myColl.stream().collect(Collectors.toSet());
// 2.容器去重，且保持原来顺序
Collection<E> noDups = new LinkedHashSet<>(myColl);

public static <E> Set<E> removeDups(Collection<E> myColl) {
    return new LinkedHashSet<E>(myColl);
}

1
2
3
4

// 取出属性值，创建集合
Set<String> set = people.stream()
    .map(Person::getName)
    .collect(Collectors.toCollection(TreeSet::new));

1
2
3
4
5
6

// 交换元素
public static <E> void swap(List<E> a, int i, int j) {
    E tmp = a.get(i);
    a.set(i, a.get(j));
    a.set(j, tmp);
}

1
2
3
4
5
6

// 洗牌算法，打乱顺序
public static void shuffle(List<E> list, Random rnd) {
    for (int i = list.size(); i > 1; i--) {
        swap(list, i - 1, rnd.nextInt(i));
    }
}

1
2

char[] charArray = { 'a', 'b', 'c' };
Character[] charObjectArray = ArrayUtils.toObject(charArray);

1
2
3
4
5
6
7
8
9

import java.util.Objects;

public boolean equals(Object o) {
    if (o instanceof E) {
        E e = (E) o;
        //
    }
    return false;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import java.util.Objects;

class Stu {
    String name;
    int score, age;

    public int hashCode() {
        return Objects.hash(name, score, age);
    }
}

1
2

import java.util.stream.Collectors;
import java.util.stream.Stream;

1
2
3
4
5
6
7
8

// 获取流方法1
int[] array = { 1, 2, 3 };
Stream<Integer> s1 = Stream.of(array);
// 获取流方法2
List<Integer> list = List.of(1, 2, 3);
Stream<Integer> s2 = list.stream();
// 获取流方法3
Stream<Integer> s3 = Stream.of(1, 2, 3);

 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
34
35
36
37
38
39
40
41
42
43

// forEach 终端操作
List<Integer> list = List.of(1, 2, 3);
list.stream().forEach(e -> System.out.println(e));
list.stream().forEach(System.out::println);
// map 中间操作
List<String> list = list.stream().map(e -> e.toString()).collect(Collectors.toList());
// collect 终端操作
List<Integer> list = Stream.of(1, 2, 3).collect(Collectors.toList());
String str = list.stream().map(e -> e.toString()).collect(Collectors.joining(", "));
Set<Integer> set = list.stream().collect(Collectors.toSet());
// filter 中间操作
List<Integer> list = Stream.of(1, 2, 3).filter(e -> e < 2).collect(Collectors.toList());
// findFirst
Integer x = Stream.of(1, 2, 3).filter(e -> e % 2 == 1).findFirst().orElse(null);
// toArray
Integer[] array = list.stream().toArray(Integer[]::new);
// flatMap 中间操作
List<List<String>> namesNested = Arrays.asList(
        Arrays.asList("Jeff", "Bezos"),
        Arrays.asList("Bill", "Gates"),
        Arrays.asList("Mark", "Zuckerberg"));
List<String> namesFlatStream = namesNested.stream()
        .flatMap(Collection::stream)
        .collect(Collectors.toList());
// count 终端操作
long a = list.stream().count();
//
Stream<Integer> infiniteStream = Stream.iterate(2, i -> i * 2);
List<Integer> collect = infiniteStream
    .skip(3)  // 跳过前 3 个元素
    .limit(5) // 长度为 5
    .collect(Collectors.toList());
// sorted
list.stream().sorted((a, b) -> b - a);
// min max
Integer x = list.stream().min((a, b) -> a - b).orElse(null);
Integer x = list.stream().max((a, b) -> a - b).orElse(null);
// distinct
List<Integer> newList = list.stream().distinct().collect(Collectors.toList());
// allMatch anyMatch noneMatch
boolean allEven = list.stream().allMatch(i -> i % 2 == 0);
boolean oneEven = list.stream().anyMatch(i -> i % 2 == 0);
boolean noneMultipleOfThree = list.stream().noneMatch(i -> i % 3 == 0);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// IntStream
list.stream().mapToInt(e -> e + 1);
IntStream.of(1, 2, 3);
// range
IntStream.range(1, 4);
// sum
int sum = list.stream().mapToInt(e -> e).sum();
// averge
double avg = list.stream().mapToInt(e -> e).average().orElse(0);
// reduce
int sum = list.stream().mapToInt(e -> e).reduce(0, Integer::sum);
int product = list.stream().mapToInt(e -> e).reduce(1, (a, b) -> a * b);