JAVA基础学习-集合

本文最后更新于：December 17, 2021 pm

Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。Java 集合框架提供了一套性能优良，使用方便的接口和类，java集合框架位于java.util包中。

目录

1.Collection

Java标准库自带的java.util包提供了集合类：Collection，它是除Map外所有其他集合类的根接口。Java的java.util包主要提供了以下三种类型的集合：

  • List：一种有序列表的集合。

  • Set：一种保证没有重复元素的集合。

  • Map：一种通过键值（key-value）查找的映射表集合。

1.List

在集合类中，List是最基础的一种集合：它是一种有序列表。List的行为和数组几乎完全相同：List内部按照放入元素的先后顺序存放，每个元素都可以通过索引确定自己的位置，List的索引和数组一样，从0开始。在实际应用中，需要增删元素的有序列表，使用最多的是ArrayList。

几个主要的接口方法：

  • 在末尾添加一个元素：boolean add(E e)
  • 在指定索引添加一个元素：boolean add(int index, E e)
  • 删除指定索引的元素：E remove(int index)
  • 删除某个元素：boolean remove(Object e)
  • 获取指定索引的元素：E get(int index)
  • 获取链表大小（包含元素的个数）：int size()

1.1 ArrayList

ArrayList 常用方法：

方法 描述
add() 将元素插入到指定位置的 arraylist 中
addAll() 添加集合中的所有元素到 arraylist 中
clear() 删除 arraylist 中的所有元素
clone() 复制一份 arraylist
contains() 判断元素是否在 arraylist
get() 通过索引值获取 arraylist 中的元素
indexOf() 返回 arraylist 中元素的索引值
removeAll() 删除存在于指定集合中的 arraylist 里的所有元素
remove() 删除 arraylist 里的单个元素
size() 返回 arraylist 里元素数量
isEmpty() 判断 arraylist 是否为空
subList() 截取部分 arraylist 的元素
set() 替换 arraylist 中指定索引的元素
sort() 对 arraylist 元素进行排序
toArray() 将 arraylist 转换为数组
toString() 将 arraylist 转换为字符串
ensureCapacity() 设置指定容量大小的 arraylist
lastIndexOf() 返回指定元素在 arraylist 中最后一次出现的位置
retainAll() 保留 arraylist 中在指定集合中也存在的那些元素
containsAll() 查看 arraylist 是否包含指定集合中的所有元素
trimToSize() 将 arraylist 中的容量调整为数组中的元素个数
removeRange() 删除 arraylist 中指定索引之间存在的元素
replaceAll() 将给定的操作内容替换掉数组中每一个元素
removeIf() 删除所有满足特定条件的 arraylist 元素
forEach() 遍历 arraylist 中每一个元素并执行特定操作
1.1.1 添加元素
1
2
3
4
5
6
7
8
9
10
11
12
13
ArrayList<Integer> al = new ArrayList<>();
        al.add(23);
        al.add(2312);
        al.add(5435);
        al.add(56);
        al.add(45);
        int len = al.size(); //获取总个数
        System.out.println(len);
        System.out.println(al);

//输出
5
[23, 2312, 5435, 56, 45]
1.1.2 输出方式

访问 ArrayList 中的元素可以使用 get() 方法。此方法获取指定索引的元素。

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
44
45
46
47
48
49
50
51
52
53
//=================================================================
//下标输出
ArrayList<Integer> al = new ArrayList<>();
        al.add(23);
        al.add(2312);
        al.add(5435);
        al.add(56);
        al.add(45);
        int len = al.size();
        for(int i = 0; i < len; ++i ){
            System.out.println(al.get(i)); 
        }
//输出结果
23
2312
5435
56
45

//=================================================================
//加强for
ArrayList<Integer> al = new ArrayList<>();
        al.add(23);
        al.add(2312);
        al.add(5435);
        al.add(56);
        al.add(45);
        for(Integer it : al){
            System.out.println(it);
        }

//输出结果同上一样

//=================================================================
//迭代器
ArrayList<Integer> al = new ArrayList<>();
        al.add(23);
        al.add(2312);
        al.add(5435);
        al.add(56);
        al.add(45);
        Iterator<Integer> it = al.iterator();
        while(it.hasNext()){ //hasNext()判断是否有下一个元素
            System.out.println(it.next()); //next()返回下一个元素。
        }

//输出结果
23
2312
5435
56
45

