java19-集合

集合

集合概述

• 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象操作，就要对对象进行存储
• 使用Array存储对象方面有一些弊端，而集合就像一个容器，可以动态的把多个对象的引用放入容器中

集合框架

Collection接口（单列集合，用来存储一个一个的对象）

• 创造集合

     Collection coll=new ArrayList();
        // add(Object e);
        coll.add("123");
        coll.add(123);
        coll.add(new  Date());
        coll.add(new Person1("jack",20));

        // size
        System.out.println(coll.size());
        // 4
1
2
3
4
5
6
7
8
9
10

• 常用方法

import org.junit.Test;

import java.util.*;

public class CollectionTest {
    @Test
    public void test1(){
        Collection coll=new ArrayList();
        // add(Object e);
        coll.add("123");
        coll.add(123);
        coll.add(new  Date());
        coll.add(new Person1("jack",20));

        // size
        System.out.println(coll.size());
        // 4

        // contains(Object obj)
        // 我们在判断时会调用obj对象所在类的equals()
        boolean contains = coll.contains(123);
        System.out.println(contains);
        // true
        System.out.println(coll.contains(new Person1("jack",20)));
        // true

        // containsAll(Collection coll) 形参coll中所有元素都在当前集合中
        Collection coll1= Arrays.asList(123,"123");
        System.out.println(coll.containsAll(coll1));
        // true

        // remove(Object obj) 移除某个元素 （也会调equals()）
        System.out.println(coll);
        // [123, 123, Thu Dec 08 22:34:36 CST 2022, Person1{name='jack', age=20}]
        coll.remove(123);
        System.out.println(coll);
        // [123, Thu Dec 08 22:34:36 CST 2022, Person1{name='jack', age=20}]

        // removeAll(Collection coll) 移除当前集合中形参coll中所有元素

    }
    @Test
    public void test2(){
        Collection coll1=new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(789);
        Collection coll2=Arrays.asList(123,789);
        // retainAll(Collection coll); 获取当前集合与coll的交集，并返回给当前集合
        coll1.retainAll(coll2);
        System.out.println(coll1);
        //[123, 789]

        // equals(Object obj) 当前集合和形参集合元素相同
        Collection coll3=new ArrayList();
        coll3.add(123);
        coll3.add(789);
        System.out.println(coll3.equals(coll2));
        // true

    }
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("123");
        coll.add(true);
        // hashCode() 返回当前对象的哈希值
        System.out.println(coll.hashCode());
        // 1658615

        // 集合=>数组 toArray()
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
            //123
            //123
            //true
        }

        // 数组=>集合 调Arrays类的静态方法asList()
        List<String> strings = Arrays.asList(new String[]{"123", "456"});
        System.out.println(strings);
        // [123, 456]

    }
    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("123");
        coll.add(true);
        // iterator()返回Iterator接口的实例，用于遍历集合元素，每次都是一个新的迭代器对象
        Iterator iterator = coll.iterator();
        System.out.println(iterator.next());
        // 123

        // hasNext() 是否还有元素
        while (iterator.hasNext()){
            // next() 指针下移，并返回下移后当前元素
            System.out.println(iterator.next());
        }
    }
}
class Person1{
    private String name;
    private int age;
    public Person1(String name,int age) {
        this.name=name;
        this.age=age;
    }

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

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

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

• forEach循环循环遍历集合

import org.junit.Test;

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

public class forEachTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("123");
        coll.add(true);
        // for (集合元素类型 局部变量 ： 集合对象)
        for (Object obj:coll){
            System.out.println(obj);
        }
    }
    @Test
    public void test2(){
        int[] arr=new int[]{1,2,3};
        for (int i:arr){
            System.out.println(i);
        }
    }
}

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

List接口（存储有序的，可重复数据）

• List接口实现类常用有ArrayList,LinkedList,Vector

• List常用方法

import org.junit.Test;

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

public class listTest {
    @Test
    public void test1() {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add("123");
        list.add(123);
        System.out.println(list);
        //[123, 123, 123]

        // void add(int index,Object obj):在index位置插入obj
        list.add(1, 456);
        System.out.println(list);
        // [123, 456, 123, 123]

        // boolean addAll(int index,Collection coll):从index位置将coll所有元素添加
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list);
        // [123, 456, 123, 123, 1, 2, 3]

