Java集合详解

活动地址：CSDN21天学习挑战赛

🍁博客主页：👉@不会压弯的小飞侠
✨欢迎关注：👉点赞👍收藏⭐留言✒
✨系列专栏：👉21天挑战回顾java
✨知足上进，不负野心。
🔥欢迎大佬指正，一起学习！一起加油！

在这里插入图片描述

一、集合接口

在这里插入图片描述

Collection接口是构造集合框架的基础，定义了操作对象集合的共同方法。

List接口是有序，可包含重复元素的列表。
Set接口是无序的，无重复元素的集合的列表。

案例分析：

package com.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class CollectionTest1 {
    public static void main(String[] args) {
        //有序，重复，有索引
        Collection c=new ArrayList();
        c.add("a");
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        c.add("d");
        System.out.println(c);  //[a, a, b, c, d, d]
        //无序，不重复，无索引
        Collection c1=new HashSet();
        c1.add("a");
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        c1.add("d");
        System.out.println(c1);  //[a, b, c, d]

    }
}

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

二、Collection常用API

方法名称	说明
public boolean add(E e)	把给定的对象添加到当前集合中
public void clear()	清空集合中所有的元素
public boolean remove(E e)	把给定的对象在当前集合中删除
public boolean contains(Object obj)	判断当前集合中是否包含给定的对象
public boolean isEmpty()	判断当前集合是否为空
public int size()	返回集合中元素的个数。
public Object[] toArray()	把集合中的元素，存储到数组中

案例分析：

package com.collection;

import java.util.ArrayList;
import java.util.Collection;

public class Collection_API {
    public static void main(String[] args) {
        Collection<String> c=new ArrayList<>();
        //添加元素
        c.add("小马哥");
        c.add("小飞侠");
        c.add("罗西");
        c.add("马奎斯");
        c.add("罗西");
        System.out.println(c);  //[小马哥, 小飞侠, 罗西, 马奎斯, 罗西]
        //获取集合大小
        System.out.println(c.size());  //5
        //判断集合是否为空
        System.out.println(c.isEmpty());  //false
       // System.out.println(c);
        //判断集合中是否包含某个元素
        System.out.println(c.contains("小马哥"));  //true
        //删除某个元素，如果是重复元素，则删除第一个
        System.out.println(c.remove("罗西"));  //true
        System.out.println(c);  //[小马哥, 小飞侠, 马奎斯, 罗西]
        //把集合转换为数组
        Object o=c.toString();
        System.out.println(o);  //[小马哥, 小飞侠, 马奎斯, 罗西]
        //清空集合元素
        c.clear();
        System.out.println(c);   //[]
        //将集合c2中的元素倒入c1中
        Collection<String> c1=new ArrayList<>();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        Collection<String> c2=new ArrayList<>();
        c2.add("d");
        c2.add("e");
        c2.add("f");
        c2.add("g");
        c1.addAll(c2);
        System.out.println(c1);  //[a, b, c, d, e, f, g]


    }
}

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

三、collection集合遍历方式

1.Iterator迭代器

Collection集合获取迭代器

方法名称	说明
Iterator iterator()	返回集合中的迭代器对象，该迭代器对象默认指向当前集合的0索引

Iterator常用的方法

方法名称	说明
boolean hasNext()	询问当前位置是否有元素存在，存在返回true ,不存在返回false
E next()	获取当前位置的元素，并同时将迭代器对象移向下一个位置，注意防止取出越界。

案例分析：

package com.collection.iterator;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

//collection集合遍历方式
public class IteratorTest {
    public static void main(String[] args) {
        //iterator遍历
        //创建Collection集合对象
        Collection<String> c=new ArrayList<>();
        //添加元素
        c.add("小马哥");
        c.add("小飞侠");
        c.add("罗西");
        c.add("马奎斯");
        c.add("罗西");
       //得到迭代器对象
        Iterator<String> it = c.iterator();
        //循环遍历
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}
/*
小马哥
小飞侠
罗西
马奎斯
罗西
 */
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

2.增强for循环遍历

for(元素数据类型变量名:数组或者Collection集合){
//在此处使用变量即可，该变量就是元素
}
1
2
3

案例分析：

package com.collection;

import java.util.ArrayList;
import java.util.Collection;

//增强for遍历
public class ForTest {
    public static void main(String[] args) {
        Collection<String> c=new ArrayList<>();
        //添加元素
        c.add("小马哥");
        c.add("小飞侠");
        c.add("罗西");
        c.add("马奎斯");
        c.add("罗西");
        for (String s : c) {
            System.out.println(s);
        }
    }
}
/*
小马哥
小飞侠
罗西
马奎斯
罗西

 */
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

3.案例分析

package com.collection.Test;

public class Student {
    private String name;
    private int age;
    private double height;