1.1.3 修改元素

使用 set() 方法。

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
ArrayList<Integer> al = new ArrayList<>();
        al.add(23);
        al.add(2312);
        al.add(5435);
        al.add(56);
        al.add(45);
        for(Integer it : al){
            System.out.println(it);
        }
        System.out.println("========================");
        al.set(3,22222222); // 第一个参数为索引位置，第二个为要修改的值。索引不能超过集合中数据的数量，即必须为有效索引，否则会报错。
        for(Integer it : al){
            System.out.println(it);
        }

//输出结果
23
2312
5435
56
45
========================
23
2312
5435
22222222
45
1.1.4 删除元素

使用 remove() 方法。

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
ArrayList<Integer> al = new ArrayList<>();
        al.add(23);
        al.add(2312);
        al.add(5435);
        al.add(56);
        al.add(45);
        for(Integer it : al){
            System.out.println(it);
        }
        System.out.println("========================");
        al.remove(2); //删除索引为2的元素
        for(Integer it : al){
            System.out.println(it);
        }


//输出结果
23
2312
5435
56
45
========================
23
2312
56
45
1.1.5 排序

Collections 类提供的sort() 方法可以对字符或数字列表进行排序。

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
ArrayList<Integer> al = new ArrayList<>();
        al.add(23);
        al.add(2312);
        al.add(5435);
        al.add(56);
        al.add(45);
        for(Integer it : al){
            System.out.println(it);
        }
        System.out.println("========================");
        Collections.sort(al);
        for(Integer it : al){
            System.out.println(it);
        }

//输出结果
23
2312
5435
56
45
========================
23
45
56
2312
5435

1.2 LinkedList

与 ArrayList 相比，LinkedList 的增加和删除对操作效率更高，而查找和修改的操作效率较低。

LinkedList 继承了 AbstractSequentialList 类。实现了 Queue 接口，可作为队列使用。实现了 List 接口，可进行列表的相关操作。实现了 Deque 接口，可作为队列使用。实现了 Cloneable 接口，可实现克隆。实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

常用方法：

方法 描述
public boolean add(E e) 链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public void add(int index, E element) 向指定位置插入元素。
public boolean addAll(Collection c) 将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
public boolean addAll(int index, Collection c) 将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。
public void addFirst(E e) 元素添加到头部。
public void addLast(E e) 元素添加到尾部。
public boolean offer(E e) 向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public boolean offerFirst(E e) 头部插入元素，返回是否成功，成功为 true，失败为 false。
public boolean offerLast(E e) 尾部插入元素，返回是否成功，成功为 true，失败为 false。
public void clear() 清空链表。
public E removeFirst() 删除并返回第一个元素。
public E removeLast() 删除并返回最后一个元素。
public boolean remove(Object o) 删除某一元素，返回是否成功，成功为 true，失败为 false。
public E remove(int index) 删除指定位置的元素。
public E poll() 删除并返回第一个元素。
public E remove() 删除并返回第一个元素。
public boolean contains(Object o) 判断是否含有某一元素。
public E get(int index) 返回指定位置的元素。
public E getFirst() 返回第一个元素。
public E getLast() 返回最后一个元素。
public int indexOf(Object o) 查找指定元素从前往后第一次出现的索引。
public int lastIndexOf(Object o) 查找指定元素最后一次出现的索引。
public E peek() 返回第一个元素。
public E element() 返回第一个元素。
public E peekFirst() 返回头部元素。
public E peekLast() 返回尾部元素。
public E set(int index, E element) 设置指定位置的元素。
public Object clone() 克隆该列表。
public Iterator descendingIterator() 返回倒序迭代器。
public int size() 返回链表元素个数。
public ListIterator listIterator(int index) 返回从指定位置开始到末尾的迭代器。
public Object[] toArray() 返回一个由链表元素组成的数组。
public T[] toArray(T[] a) 返回一个由链表元素转换类型而成的数组。
1.2.1 添加元素
  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
LinkedList<Integer> ll = new LinkedList<>();
        ll.add(23);
        ll.add(56);
        ll.add(34);
        ll.add(657);
        ll.add(214);
        for ( int it : ll){
            System.out.println(it);
        }
        System.out.println("============================");
        
        ll.addFirst(111111);
        
        for ( int it : ll){
            System.out.println(it);
        }

//输出结果
23
56
34
657
214
============================
111111
23
56
34
657
214
  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
