Java常用集合的创建，添加，取出，遍历等_java创建集合对象

1、ArrayList 集合

1.1、每个集合对象的创建（new）
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合

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

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
 */
public class ArrayListTest {
    public static void main(String[] args) {
        // 创建ArrayList集合
        ArrayList<String> arrayList = new ArrayList<>();
        // 向集合添加元素
        arrayList.add("zhangsan");
        arrayList.add("lisi");
        arrayList.add("wangwu");
        arrayList.add("zhaoliu");
        // 从集合中取出某个元素
        String i = arrayList.get(1);
        System.out.println(i);
        System.out.println("===============分割线============");
        // 遍历集合 获取迭代器进行集合遍历
        Iterator<String> it = arrayList.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println("\n===============分割线============");
        // 遍历集合 通过迭代器配合for循环遍历
        for(Iterator<String> its = arrayList.iterator() ;its.hasNext();){
            System.out.println("====>"+its.next());
        }
        System.out.println("===============分割线=============");
        // 遍历集合 通过增强for
        for(String fors : arrayList){
            System.out.print(fors+" ");
        }
        System.out.println("\n===============分割线=============");
        // 遍历集合 通过获取长度加for的方式
        for(int j = 0;j < arrayList.size();j++){
            System.out.print(arrayList.get(j)+" ");
        }
    }
}

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

2、HashMap集合

1.1、每个集合对象的创建（new）
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合

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

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
 */
public class HashMapTest {
    public static void main(String[] args) {
        // 创建 HashMap 集合
        HashMap<Integer,String> hashMap = new HashMap<>();
        // 向集合中添加元素
        hashMap.put(1,"zhangsan");
        hashMap.put(2,"lisi");
        hashMap.put(3,"wangwu");
        hashMap.put(4,"zhaoliu");
        // 从集合中取出某个元素
        String s = hashMap.get(1);
        System.out.println(s);
        // 遍历集合 获取所有的key，然后通过key获取value
        Set<Integer> it = hashMap.keySet();
        for (Integer integer : it) {
            System.out.println(integer + " =" + hashMap.get(integer));
        }
        System.out.println("===============分割线============");
        // 遍历集合 通过 调用 entrySet方法 得到一个 Set
        Set<Map.Entry<Integer, String>> entries = hashMap.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            System.out.println(entry.getKey() + " =" + entry.getValue());
        }
    }
}

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

3、Properties集合

1.1、每个集合对象的创建（new）
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合

import java.util.Properties;

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
 */
public class PropertiesTest {
    public static void main(String[] args) {
        // 创建 Properties 集合，只支持 String 类型
        Properties properties = new Properties();
        // 向集合中添加元素 基本数据类型自动装箱
        properties.put("你","zhangsan");
        properties.put("好","lisi");
        properties.put("世","wangwu");
        properties.put("界","zhaoliu");
        // 从集合中取出某个元素
        String property = properties.getProperty("你");
        // 遍历 Properties 集合 通过stringPropertyNames()方法获取所有的key
        System.out.println(property);
        for (String key : properties.stringPropertyNames()) {
            System.out.println(key + " ="+ properties.getProperty(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

4、TreeSet集合

1.1、每个集合对象的创建（new）
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合
1.5、测试TreeSet集合中的元素是可排序的。
1.6、测试TreeSet集合中存储的类型是自定义的。
1.7、测试实现Comparable接口的方式
1.8、测试实现Comparator接口的方式（最好测试以下匿名内部类的方式）

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
	1.5、测试TreeSet集合中的元素是可排序的。
	1.6、测试TreeSet集合中存储的类型是自定义的。
	1.7、测试实现Comparable接口的方式
	1.8、测试实现Comparator接口的方式（最好测试以下匿名内部类的方式）
 */
public class TreeSetTest {
    public static void main(String[] args) {
        // 创建 TreeSet 集合
        TreeSet<String> treeSet = new TreeSet<>();
        // 向集合中添加元素
        treeSet.add("zhangsan");
        treeSet.add("lisi");
        treeSet.add("wangwu");
        treeSet.add("zhaoliu");
        // 从集合中取出元素 转为 ArrayList 集合通过下标取出
        ArrayList arr = new ArrayList(treeSet);
        System.out.println(arr.get(0));
        System.out.println("===============分割线============");
        // 集合遍历 获取迭代器遍历
        Iterator<String> it = treeSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("===============分割线============");
        // 遍历集合 通过增强for
        for (String s : treeSet) {
            System.out.println(s);
        }
        System.out.println("===============分割线============");
        // 测试TreeSet集合中的元素是可排序的
        TreeSet<Integer> treeSet1 = new TreeSet<>();    // 结果 1 2 3 4
        treeSet1.add(2);
        treeSet1.add(4);
        treeSet1.add(1);
        treeSet1.add(3);
        for (Integer integer : treeSet1) {
            System.out.println(integer);
        }
        System.out.println("===============分割线============");
        //测试TreeSet集合中存储的类型是自定义的
       /* TreeSet<A> treeSet2 = new TreeSet<>();
        treeSet2.add(new A(1));
        treeSet2.add(new A(3));
        treeSet2.add(new A(2));
        treeSet2.add(new A(4));
        //遍历集合
        for (A a : treeSet2) {
            System.out.println(a);
        }*/
        /* 会报
         Exception in thread "main"
         java.lang.ClassCastException: Gather.GatherZoJie.A cannot be cast to java.lang.Comparable
         这个异常，原因是类未实现Comparable接口
        */
        System.out.println("===============分割线============");
        // 测试实现Comparable接口的方式
        TreeSet<B> treeSet3 = new TreeSet<>();
        treeSet3.add(new B(1));
        treeSet3.add(new B(3));
        treeSet3.add(new B(2));
        treeSet3.add(new B(4));
        // B 类以实现 Comparable 接口,同时重写了 toString 方法
        // 遍历
        for (B b : treeSet3) {
            System.out.println(b);
        }
        // 遍历结果是按 重写的compareTo方法的排序方式进行排序
        System.out.println("===============分割线============");
        //测试实现Comparator接口的方式（最好测试以下匿名内部类的方式）
        // 比较器方法
        TreeSet<C> treeSet4 = new TreeSet<>(new Comparator<C>() {
            @Override
            public int compare(C o1, C o2) {
                return o1.age - o2.age;
            }
        });
        treeSet4.add(new C(1));
        treeSet4.add(new C(3));
        treeSet4.add(new C(2));
        treeSet4.add(new C(4));
        // 遍历
        for (C c : treeSet4) {
            System.out.println(c);
        }
        // 输出结果 1 2 3 4 以排序
    }
}
// 自定义类型A
class A{
    int age;
    public A(int age){
        this.age = age;
    }
}
// 自定义类型B,实现 Comparable 接口，重写 compareTo 排序方法
class B implements Comparable<B>{
    int age;
    public B(int age){
        this.age = age;
    }

    @Override
    public int compareTo(B o) {
        return this.age - o.age;
    }

    @Override
    public String toString() {
        return "B{" +
                "age=" + age +
                '}';
    }
}
// 自定义类型A
class C{
    int age;
    public C(int age){
        this.age = age;
    }
    @Override
    public String toString() {
        return "B{" +
                "age=" + 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
135
136

1、HashSet 底层 HashMap
2、TreeSet 底层 TreeMap