    public Student() {
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}


package com.collection.Test;

import java.util.ArrayList;
import java.util.Collection;

public class StudentTest {
    public static void main(String[] args) {
        Collection<Student> students=new ArrayList<>();
        students.add(new Student("小马哥",34,180.5));
        students.add(new Student("小飞侠",44,170.5));
        students.add(new Student("马奎斯",24,190.5));
        students.add(new Student("罗西",54,189.5));
        for (Student student : students) {
            System.out.println(student.getName()+"\t"+student.getAge()+"\t"+student.getHeight());
        }
    }
}
/*
小马哥	34	180.5
小飞侠	44	170.5
马奎斯	24	190.5
罗西	54	189.5
 */

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
68
69
70
71
72
73
74
75

四、List接口

List系列集合特点
- ArrayList、LinekdList :有序，可重复，有索引。
List的实现类的底层原理
- ArrayList底层是基于数组实现的，根据查询元素快，增删相对慢。
- LinkedList底层基于双链表实现的，查询元素慢，增删首尾元素是非常快的。

1.Arraylist类

方法名称	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

案例分析：

package com.list;

import java.util.ArrayList;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        //创建一个List集合对象
        List<String> list=new ArrayList();
        list.add("小马哥");
        list.add("小飞侠");
        list.add("马奎斯");
        list.add("小马哥");
        //在某个索引插入元素
        list.add(1,"罗西");
        System.out.println(list);  //[小马哥, 罗西, 小飞侠, 马奎斯, 小马哥]
        //根据索引删除元素
        list.remove(1);
        System.out.println(list);  //[小马哥, 小飞侠, 马奎斯, 小马哥]
        //根据索引获取元素
        System.out.println(list.get(2));   //马奎斯
        //修改某索引的元素
        list.set(1,"科比");
        System.out.println(list);  //[小马哥, 科比, 马奎斯, 小马哥]
    }
}

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

2.List遍历方式

for循环
iterator迭代器
增强for循环

案例分析：

package com.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//List遍历方式
public class ListTest2 {
    public static void main(String[] args) {
        List<String> list=new ArrayList();
        list.add("小马哥");
        list.add("小飞侠");
        list.add("马奎斯");
        list.add("小马哥");
        //for循环
        for (int i = 0; i <list.size() ; i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println();
        //iterator迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println();
        //增强for循环
        for (String s : list) {
            System.out.println(s);
        }

    }
}
/*
小马哥
小飞侠
马奎斯
小马哥

小马哥
小飞侠
马奎斯
小马哥

小马哥
小飞侠
马奎斯
小马哥
 */
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

3.List遍历删除相同元素

package com.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//遍历删除相同元素
public class ListTest3 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        System.out.println(list);  //[a, b, b, c, d, e]
        //迭代器删除元素
       /* Iterator it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if ("b".equals(s)){
                it.remove();  //使用迭代器删除保证不后移
            }
        }
        System.out.println(list);  //[a, c, d, e]*/

       //for循环删除元素(方式一)
        /*for (int i = 0; i 

        //for循环删除元素(方式二)
        for (int i =list.size()-1; i >=0 ; i--) {
            String s = list.get(i);
            if ("b".equals(s)){
                list.remove("b");
            }

        }
        System.out.println(list);  //[a, c, d, e]

    }
}

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

4.LinkedList类

package com.list;

import java.util.LinkedList;

public class LinkedListTest {
    public static void main(String[] args) {
        //LinkedList可以完成队列结构和栈结构
        //栈
        LinkedList<String> ll=new LinkedList<>();
        //入栈
        ll.addFirst("第一块积木");
        ll.addFirst("第二块积木");
        ll.addFirst("第三块积木");
        ll.addFirst("第四块积木");
        ll.addFirst("第五块积木");
        System.out.println(ll);
        //出栈
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
        System.out.println(ll);
        /*
        [第五块积木, 第四块积木, 第三块积木, 第二块积木, 第一块积木]
        第五块积木
        第四块积木
        第三块积木
        第二块积木
        [第一块积木]
         */