        // Object get(int index):获取指定位置的元素
        Object obj = list.get(1);
        System.out.println(obj);
        // 456

        // int indexOf(Object obj):获取obj首次出现位置返回
        int index = list.indexOf(123);
        System.out.println(index);
        // 0

        // int lastIndexOf(Object obj):获取obj最后出现位置返回
        int index1 = list.lastIndexOf(123);
        System.out.println(index1);
        // 3

        //Object remove(int index):移除index位置元素，并返回移除元素
        Object remove = list.remove(1);
        System.out.println(remove);
        // 123

        // Object set(int index,Object obj):设置index位置的元素为obj
        list.set(1, "set");
        System.out.println(list);
        // [123, set, 123, 1, 2, 3]

        // list subList(int fromIndex,int toIndex):返回从fromIndex到toIndex元素子集合
        List list2 = list.subList(1, 3);
        System.out.println(list2);
        // [set, 123]
    }
}
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接口（存储无序的，不可重复数据）

1. 无序性和不可重复

• 无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引顺序添加，而是根据数据哈希值
• 不可重复：保证添加的元素按照equals方法判断时不能返回true，即相同元素只能有一个

2. set中没有新增方法，都是collection中方法
3. TreeSet的排序

• 自然排序：比较两个对象是否相等的标准为compareTo()返回为0，不再是equals()

import org.junit.Test;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetTest {
    @Test
    public void test1(){
        TreeSet treeSet = new TreeSet();
        treeSet.add(new User("jack",10));
        treeSet.add(new User("tom",23));
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
            //User{name='jack', age=10}
            //User{name='tom', age=23}
        }
    }
}
class User implements Comparable{
    public String name;
    public Number age;
    public User(String name,Number age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

    public Number getAge() {
        return age;
    }

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

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

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

    // 按照姓名从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user=(User) o;
            return this.name.compareTo(user.name);
        }else {
            throw new RuntimeException("输入类型不匹配");
        }
    }
}
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

• 定制排序：比较两个对象是否相等的标准为compare()返回为0，不再是equals()

Map接口（双列集合，用来存储一对一对的数据（key-value））

• HashMap：作为Map主要实现类，线程不安全，效率高，存储null的key和value
  • linkedHashMap：保证在遍历Map元素时，可以按照添加顺序遍历。原理在原有的HashMap底层结构基础上，添加了一对指针指向前一个和后一个元素。对于频繁的遍历操作，此类效率高于HashMap

import org.junit.Test;

import java.util.HashMap;
import java.util.LinkedHashMap;

public class MapTest { 
    @Test
    public void test2(){
        HashMap map = new HashMap();
        map.put(123,"aa");
        map.put(23,"bb");
        map.put(3,"cc");
        System.out.println(map);
        // {3=cc, 23=bb, 123=aa}
        HashMap map2 = new LinkedHashMap();
        map2.put(123,"aa");
        map2.put(23,"bb");
        map2.put(3,"cc");
        System.out.println(map2);
        // {123=aa, 23=bb, 3=cc}
    }
}

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

• TreeMap：保证按照添加的Key-Value对进行排序，实现排序遍历，要求key必须是同一个类的实例
• Hashtable：作为古老的实现类，线程安全，效率低,不能存储null的key和value
  • Properties：常用来处理配置文件。key和value都是String类型

Map结构

• Map中的key：无序的，不可重复的，使用Set存储所有的key==>key所在的类重写equals()和hashCode()
• Map中的value：无序的，可重复的，使用Collection存储的所有的value==>value所在的类重写equals()
• 一个键值对：key-value构成了一个Entry对象
• Map中的Entry：无序的，不可重复的，使用set存储所有的entry

HashMap底层结构

对于jdk7