LinkedList<Integer> ll = new LinkedList<>();
        ll.add(23);
        ll.add(56);
        ll.add(34);
        ll.add(657);
        ll.add(214);
        for ( int it : ll){
            System.out.println(it);
        }
        System.out.println("============================");
        
        ll.addLast(99999);
        
        for ( int it : ll){
            System.out.println(it);
        }

//输出结果
23
56
34
657
214
============================
23
56
34
657
214
99999
1.2.2 删除元素
  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
LinkedList<Integer> ll = new LinkedList<>();
        ll.add(23);
        ll.add(56);
        ll.add(34);
        ll.add(657);
        ll.add(214);
        for ( int it : ll){
            System.out.println(it);
        }
        System.out.println("============================");
        
        ll.removeFirst();
        
        for ( int it : ll){
            System.out.println(it);
        }

//输出结果
23
56
34
657
214
============================
56
34
657
214
  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
LinkedList<Integer> ll = new LinkedList<>();
        ll.add(23);
        ll.add(56);
        ll.add(34);
        ll.add(657);
        ll.add(214);
        for ( int it : ll){
            System.out.println(it);
        }
        System.out.println("============================");

        ll.removeLast();

        for ( int it : ll){
            System.out.println(it);
        }

//输出结果
23
56
34
657
214
============================
23
56
34
657
1.2.3 获取元素
  1. 头部获取元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
LinkedList<Integer> ll = new LinkedList<>();
        ll.add(23);
        ll.add(56);
        ll.add(34);
        ll.add(657);
        ll.add(214);
        for ( int it : ll){
            System.out.println(it);
        }
        System.out.println("============================");

        int mi = ll.getFirst();

        System.out.println(mi);

//输出结果
23
56
34
657
214
============================
23
  1. 尾部获取元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
LinkedList<Integer> ll = new LinkedList<>();
        ll.add(23);
        ll.add(56);
        ll.add(34);
        ll.add(657);
        ll.add(214);
        for ( int it : ll){
            System.out.println(it);
        }
        System.out.println("============================");

        int mi = ll.getLast();

        System.out.println(mi);

//输出结果
23
56
34
657
214
============================
214

1.3 Vector（遗留类）

一种线程安全的List实现。

见蓝桥杯JAVA-7.集合（容器）在竞赛中的使用

2.Set

Set用于存储不重复的元素集合。

  • 将元素添加进Set<E>：boolean add(E e)
  • 将元素从Set<E>删除：boolean remove(Object e)
  • 判断是否包含元素：boolean contains(Object e)
  • HashSet是无序的，因为它实现了Set接口，并没有实现SortedSet接口；
  • TreeSet是有序的，因为它实现了SortedSet接口。

2.1 TreeSet（无重复有序）

是自带排序的set，没有重复元素。

API见图。

示例：

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
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        TreeSet<String> ts = new TreeSet<>();
        ts.add("C");
        ts.add("A");
        ts.add("D");
        ts.add("A");
        ts.add("F");
        ts.add("G");
        System.out.println("-------------遍历方式：1、使用迭代器遍历------------");
        Iterator<String> ite = ts.iterator();
        while (ite.hasNext()) {
            System.out.println(ite.next());
        }
        System.out.println("-------------遍历方式：2、使用数组遍历------------");
        Object[] objs = ts.toArray();
        for (int i = 0; i < objs.length; i++) {
            System.out.println(objs[i]);
        }

    }

//输出
-------------遍历方式：1、使用迭代器遍历------------
A
C
D
F
G
-------------遍历方式：2、使用数组遍历------------
A
C
D
F
G
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import javafx.util.Pair;

import java.io.*;
import java.util.*;

/**
 * @Author DragonOne
 * @Date 2021/12/5 21:27
 * @墨水记忆 www.tothefor.com
 */