        //队列
        LinkedList<String> ll1=new LinkedList<>();
        //入队
        ll1.addLast("1");
        ll1.addLast("2");
        ll1.addLast("3");
        ll1.addLast("4");
        ll1.addLast("5");
        System.out.println(ll1);
        //出队
        System.out.println(ll1.removeLast());
        System.out.println(ll1.removeLast());
        System.out.println(ll1.removeLast());
        System.out.println(ll1.removeLast());
        System.out.println(ll1);
/*
[1, 2, 3, 4, 5]
5
4
3
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
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

五、set接口

Set系列集合特点
- 无序:存取顺序不一致不重复:可以去除重复
- 无索引:没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。
Set集合实现类特点
- HashSet:无序、不重复、无索引。
- LinkedHashSet:有序、不重复、无索引。
- TreeSet:排序、不重复、无索引。
set集合的功能上基本上与collection的API一致。

1.HashSet类

HashSet:无序、不重复、无索引。

案例分析：

package com.set.hashSet;

import java.util.HashSet;
import java.util.Set;

public class Test1 {
    public static void main(String[] args) {
        Set<String> sets=new HashSet<>();
        sets.add("小马哥");
        sets.add("小飞侠");
        sets.add("马奎斯");
        sets.add("罗西");
        System.out.println(sets);  //[马奎斯, 小马哥, 罗西, 小飞侠]

    }
}

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

综合案例分析：

package com.set.hashSet;

public class Student {
    private String name;
    private int age;
    private char sex;

    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        if (sex != student.sex) return false;
        return name.equals(student.name);
    }

    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + age;
        result = 31 * result + (int) sex;
        return result;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}


package com.set.hashSet;

import java.util.HashSet;
import java.util.Set;

public class StudentTest {
    public static void main(String[] args) {
        Set<Student> sets=new HashSet<>();
        sets.add(new Student("小马哥",34,'男'));
        sets.add(new Student("小马哥",34,'男'));
        sets.add(new Student("小飞侠",24,'女'));
        System.out.println(sets);  //[Student{name='小飞侠', age=24, sex=女}, Student{name='小马哥', age=34, sex=男}]

    }
}


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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

注意：

如果希望Set集合认为2个内容相同的对象是重复的应该怎么办?
- 重写对象的hashCode和equals方法。

2.TreeSet类

TreeSet:排序、不重复、无索引。

案例分析：

package com.set.TreeSet;

import java.util.Set;
import java.util.TreeSet;

public class Test1 {
    public static void main(String[] args) {
        Set<Integer> s1=new TreeSet<>();  //无序，不重复，可排序
        s1.add(21);
        s1.add(12);
        s1.add(12);
        s1.add(1);
        s1.add(56);
        s1.add(45);
        System.out.println(s1);  //[1, 12, 21, 45, 56]

        Set<String> s2=new TreeSet<>();  无序，不重复，可排序
        s2.add("小马哥");
        s2.add("A");
        s2.add("Z");
        s2.add("D");
        s2.add("z");
        s2.add("a");
        System.out.println(s2);  //[A, D, Z, a, z, 小马哥]

    }
}

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

1.自然排序和比较器排序

自定义排序规则
TreeSet集合存储对象的的时候有2种方式可以设计自定义比较规则
方式一
- 让自定义的类（如学生类)实现comparable接口重写里面的compareTo方法来定制比较规则。
方式二
- TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则。

案例分析：

package com.set.TreeSet;

public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private double score;

    public Student(String name) {
        this.name = name;
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
//第一种类定义比较规则
    @Override
    public int compareTo(Student o) {
        //按照年龄排序
        //return this.getAge()-o.getAge(); //去掉了年龄相同的元素
        //[Student{name='小马哥', age=23, score=99.9}, Student{name='马奎斯', age=34, score=70.9}, Student{name='罗西', age=44, score=85.5}]
        return this.getAge()-o.getAge()>=0?1:-1;  //保留了年龄相同的元素
        //[Student{name='小马哥', age=23, score=99.9}, Student{name='小飞侠', age=23, score=89.5}, Student{name='马奎斯', age=34, score=70.9}, Student{name='罗西', age=44, score=85.5}]
    }
}


package com.set.TreeSet;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class StudentTest {
    public static void main(String[] args) {
        //集合自带比较器对象进行规则制定
        Set<Student> s=new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
               // return (int) (o1.getScore()-o2.getScore()); //升序
                return (int) (o2.getScore()-o1.getScore());  //降序
                //[Student{name='小马哥', age=23, score=99.9}, Student{name='小飞侠', age=23, score=89.5}, Student{name='罗西', age=44, score=85.5}, Student{name='马奎斯', age=34, score=70.9}]
            }
        });
        s.add(new Student("小马哥",23,99.9));
        s.add(new Student("小飞侠",23,89.5));
        s.add(new Student("马奎斯",34,70.9));
        s.add(new Student("罗西",44,85.5));
        System.out.println(s);

    }
}

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

注意：

两种方式中，关于返回值的规则：
- 如果认为第一个元素大于第二个元素返回正整数即可。
- 如果认为第一个元素小于第二个元素返回负整数即可。
- 如果认为第一个元素等于第二个元素返回0即可，此时Treeset集合只会保留一个元素，认为两者重复。
注意:
- 如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自带的比较器排序。

六、可变参数

可变参数
- 可变参数用在形参中可以接收多个数据。
- 可变参数的格式:数据类型…参数名称可变参数的作用
传输参数非常灵活，方便。可以不传输参数，可以传输1个或者多个，也可以传输一个数组
- 可变参数在方法内部本质上就是一个数组。
- 可变参数的注意事项:
- 一个形参列表中可变参数只能有一个
- 可变参数必须放在形参列表的最后面

案例分析：

package com.params;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        //不传参数
        //sum();
        //可以传一个参数
        sum(12);
        //可以传多个参数
        sum(23,34,45);
        //可以传一个数组
        //sum(new int[]{12,23,34,45});

    }
    public static void sum(int age,int ... num){
        System.out.println("元素个数："+num.length);
        System.out.println("元素内容："+ Arrays.toString(num));

    }
}
/*
元素个数：0
元素内容：[]
元素个数：1
元素内容：[12]
元素个数：3
元素内容：[23, 34, 45]
元素个数：4
元素内容：[12, 23, 34, 45]

 */
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

七、集合操作的工具类Collections

collections排序相关API
- 使用范围:只能对于List集合的排序。
排序方式1:

方法名称	说明
public static void sort(List list)	将集合中元素按照默认规则排序

注意:本方式不可以直接对自定义类型的List集合排序，除非自定义类型实现了比较规则Comparable接口。
排序方式2:

方法名称	说明
public static void sort(List list,Comparator c)	将集合中元素按照指定规则排序

案例分析：

package com.collection.collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        /*list.add("小马哥");
        list.add("小飞侠");
        list.add("马奎斯");
        list.add("罗西");*/

