集合的使用

List集合的使用

/*
* List: 是Collection的子接口，列表的意思，可以认为有序列表
* 特性:1、放入的元素是有序的，2、元素可以重复
* List是接口不能实例化，如果想使用列表集合，必须要通过它的实现类实例化对象来使用
*           List 下两个常见的实现类
*               ArrayList数组列表
*               LinkedList双向链表
* 最常用的列表的创建方式：
*           (文类引用指向子类实例对象的方式)
*           List<类型> list = new ArrayList<类型>();
* 需要掌握的是List常用的方法及遍历操作
* List 下常用的方法
*           add(元素)往列表中添加数据
*           get(index)获取列表中指定位置的元素
*           set(index，元素)给列表中指定位置设置元素
*           size()获取元素的大小(元素的个数)
*           contains(元素)判断列表当中是否包含某个元素
*           remove(index)删除元素
*           clear()：从List集合中移除所有元素。该方法是从Collection集合继承过来的。
* 判断元素
*       isEmpty()：判断List集合中是否有元素，没有返回true，有返回false。该方法是从Collection集合继承过来的。
*       contains(Object element)：判断List集合中是否包含指定元素，包含返回true，不包含返回false。该方法是从Collection集合继承过来的。
* 查询元素
*       indexOf(Object o)：从前往后查找List集合元素，返回第一次出现指定元素的索引，如果此列表不包含该元素，则返回-1。
*       lastIndexOf(Object o)：从后往前查找List集合元素，返回第一次出现指定元素的索引，如果此列表不包含该元素，则返回-1。
*
* List的遍历:
*       (1)使用索引进行遍历，普通for 循环
*           for (int i = 0; i it = list.iterator();
*           while (it.hasNext()) {
*               //Object item = it.next();
*               String s = it.next();
*               //String s = (String) item;
*               System.out.println("读取集合元素: " + s);
*           }
*
* List下的另一个实现类LinkedList双向链表
*       相比ArrayList进行数据删除修改添加的操作时效率要高
* */
public class Test1 {
    public static void main(String[] args) {
        /*
        * 创建一个存放字符串的列表
        * */
        List<String> list = new ArrayList<>();
        /*
        * 1、添加元素
        * */
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");
        /*
        * 2、获取元素
        *       get(index)
        * */
        System.out.println(list.get(0));

        /*
        * 3、设置元素或者修改元素
        * */
        list.set(1,"55");
        /*
        * 报错，List的长度根据放入数据个数来决定
        * */
//        list.set(10,"10");
        /*
        * 4、删除元素
        * */
        list.remove(2);
        /*
        * 是否包含某个元素
        *       contains(元素)
        * */
        System.out.println(list.contains("55"));
        System.out.println("___________普通循环___________");
        for (int i = 0; i<list.size(); i++){
            System.out.println(list.get(i));
        }
        /*
        * 增强for循环
        * for(列表对应数据类型 变量名 : 列表名){
        * }
        * 意为: 将列表当中的每一个元素循环取出来给到对应的变量
        * */
        System.out.println("___________增强for循环________");
        for (String str:list) {
            System.out.println(str);
        }
        System.out.println("___________迭代器_____________");
        /*
        * 通过送代的方式获取List中的每一个元素
        *   hasNext是用来判断下一个位置是否有值
        *   如果有就使用next获取下一个位置的值
        * */
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
//            Object item = it.next();
            String s = it.next();
//            String s = (String) item;
            System.out.println("读取集合元素: " + s);
        }
        LinkedList<String> list1 = new LinkedList<>();
        list1.add("11");
        list1.add("55");
        list1.add("44");
//        往列表中第一个位置添加一个元素
        list1.addFirst("00");
        list1.add(1,"101");
        Iterator<String> it1 = list1.iterator();
        while (it1.hasNext()){
            System.out.println(it1.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
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

CoLLection

/*
* CoLLection的子接口Set，无序列表
*       特性: 放入的元素是没有顺序的
*            元素不能重复
* 创建Set集合的方式，使用set接口下的实现类：
*       最常用的：
*               HashSet
*       Set<类型> set = new HashSet<类型>();
* 掌握set的增删改查及遍历
*   操作元素
*       add(Object element)：在Set集合的尾部添加指定的元素。该方法是从Collection集合继承过来的。
*       remove(Object element)：如果Set集合中存在指定元素，则从Set集合中移除该元素。该方法是从Collection集合继承过来的。
*       clear()：从Set集合中移除所有元素。该方法是从Collection集合继承过来的。
*   判断元素
*       isEmpty()：判断Set集合中是否有元素，没有返回true，有返回false。该方法是从Collection集合继承过来的。
*       contains(Object element)：判断Set集合中是否包含指定元素，包含返回true，不包含返回false。该方法是从Collection集合继承过来的。
*   其他
*       iterator()：返回迭代器（Iterator）对象，迭代器对象用于遍历集合。该方法是从Collection集合继承过来的。
*       size()：返回Set集合中的元素数，返回值是int类型。该方法是从Collection集合继承过来的。
*
* 注意: set相比于List在获取指定位置的元素的时候不太方便，因为没有索引
*       set集合只能用增强for循环和迭代器去便利
*
* 总结: list和set的区别
*       1、List是有序的 (放入元素的顺序) set无序
*       2、List元素可以重复，set不可以
*       3、List有所应，set没有
*了解部分: set其实是基FHashMap 来存放数据的
*       它存放数据的结构链表+数组或者链表+红黑树
* */
public class Test2 {
    public static void main(String[] args) {
        Set<String> set = new HashSet();
        set.add("00");
        set.add("11");
        set.add("22");
        for (String str: set) {
            System.out.println(str);
        }
        set.add("aa");
        set.add("cd");
        set.add("99");
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        List<String> list = new ArrayList();
        list.add("00");
        list.add("22");
        list.add("aa");
        list.add("99");
        for (String li: list) {
            System.out.println(li);
        }
    }
}
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

Map集合的使用

/*
*
* Map特性:
*   key不能重复,value 可以重复
*   由key具体映射到具体的value 值如何使用Map进行数据存储，需要用到Map的实现类HashMap
* 多掌握Map的常用方法和遍历:
* 方法:
*   put(key元素,value元素) 一次放入一对数据
*   get(key元素)根据key值获取value
*   remove(key元素)根据key删除此对数据
*   containskey(key元素)
*   containsvalue(value元素)是否包含value
*   keySet() 获取map当中所有key值放入一个set集合中,也就是这个方法返回的是一个存放map 中key值的set集合
*            Set keys = map.keySet();
*           //实现获取此map中所有的key、value值，以key-value的形式打印出来
*           for (String key:keys){
*               System.out.println("key=="+key);
*               System.out.println("value=="+map.get(key));
*           }
*
*   entrySet 返回的是一个存放Map.Entry
*       set集合，Map.Entry中的一个Entry可以认为是一对数据
*        //entrySet
*        相当于把map当中的每一对数据作为一个Entry对象放入
*          Set集合当中
*          此处Map.Entry认为是一个整体，是一种类型
*          其实和Set一样的
*           Set> entries = map.entrySet();
*           for (Map.Entry entry : entries){
*               System.out.println(entry.getKey());
*               System.out.println(entry.getValue());
*           }
*
* 遍历:
*   (1)使用keySet()获取map当中的所有key值然后通过key值获取每一个value这种方式是最常用而日
*   (2)使用EntrySet
*
*
* 了解HashMap的底层原理(面试高频考点)
*       结构:数组+链表  链表+树结构
*
* Map下其他的实现类：HashTable、TreeMap也可以去了解下
*   HashTable的key值不可为空
*   HashMap可以
*
* */
public class Test3 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("1",1);
        map.put("2",2);
        map.put("3",3);
        /*
        * 根据key获取value 值
        * */
        System.out.println(map.get("1"));
        /*
        * 删除数据remove(key)
        * */
        map.remove("1");
        System.out.println(map.get("1"));
        /*
        * key值重复，会将原来的value 值覆盖
        * */
        map.put("3",3);
        /*
        * 是否包含某个key值
        * */
        System.out.println(map.containsKey("2"));
        /*
        * 第一种遍历方式
        * */
        map.keySet();
        Set<String> keys = map.keySet();
        //实现获取此map中所有的key、value值，以key-value的形式打印出来
        for (String key:keys){
            System.out.println("key=="+key);
            System.out.println("value=="+map.get(key));
        }
        //entrySet
        /*
        * 相当于把map当中的每一对数据作为一个Entry对象放入
        *   Set集合当中
        *   此处Map.Entry认为是一个整体，是一种类型
        *   其实和Set一样的
        * */
        Set<Map.Entry<String,Integer>> entries = map.entrySet();
        for (Map.Entry<String,Integer> entry : entries){
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
        Set<User> userSet = new HashSet<>();
        User zhangsan = new User();
        userSet.add(zhangsan);
        for (User u : userSet){
            System.out.println(u.getAge());
            System.out.println(u.getName());
        }
    }
}

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