public class Main {

    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        TreeSet<book> set=new TreeSet<book>(new BookComparator());
        set.add(new book("流浪地球",100));
        set.add(new book("三体",90));
        set.add(new book("大秦帝国",110));
        System.out.println(set.toString());
        System.out.println("-------------遍历方式：1、使用迭代器遍历------------");
        Iterator<book> iteBook = set.iterator();
        while(iteBook.hasNext()) {
            System.out.println(iteBook.next());
        }
        System.out.println("-------------遍历方式：2、使用数组遍历------------");
        Object[] objsBook = set.toArray();
        for(int i=0;i<objsBook.length;i++) {
            System.out.println(objsBook[i]);
        }

    }
    static class book {
        String name;
        double price;
        book(String name,double price){
            this.name=name;
            this.price=price;
        }
        @Override
        public String toString() {
            return "书名:"+this.name+" 价格:"+this.price;
        }
    }
    static class BookComparator implements Comparator<book> {
        @Override
        public int compare(book o1, book o2) {
            if (o1.price > o2.price) {
                return 1;
            } else if (o1.price < o2.price) {
                return -1;
            }
            return 0;
        }
    }

}

//输出
[书名:三体 价格:90.0, 书名:流浪地球 价格:100.0, 书名:大秦帝国 价格:110.0]
-------------遍历方式：1、使用迭代器遍历------------
书名:三体 价格:90.0
书名:流浪地球 价格:100.0
书名:大秦帝国 价格:110.0
-------------遍历方式：2、使用数组遍历------------
书名:三体 价格:90.0
书名:流浪地球 价格:100.0
书名:大秦帝国 价格:110.0
2.自定义比较器（类中实现Comparable接口）
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
44
45
46
47
import javafx.util.Pair;

import java.io.*;
import java.util.*;

/**
 * @Author DragonOne
 * @Date 2021/12/5 21:27
 * @墨水记忆 www.tothefor.com
 */
public class Main {

    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        System.out.println("-------------------------");
        TreeSet<person> setPerson=new TreeSet<person>();
        setPerson.add(new person("张三",20));
        setPerson.add(new person("李四",19));
        setPerson.add(new person("王五",32));
        System.out.println(setPerson.toString());

    }
    static class person implements Comparable<person>{
        String name;  int age;
        person(String name,int age){
            this.name=name;   this.age=age;
        }
        @Override
        public String toString() {
            return "姓名："+this.name+" 年龄:"+this.age;
        }
        @Override
        public int compareTo(person o) {
            if(o.age>this.age) {
                return 1;
            } else if(o.age<this.age) {
                return -1;
            }
            return 0;
        }
    }

}

//输出
-------------------------
[姓名：王五 年龄:32, 姓名：张三 年龄:20, 姓名：李四 年龄:19]

2.2 HashSet（无重复无序）

基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。允许有 null 值。是无序的。不是线程安全的。实现了 Set 接口。

2.2.1 添加元素
1
2
3
4
5
6
7
8
9
10
11
HashSet<Integer> hs = new HashSet<>();
        hs.add(23);
        hs.add(23);
        hs.add(1213);
        hs.add(567);
        hs.add(654);
        System.out.println(hs);

//输出结果
[23, 567, 1213, 654]
//重复元素只会出现一次，因为集合中的每个元素都必须是唯一的。
2.2.2. 删除元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
HashSet<Integer> hs = new HashSet<>();
        hs.add(23);
        hs.add(23);
        hs.add(1213);
        hs.add(567);
        hs.add(654);
        for(int it : hs){
            System.out.println(it);
        }
        System.out.println("===========================");
        hs.remove(1213);
        for(int it : hs){
            System.out.println(it);
        }

//输出结果
23
567
1213
654
===========================
23
567
654
2.2.3 判断元素是否存在
1
2
3
4
5
6
7
8
9
10
11
12
HashSet<Integer> hs = new HashSet<>();
        hs.add(23);
        hs.add(23);
        hs.add(1213);
        hs.add(567);
        hs.add(654);
        System.out.println(hs.contains(567));
        System.out.println(hs.contains(5672));

//输出结果
true
false

2.3 LinkedHashSet

无重复有序，但此有序非之前的TreeSet的有序。它是你输入的顺序。你怎么输入的，就怎么输出。

示例：

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
public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        LinkedHashSet<String> ls = new LinkedHashSet<>();
        ls.add("C");
        ls.add("E");
        ls.add("B");
        ls.add("G");
        ls.add("A");
        ls.add("D");
        ls.add("F");
        ls.add("H");
        Iterator<String> it = ls.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

    }

//输出
C
E
B
G
A
D
F
H

3.Queue

Queue的实现类有LinkedList和PriorityQueue。最常用的实现类是LinkedList。

3.1 LinkedList

见蓝桥杯JAVA-7.集合（容器）在竞赛中的使用

3.2 PriorityQueue

