Ming-Log's Blog

记录生活中的点点滴滴

0%

Java(22)List集合和Set集合

发表于 更新于 分类于
本文字数： 13k 阅读时长 ≈ 12 分钟

List集合

java.util.List接口 extends Collection接口

List接口:

  1. 有序集合，存储元素和取出元素的顺序是一致的(存储123 取出123)

  2. 有索引，包含了一些带索引的方法

  3. 允许存储重复的元素

List 接口中带索引的方法（特有）

1
2
3
4
public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
public E get(int index):返回集合中指定位置的元素。
public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

注意：

​ 操作索引的时候，一定要防止索引越界异常

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
package com.tipdm.Demo01;

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

public class demo1 {
    public static void main(String[] args) {
        // 创建一个List集合对象，多态
        List<String> list = new ArrayList<>();
        // 使用add方法往集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        // 打印集合
        System.out.println(list);  // [a, b, c, d, a]   允许存储重复元素，并且重写了toString()方法
        // public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
        // 在c和d之间添加一个元素“tipdm”
        list.add(3, "tipdm");
        System.out.println(list);  // [a, b, c, tipdm, d, a]

        // public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
        // 移除c元素
        String re = list.remove(2);
        System.out.println(re);  // c
        System.out.println(list);  // [a, b, tipdm, d, a]

        // public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
        // 将d换成lm
        String se = list.set(3, "lm");
        System.out.println(se);  // d
        System.out.println(list);  // [a, b, tipdm, lm, a]

        // 获取第3个位置元素
        String ge = list.get(3);
        System.out.println(ge);  // lm
        System.out.println("===============");

        // List集合遍历有3种方式
        // 1. 使用普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("===============");

        // 2. 使用迭代器
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("===============");

        // 3. 使用增强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
[a, b, c, d, a]
[a, b, c, tipdm, d, a]
c
[a, b, tipdm, d, a]
d
[a, b, tipdm, lm, a]
lm
===============
a
b
tipdm
lm
a
===============
a
b
tipdm
lm
a
===============
a
b
tipdm
lm
a

进程已结束,退出代码0

ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

集合

java.util.LinkedList集合 implements List 接口

LinkedList集合的特点：

  1. 底层是一个链表接口：查询慢，增删快

  2. 里面包含了大量操作首尾元素的方法

注意：使用LinkedList集合特有的方法，不能使用多态

1
2
3
4
5
6
7
8
9
10
11
12
public void addFirst(E e):将指定元素插入此列表的开头。
public void push(E e):将元素推入此列表所表示的堆栈。
public void addLast(E e)`:将指定元素添加到此列表的结尾。

public E getFirst()`:返回此列表的第一个元素。
public E getLast()`:返回此列表的最后一个元素。

public E removeFirst()`:移除并返回此列表的第一个元素。
public E pop()`:从此列表所表示的堆栈处弹出一个元素。
public E removeLast()`:移除并返回此列表的最后一个元素

public boolean isEmpty()`：如果列表不包含元素，则返回true。
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
package com.tipdm.Demo01;

import java.util.LinkedList;

public class demo2LinkedList {
    public static void main(String[] args) {
        show01();
        System.out.println("================");
        show02();
        System.out.println("================");
        show03();
        System.out.println("================");
    }

    /**
     * public E removeFirst():移除并返回此列表的第一个元素。
     * public E pop():从此列表所表示的堆栈处弹出一个元素。
     * public E removeLast():移除并返回此列表的最后一个元素
     */
    private static void show03() {
        // 创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        // 使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        linked.add("d");
        linked.add("e");

        System.out.println(linked);  // [a, b, c, d, e]
        System.out.println(linked.removeFirst());  //a
        System.out.println(linked);  // [b, c, d, e]

        System.out.println(linked.removeLast());  // e
        System.out.println(linked);  // [b, c, d]

        System.out.println(linked.pop());  // b  与removeFirst()等效
        System.out.println(linked);  // [c, d]
    }

    /**
     * public E getFirst():返回此列表的第一个元素。
     * public E getLast():返回此列表的最后一个元素。
     */
    private static void show02() {
        // 创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        // 使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked.getFirst());  // a
        System.out.println(linked.getLast());  // c

        linked.clear();
        if(linked.isEmpty()){
            System.out.println("空集合!");
        }else{
            System.out.println(linked.getFirst());
        }

    }

    /**
     * public void addFirst(E e):将指定元素插入此列表的开头。
     * public void push(E e):将元素推入此列表所表示的堆栈。
     * public void addLast(E e):将指定元素添加到此列表的结尾。
     */
    private static void show01() {
        // 创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        // 使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);  // [a, b, c]

        linked.addFirst("www");
        System.out.println(linked);  // [www, a, b, c]

        linked.push("https://");
        System.out.println(linked);  // [https://, www, a, b, c]   此方法等效于  addFirst()

        linked.addLast(".com");
        System.out.println(linked);  // [https://, www, a, b, c, .com]  此方法等效于 add()
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[a, b, c]
[www, a, b, c]
[https://, www, a, b, c]
[https://, www, a, b, c, .com]
================
a
c
空集合!
================
[a, b, c, d, e]
a
[b, c, d, e]
e
[b, c, d]
b
[c, d]
================

进程已结束,退出代码0

Set集合

java.util.Set接口 extends Collection 接口

Set接口特点：

  1. 不允许存储重复的元素

  2. 没有索引，没有带索引的方法，也不能使用普通的for循环遍历

java.util.HashSet集合 implements Set接口

HashSet特点：

  1. 不允许存储重复的元素

  2. 没有索引，没有带索引的方法，也不能使用普通的for循环遍历

  3. 是一个无序的集合，存储元素和取出元素的顺序有可能不一致

  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
package com.tipdm.Demo01;

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

/**
 * java.util.Set接口 extends Collection 接口
 * Set接口特点：
 *      1. 不允许存储重复的元素
 *      2. 没有索引，没有带索引的方法，也不能使用普通的for循环遍历
 * java.util.HashSet集合 implements Set接口
 * HashSet特点：
 *      1. 不允许存储重复的元素
 *      2. 没有索引，没有带索引的方法，也不能使用普通的for循环遍历
 *      3. 是一个无序的集合，存储元素和取出元素的顺序有可能不一致
 *      4. 底层是一个哈希表结构（查询的速度非常快）
 */
public class demo3Set {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        // 使用add方法往集合中添加元素
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(5);
        set.add(2);
        // 使用迭代器遍历set集合
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());  // 1 2 3 5 无重复,无顺序元素
        }
        // 使用增强for遍历
        System.out.println("====================");
        for (Integer integer : set) {
            System.out.println(integer);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
1
2
3
5
====================
1
2
3
5

进程已结束,退出代码0

哈希值

哈希值:是一个十进制的整数，由系统随机给出（就算对象的地址值，是一个逻辑地址。是模拟出来得到地址，不是数据实际存储的物理地址）

在Object类有一个方法，可以获取对象的哈希值

1
int hashCode()

返回该对象的哈希码值。

hashCode方法的源码：

1
public native int hashCode();

native:代表该方法调用的是本地操作系统的方法。

Person类：

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
package com.tipdm.Demo01;

import java.util.Objects;

public class Person extends Object{
    private String name;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

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

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

    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 Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

主类：

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
package com.tipdm.Demo01;

/**
 * 哈希值:是一个十进制的整数，由系统随机给出（就算对象的地址值，是一个逻辑地址。是模拟出来得到地址，不是数据实际存储的物理地址）
 * 在Object类有一个方法，可以获取对象的哈希值
 *  int hashCode()
 *           返回该对象的哈希码值。
 * hashCode方法的源码：
 *      public native int hashCode();
 *      native:代表该方法调用的是本地操作系统的方法。
 */
public class demo4Hashcode {
    public static void main(String[] args) {
        // Person类继承了Object类，所以可以使用Object类的hashCode方法
        Person p1 = new Person();
        int h1 = p1.hashCode();
        System.out.println(h1);  // 460141958

        Person p2 = new Person();
        int h2 = p2.hashCode();
        System.out.println(h2);  // 1163157884

        /**
         * toString方法的源码：
         *      public String toString() {
         *         return getClass().getName() + "@" + Integer.toHexString(hashCode());
         *     }
         */
        System.out.println(p1);  // 1b6d3586  对应的十六进制值
        System.out.println(p2);  // 4554617c

        /**
         * String类的哈希值
         * String类重写了Object类的hashCode方法
         */
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode());  // 96354
        System.out.println(s2.hashCode());

        System.out.println("重地".hashCode());  // 1179395  哈希冲突（两个元素不同，但是哈希值相同）
        System.out.println("通话".hashCode());  // 1179395
    }
}
1
2
3
4
5
6
7
8
9
10
961
961
Person{name='null', age=0}
Person{name='null', age=0}
96354
96354
1179395
1179395

进程已结束,退出代码0

Set集合不允许重复元素的原理

Set集合在调用add方法的时候，add方法会调用元素的hashCode方法和equals方法，判断元素是否重复
set.add(s1);
add方法会调用s1的hashCode方法，计算字符串”abc”的哈希值，哈希值是96354
在集合中找有没有96354这个哈希值的元素

  • 发现有(发生哈希冲突)会调用equals方法和哈希值相同的元素进行比较 s2.equals(s1)

    • 若返回true，两个元素的哈希值相同，equals方法返回true，认定两个元素相同就不会把元素存储到集合
    • 若返回false，则认定两个元素不同，就会把元素存储到集合中。

  • 发现没有直接存储元素。

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
package com.tipdm.Demo01;

import java.util.HashSet;

/**
 * Set集合不允许重复元素的原理
 */
public class demo5HashSetSaveString {
    public static void main(String[] args) {
        // 创建HashSet集合对象
        HashSet<String> set = new HashSet<>();
        String s1 = new String("abc");
        String s2 = new String("abc");
        set.add(s1);
        set.add(s2);
        set.add("重地");
        set.add("通话");
        set.add("abc");
        System.out.println(set);  // [重地, 通话, abc]
        // Set集合在调用add方法的时候，add方法会调用元素的hashCode方法和equals方法，判断元素是否重复
        // set.add(s1);
        // add方法会调用s1的hashCode方法，计算字符串"abc"的哈希值，哈希值是96354
        // 在集合中找有没有96354这个哈希值的元素
        // 发现有(发生哈希冲突)会调用equals方法和哈希值相同的元素进行比较 s2.equals(s1)
        //      若返回true，两个元素的哈希值相同，equals方法返回true，认定两个元素相同就不会把元素存储到集合中
        //      若返回false，则认定两个元素不同，就会把元素存储到集合中。
        // 发现没有直接存储元素。
    }
}
1
2
3
[重地, 通话, abc]

进程已结束,退出代码0

HashSet存储自定义类型元素

使用hashSet存储自定义类型元素

set集合保持元素唯一：

存储的元素(String, Integer, …, Student, Person …), 必须重写hashCode方法和equals方法

要求：

同名同年龄的人，视为同一个人，只能存储一次

person类：

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
package com.tipdm.Demo01;

import java.util.Objects;

public class Person extends Object{
    private String name;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

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

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

    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 Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

主类：

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
package com.tipdm.Demo01;

import java.util.HashSet;

/**
 * 使用hashSet存储自定义类型元素
 *
 * set集合保持元素唯一：
 *      存储的元素(String, Integer, ..., Student, Person ...), 必须重写hashCode方法和equals方法
 * 要求：
 *      同名同年龄的人，视为同一个人，只能存储一次
 */
public class demo6HashSetSavePerson {
    public static void main(String[] args) {
        // 创建hashSet集合存储Person
        HashSet<Person> set = new HashSet<>();
        Person p1 = new Person("小美女", 18);
        Person p2 = new Person("小美女", 18);
        Person p3 = new Person("小美女", 19);
        System.out.println(p1.hashCode());  // 460141958
        System.out.println(p2.hashCode());  // 1163157884
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set);    // [Person{name='小美女', age=19},
                                    // Person{name='小美女', age=18},
                                    // Person{name='小美女', age=18}]

        // 重写hashCode方法后后
        System.out.println(p1.hashCode());  // 734175839
        System.out.println(p2.hashCode());  // 734175839
        System.out.println(set);    // [Person{name='小美女', age=19},
                                    // Person{name='小美女', age=18}]
    }
}

重写HashCode方法前：

1
2
3
4
5
6
7
8
460141958
1163157884
[Person{name='小美女', age=19}, Person{name='小美女', age=18}, Person{name='小美女', age=18}]
460141958
1163157884
[Person{name='小美女', age=19}, Person{name='小美女', age=18}, Person{name='小美女', age=18}]

进程已结束,退出代码0

重写HashCode方法后：

1
2
3
4
5
6
7
8
734175839
734175839
[Person{name='小美女', age=19}, Person{name='小美女', age=18}]
734175839
734175839
[Person{name='小美女', age=19}, Person{name='小美女', age=18}]

进程已结束,退出代码0

LinkedHashSet集合

java.util.LinkedHashSet集合 extend HashSet集合

LinkedHashSet集合特点：

  • 有序
  • 不允许重复

底层是一个哈希表(数组+链表/红黑树) + 链表：多了一条链表(记录元素的存储顺序)，保证元素有序。

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
package com.tipdm.Demo01;

import java.util.HashSet;
import java.util.LinkedHashSet;

/**
 * java.util.LinkedHashSet集合 extend HashSet集合
 * LinkedHashSet集合特点：
 *      底层是一个哈希表(数组+链表/红黑树) + 链表：多了一条链表(记录元素的存储顺序)，保证元素有序
 */
public class demo7LinkedHashSet {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("abc");
        set.add("abc");
        set.add("www");
        set.add("com");
        System.out.println(set);  // [com, abc, www]  无序，不允许重复
        System.out.println("=======================");
        LinkedHashSet<String> linkedset = new LinkedHashSet<>();
        linkedset.add("abc");
        linkedset.add("abc");
        linkedset.add("www");
        linkedset.add("com");
        System.out.println(linkedset);  // [abc, www, com]  有序，不允许重复
    }
}
1
2
3
4
5
[com, abc, www]
=======================
[abc, www, com]

进程已结束,退出代码0
-------------本文结束感谢您的阅读-------------