        //批量添加元素
        Collections.addAll(list,"小马哥","小飞侠","马奎斯","罗西");  //[小马哥, 小飞侠, 马奎斯, 罗西]
        System.out.println(list);
        //打乱集合顺序
        Collections.shuffle(list);
        System.out.println(list);  //[马奎斯, 小飞侠, 罗西, 小马哥]
        //将集合中元素按默认规则排序
        List<Integer> l=new ArrayList<>();
        Collections.addAll(l,12,34,23,78,99,35);
        Collections.sort(l);
        System.out.println(l);  //[12, 23, 34, 35, 78, 99]
        //将集合中元素按指定规则排序
    }
}

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

八、Map接口

1.Map集合概述

Map集合是一种双列集合，每个元素包含两个数据。
Map集合的每个元素的格式: key=value(键值对元素)。
Map集合也被称为“键值对集合”。
Map集合整体格式:
- Collection集合的格式:[元素1,元素2,元素3…]
- Map集合的完整格式:{key1=value1 , key2=value2 , key3=value3 , …}
Map集合体系特点
- Map集合的特点都是由键决定的。
- Map集合的键是无序,不重复的，无索引的，值不做要求（可以重复)。
- Map集合后面重复的键对应的值会覆盖前面重复键的值。
- Map集合的键值对都可以为null。
Map集合实现类特点
- HashMap:元素按照键是无序，不重复，无索引，值不做要求。(与Map体系一致)
- LinkedHashMap:元素按照键是有序，不重复，无索引，值不做要求。

案例分析：

package com.map;
import java.util.HashMap;
import java.util.Map;
public class Test {
    public static void main(String[] args) {
        Map<String,Integer> m=new HashMap<>();
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        m.put(null,null);
        System.out.println(m);  //{null=null, 马奎斯=33, 小马哥=33, 罗西=45, 小飞侠=44}

    }
}

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

2.Map集合API

Map集合
- Map是双列集合的祖宗接口，它的功能是全部双列集合都可以继承使用的。