• HashMap map = new HashMap();底层创建一个长度是16的一维数组Entry[] table
• map.put(key.value)
  • 调用key所在类的hashCode()计算key的哈希值，此哈希值经过算法后，得到Entry数组中存放位置
    • 如果位置上数据为空，key-value添加成功
    • 如果此位置数据不为空，意味着此位置上存在一个或者多个数据（以链表形式存在），比较key和已有数据的hash值
      • 如果key的Hash值与已经存在的数据的哈希值都不相同，此时数据添加成功
      • 如果key的Hash值与某个数据的Hash值相同，继续比较key的equlas(key2)，如果返回false，此时添加成功；如果返回true， 替换调value
        对于jdk8
• new HashMap()底层没有创建一个长度为16的数组
• jdk8底层数组是node[]
• 首次调用put()时，创建底层长度为16数组
• jdk底层结构：数组+链表+红黑树。当数组某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64，此时此索引位置上的所有数据改为使用红黑树存储

Map常用方法

import org.junit.Test;

import java.util.*;

public class MapTest {
    @Test
    public void test3(){
        HashMap hashMap = new HashMap();
        hashMap.put("AA",12);
        hashMap.put(12,"AA");
        hashMap.put("AA",123);
        System.out.println(hashMap);
        // {AA=123, 12=AA}
        HashMap hashMap1 = new HashMap();
        hashMap1.put("BB",12);
        hashMap.putAll(hashMap1);
        System.out.println(hashMap);
        // {AA=123, BB=12, 12=AA}
        Object value = hashMap.remove("AA");
        System.out.println(value);
        // 123
        System.out.println(hashMap);
        // {BB=12, 12=AA}
        hashMap.clear();
        System.out.println(hashMap);
        // {}
        HashMap hashMap2 = new HashMap();
        hashMap2.put("AA",123);
        hashMap2.put("BB",123);
        Object key = hashMap2.get("AA");
        System.out.println(key);
        Boolean isExist = hashMap2.containsKey("AA");
        System.out.println(isExist);
        isExist = hashMap2.containsValue(123);
        System.out.println(isExist);
        int size = hashMap2.size();
        System.out.println(size);
        boolean empty = hashMap2.isEmpty();
        System.out.println(empty);
        Set set = hashMap2.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
            // AA BB
        }
        Collection values = hashMap2.values();
        for (Object obj: values){
            System.out.println(obj);
            // 123 123
        }
        Set set1 = hashMap2.entrySet();
        Iterator iterator1 = set1.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            // entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey()+"="+entry.getValue());
            // AA=123
            // BB=123
        }
    }
}

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

Properties

• Properties类是Hashtable的子类，该对象用于处理属性文件
• 由于属性文件key-value是字符串类型，所以Properties的key-value是字符串类型
• 用getProperty(String key)和setProperty(String key,String value)

import java.io.FileInputStream;
import java.util.Properties;

public class properties {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        FileInputStream fileInputStream = new FileInputStream("jdbc.properties");
        properties.load(fileInputStream);
        String name = properties.getProperty("name");
        String password = properties.getProperty("password");
        System.out.println("name="+name+"password"+password);
        // name=jackpassword123

    }
}

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

collections工具类

Collections是一个操作Set，List和Map等集合的工具类

import org.junit.Test;

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

public class CollectionsTest {
    @Test
    public void test1(){
        ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(234);
        arrayList.add(345);
        System.out.println(arrayList);
        // [123, 234, 345]
        Collections.reverse(arrayList);
        System.out.println(arrayList);
        // [345, 234, 123]
//        Collections.shuffle(arrayList);
//        System.out.println(arrayList);
//        // [345, 123, 234]
        Collections.swap(arrayList,1,2);
        System.out.println(arrayList);
        // [345, 123, 234]
    }
    @Test
    public void test2(){
        ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(234);
        arrayList.add(345);
        List<Object> dest =  Arrays.asList(new Object[arrayList.size()]);
        // dest.size必须大于arrayList.size
        Collections.copy(dest,arrayList);
        System.out.println(dest);
        // [123, 234, 345]
    }
}

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

同步操作

Collections提供多个synchronizedXXX方法，该方法可以将指定集合包装成线程同步集合，从而可以解决多线程访问集合线程安全问题

Collection c = Collections.synchronizedCollection(new ArrayList());
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());
Map map = Collections.synchronizedMap(new HashMap());
1
2
3
4