见蓝桥杯JAVA-7.集合（容器）在竞赛中的使用

2.Map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
       ┌───┐
       │Map│
       └───┘
         ▲
    ┌────┴─────┐
    │          │
┌───────┐ ┌─────────┐
│HashMap│ │SortedMap│
└───────┘ └─────────┘
               ▲
               │
          ┌─────────┐
          │ TreeMap │
          └─────────┘

SortedMap是接口，它的实现类是TreeMap。

2.1 TreeMap

HashMap是一种以空间换时间的映射表，它的实现原理决定了内部的Key是无序的，即遍历HashMap的Key时，其顺序是不可预测的（但每个Key都会遍历一次且仅遍历一次）。SortedMap保证遍历时以Key的顺序来进行排序。String默认按字母排序。

2.1.1 添加元素

1
2
3
4
5
6
7
8
9
10
TreeMap<String,Integer> tm = new TreeMap<>();
        tm.put("apre",2);
        tm.put("zfwe",43);
        tm.put("ret",14);
        tm.put("noetjr",576);
        tm.put("mweq",789);
        System.out.println(tm);

//输出结果
{apre=2, mweq=789, noetjr=576, ret=14, zfwe=43}

使用TreeMap时，放入的Key必须实现Comparable接口。String、Integer这些类已经实现了Comparable接口，因此可以直接作为Key使用。作为Value的对象则没有任何要求。如果作为Key的class没有实现Comparable接口，那么，必须在创建TreeMap时同时指定一个自定义排序算法。

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
public class Main {
    public static void main(String[] args) {
        Map<Person, Integer> map = new TreeMap<>(new Comparator<Person>() {
            public int compare(Person p1, Person p2) {
                return p1.name.compareTo(p2.name);
            }
        });
        map.put(new Person("Tom"), 1);
        map.put(new Person("Bob"), 2);
        map.put(new Person("Lily"), 3);
        for (Person key : map.keySet()) {
            System.out.println(key);
        }
        // {Person: Bob}, {Person: Lily}, {Person: Tom}
        System.out.println(map.get(new Person("Bob"))); // 2
    }
}

class Person {
    public String name;
    Person(String name) {
        this.name = name;
    }
    public String toString() {
        return "{Person: " + name + "}";
    }
}

Comparator接口要求实现一个比较方法，它负责比较传入的两个元素a和b，如果a<b，则返回负数，通常是-1，如果a==b，则返回0，如果a>b，则返回正数，通常是1。TreeMap内部根据比较结果对Key进行排序。

其他方法的使用可以参考下面的HashMap。

2.2 HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。是无序的，即不会记录插入的顺序。HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。HashMap 的 key 与 value 类型可以相同也可以不同。

HashMap 常用方法：

方法 描述
clear() 删除 hashMap 中的所有键/值对
clone() 复制一份 hashMap
isEmpty() 判断 hashMap 是否为空
size() 计算 hashMap 中键/值对的数量
put() 将键/值对添加到 hashMap 中
putAll() 将所有键/值对添加到 hashMap 中
putIfAbsent() 如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。
remove() 删除 hashMap 中指定键 key 的映射关系
containsKey() 检查 hashMap 中是否存在指定的 key 对应的映射关系。
containsValue() 检查 hashMap 中是否存在指定的 value 对应的映射关系。
replace() 替换 hashMap 中是指定的 key 对应的 value。
replaceAll() 将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。
get() 获取指定 key 对应对 value
getOrDefault() 获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
forEach() 对 hashMap 中的每个映射执行指定的操作。
entrySet() 返回 hashMap 中所有映射项的集合集合视图。
keySet() 返回 hashMap 中所有 key 组成的集合视图。
values() 返回 hashMap 中存在的所有 value 值。
merge() 添加键值对到 hashMap 中
compute() 对 hashMap 中指定 key 的值进行重新计算
computeIfAbsent() 对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中
computeIfPresent() 对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。

2.2.1 添加元素

1
2
3
4
5
6
7
8
9
10
HashMap<Integer,String> hm = new HashMap<>();
        hm.put(1,"abc");
        hm.put(2,"defa");
        hm.put(3,"ghij");
        hm.put(4,"klim");
        hm.put(5,"nopq");
        System.out.println(hm);

//输出结果
{1=abc, 2=defa, 3=ghij, 4=klim, 5=nopq}

2.2.2 删除元素