方法名称	说明
v put(K key,v value)	添加元素
v remove(0bject key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(0bject key)	判断集合是否包含指定的键
boolean containsValue(0bject value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

案例分析：

package com.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test1 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,Integer> m=new HashMap<>();
        //添加元素
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        //清空集合
        //m.clear();
        //System.out.println(m);  //{}
        //判断集合是否为空
        System.out.println(m.isEmpty());  //false
        //根据键获取对应的值
        Integer i = m.get("小马哥");
        System.out.println(i);  //33
        //根据键删除整个元素
        System.out.println(m.remove("小马哥"));  //33
        System.out.println(m);  //{马奎斯=33, 罗西=45, 小飞侠=44}
        //判断是否包含某个键
        System.out.println(m.containsKey("罗西")); //true
        System.out.println(m.containsKey("小马哥"));  //false
        //判断是否包含某个值
        System.out.println(m.containsValue(45));  //true
        //获取全部键的集合
        Set<String> keySet = m.keySet();
        System.out.println(keySet);  //[马奎斯, 罗西, 小飞侠]
        //获取全部值的集合
        Collection<Integer> values = m.values();
        System.out.println(values);  //[33, 45, 44]
        //集合的大小
        System.out.println(m.size());  //3
        //合并其他Map集合
        Map<String,Integer> m1=new HashMap<>();
        m1.put("a",1);
        m1.put("b",2);
        Map<String,Integer> m2=new HashMap<>();
        m1.put("c",3);
        m1.put("d",4);
        m1.putAll(m2);  //把m2中的元素合并到m1中
        System.out.println(m1);   //{a=1, b=2, c=3, d=4}


    }
}

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

3.Map集合遍历方式

1.键找值

先获取Map集合的全部键的Set集合。
遍历键的Set集合，然后通过键提取对应值。

方法名称	说明
`Set keySet()`	获取所有键的集合
V get(Object key)	根据键获取值

案例分析：

package com.map;

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

public class Test2 {
    public static void main(String[] args) {
        Map<String,Integer> m=new HashMap<>();
        //添加元素
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        //键找值
        //先获取所有的键
        Set<String> keys = m.keySet();
        for (String key : keys) {
            Integer values = m.get(key);
            System.out.println(key+"="+values);
        }
    }
}
/*
马奎斯=33
小马哥=33
罗西=45
小飞侠=44

 */
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

2.键值对

先把Map集合转换成Set集合，Set集合中每个元素都是键值对实体类型了。
遍历Set集合，然后提取键以及提取值。
键值对涉及到的API:

方法名称	说明
Set> entrySet(）	获取所有键值对对象的集合
K getKey()	获得键
v getValue()	获取值

案例分析：

package com.map;

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

public class Test3 {
    public static void main(String[] args) {
        Map<String,Integer> m=new HashMap<>();
        //添加元素
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        //把Map集合转换为set集合
        Set<Map.Entry<String, Integer>> entries = m.entrySet();
        //for遍历
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"="+value);
        }

    }
}
/*
马奎斯=33
小马哥=33
罗西=45
小飞侠=44
 */
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

注意：

如果希望元素可以重复，又有索引，索引查询要快?
- 用ArrayList集合，基于数组的。（用的最多)
如果希望元素可以重复，又有索引，增删首尾操作快?
- 用LinkedList集合，基于链表的。
如果希望增删改查都快，但是元素不重复、无序、无索引。
- 用HashSet集合，基于哈希表的。
如果希望增删改查都快，但是元素不重复、有序、无索引。
- 用LinkedHashSet集合，基于哈希表和双链表。
如果要对对象进行排序。
- 用TreeSet集合，基于红黑树。后续也可以用List集合实现排序。

相关阅读:
电销外呼系统主要有哪些作用？
【Note17】PECI（Platform Environment Control Interface）
使用 @GrpcClient 实现客户端
 TCC分布式事务----以Hmily框架为例
 学习笔记——sklearn数据预处理和特征工程(过滤法、嵌入法、包装法)
JS高级---面向对象
 Django 的国际化与本地化详解
 DBus笔记
 RedisStack部署/持久化/安全/与C#项目集成
 Spring Boot事件监听机制：原理、实践与优化之道
原文地址：https://blog.csdn.net/qq_43514330/article/details/126324776

Java集合详解

目录

一、集合接口

二、Collection常用API

三、collection集合遍历方式

1.Iterator迭代器

2.增强for循环遍历

3.案例分析

四、List接口

1.Arraylist类

2.List遍历方式

3.List遍历删除相同元素

4.LinkedList类

五、set接口

1.HashSet类

2.TreeSet类

1.自然排序和比较器排序

六、可变参数

七、集合操作的工具类Collections

八、Map接口

1.Map集合概述

2.Map集合API

3.Map集合遍历方式

1.键找值

2.键值对