使用 remove(key) 方法来删除 key 对应的键值对。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
HashMap<Integer,String> hm = new HashMap<>();
        hm.put(11,"abc");
        hm.put(21,"defa");
        hm.put(33,"ghij");
        hm.put(44,"klim");
        hm.put(55,"nopq");
        System.out.println(hm);
        System.out.println(hm.remove(33));
        System.out.println(hm);

//输出结果
{33=ghij, 21=defa, 55=nopq, 11=abc, 44=klim}
ghij
{21=defa, 55=nopq, 11=abc, 44=klim}

2.2.3 获取元素、获取key、获取value

使用 get(key) 方法来获取 key 对应的 value。使用 keySet() 方法，获取 key。

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//=================================================
//获取key
HashMap<Integer,String> hm = new HashMap<>();
        hm.put(1,"abc");
        hm.put(2,"defa");
        hm.put(3,"ghij");
        hm.put(4,"klim");
        hm.put(5,"nopq");
        System.out.println(hm);
        Set<Integer> itt = hm.keySet();
        for (int it :itt){
            System.out.println(it);
        }

//输出结果
{1=abc, 2=defa, 3=ghij, 4=klim, 5=nopq}
1
2
3
4
5




//=================================================
//获取value
HashMap<Integer,String> hm = new HashMap<>();
        hm.put(1,"abc");
        hm.put(2,"defa");
        hm.put(3,"ghij");
        hm.put(4,"klim");
        hm.put(5,"nopq");
        System.out.println(hm);
        Collection<String> itt = hm.values();
        for (String it :itt){
            System.out.println(it);
        }

//输出结果
{1=abc, 2=defa, 3=ghij, 4=klim, 5=nopq}
abc
defa
ghij
klim
nopq




//=================================================
//通过key获取value
HashMap<Integer,String> hm = new HashMap<>();
        hm.put(11,"abc");
        hm.put(21,"defa");
        hm.put(33,"ghij");
        hm.put(44,"klim");
        hm.put(55,"nopq");
        System.out.println(hm);
        System.out.println(hm.get(33));

//输出结果
{33=ghij, 21=defa, 55=nopq, 11=abc, 44=klim}
ghij

2.2.4 清空

1
2
3
4
5
6
7
8
9
10
11
12
13
HashMap<Integer,String> hm = new HashMap<>();
        hm.put(11,"abc");
        hm.put(21,"defa");
        hm.put(33,"ghij");
        hm.put(44,"klim");
        hm.put(55,"nopq");
        System.out.println(hm);
        hm.clear();
        System.out.println(hm);

//输出结果
{33=ghij, 21=defa, 55=nopq, 11=abc, 44=klim}
{}

2.4 LinkedHashMap

1.entrySet()获取全部的键值对

返回的数据类型是Map.Entry。

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
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        LinkedHashMap<String,Integer> lm = new LinkedHashMap<>();
        lm.put("C",3);
        lm.put("A",1);
        lm.put("B",2);
        lm.put("D",4);
        Set<Map.Entry<String,Integer> > sets = lm.entrySet();
        Iterator<Map.Entry<String, Integer>> it = sets.iterator();
        while(it.hasNext()){
            Map.Entry<String, Integer> mt = it.next();
            System.out.println(mt);
            System.out.println(mt.getKey());
            System.out.println(mt.getValue());
            System.out.println("========================");
        }

//        closeAll();
    }

//输出
C=3
C
3
========================
A=1
A
1
========================
B=2
B
2
========================
D=4
D
4
========================
2.分别获取键和值集合

获取键后，也可以通过get(key)再获取对应的值。

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
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        LinkedHashMap<String,Integer> lm = new LinkedHashMap<>();
        lm.put("C",3);
        lm.put("A",1);
        lm.put("B",2);
        lm.put("D",4);
        Set<String> set = lm.keySet();
        Iterator<String> it = set.iterator();
        System.out.println("所有的键为：");
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("=======================");

        Collection<Integer> values = lm.values();
        Iterator<Integer> it2 = values.iterator();
        System.out.println("所有的值为：");
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
        System.out.println("=======================");
//        closeAll();
    }

//输出
所有的键为：
C
A
B
D
=======================
所有的值为：
3
1
2
4
=======================
JAVA
JAVA

本文作者: 墨水记忆
本文链接: https://tothefor.com/DragonOne/3264474202.html
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！