List⤅&Set的操作和遍历

Search…
List⤅&Set的操作和遍历
Java的三大集合即：Set、List、Map。
Set：代表无序、不可重复的集合，常用的有HashSet（哈希表实现）、TreeSet（红黑树实现）；
List：代表有序、可以重复的集合，比较常用的有ArrayList（数组实现）、LinkedList（链表实现）；
Map：代表具有映射关系的集合，常用的有HashMap（哈希表实现）、TreeMap（红黑树实现）；
Java5以后又增加了Queue体系集合，代表一种队列集合实现，这里先不介绍。
List的实现类原理比较简单，Map比较复杂，而Set其实是基于Map的一种实现。
下面从各个集合的基本操作介绍一下，分别选取HashSet、ArrayList、HashMap三个典型的实现类：
1. HashSet
1
/** 
2
 * HashSet的增删遍历
3
 * @author wangjun 
4
 * @email  [email protected]
5
 * @time   2018年4月6日 下午2:40:33 
6
 */
7
public class HashSetOperation {
8
​
9
    public static void main(String[] args) {
10
        //初始化
11
        HashSet<String> set = new HashSet<>();
12
        //增
13
        set.add("key1");
14
        set.add("key2");
15
        set.add("key3");
16
        //删
17
        set.remove("key1");
18
        //遍历1
19
        //使用set.descendingIterator()方法可以反向遍历
20
        System.out.println("HashSet遍历1,使用Iterator:");
21
        Iterator<String> it = set.iterator();
22
        while(it.hasNext()) {
23
            System.out.println(it.next());
24
        }
25
        //遍历2
26
        System.out.println("HashSet遍历2,使用for：");
27
        for(String str: set) {
28
            System.out.println(str);
29
        }
30
    }
Copied!
运行结果：
1
HashSet遍历1,使用Iterator:
2
key2
3
key3
4
HashSet遍历2,使用for：
5
key2
6
key3
Copied!
2.ArrayList
1
/** 
2
 * ArrayList的增删查改，遍历
3
 * @author wangjun 
4
 * @email  [email protected]
5
 * @time   2018年4月6日 下午2:25:43 
6
 */
7
public class ArrayListOperation {
8
​
9
    public static void main(String[] args) {
10
        //初始化
11
        List<String> list = new ArrayList<>();
12
        //增
13
        list.add("str1");
14
        list.add("str2");
15
        list.add("str3");
16
        //删
17
        list.remove(1);
18
        //查
19
        System.out.println("list的第二个元素是：" + list.get(1));
20
        //改
21
        list.set(0, "str11");
22
        System.out.println("最终的list：" + list.toString());
23
        //遍历1,使用for
24
        System.out.println("LinkedList遍历1,使用for:");
25
        for (int i = 0; i < list.size(); i++) {
26
            System.out.println(list.get(i));
27
        }
28
        //遍历2,使用增强for
29
        System.out.println("LinkedList遍历1,使用增强for:");
30
        for(String str: list) {
31
            System.out.println(str);
32
        }
33
        //遍历3，使用Iterator，集合类的通用遍历方式
34
        System.out.println("LinkedList遍历3，使用Iterator:");
35
        Iterator<String> it = list.iterator();
36
        while(it.hasNext()) {
37
            System.out.println(it.next());
38
        }
39
    }
40
​
41
}
Copied!
运行结果：
1
list的第二个元素是：str3
2
最终的list：[str11, str3]
3
LinkedList遍历1,使用for:
4
str11
5
str3
6
LinkedList遍历1,使用增强for:
7
str11
8
str3
9
LinkedList遍历3，使用Iterator:
10
str11
11
str3
Copied!
3.HashMap
1
/** 
2
 * hashMap的增删查改
3
 * 无序
4
 * key相当于set，不可重复
5
 * value相当于list，可重复
6
 * @author wangjun 
7
 * @email  [email protected]
8
 * @time   2018年4月6日 下午2:30:31 
9
 */
10
public class HashMapOperation {
11
​
12
    public static void main(String[] args) {
13
        //初始化
14
        HashMap<String,String> map = new HashMap<>();
15
        //增
16
        map.put("key1", "value1");
17
        map.put("key2", "value2");
18
        map.put("key3", "value3");
19
        //删
20
        map.remove("key2");
21
        //查
22
        System.out.println("key1对应的valve为：" + map.get("key1"));
23
        //改
24
        map.replace("key3", "value33");
25
        System.out.println("最终的map是：" + map.toString());
26
        //遍历1，取出map中所有的key组成一个set
27
        System.out.println("HashMap遍历1，取出map中所有的key组成一个set:");
28
        for(String key: map.keySet()) {
29
            System.out.println("key:" + key + ",value:" + map.get(key));
30
        }
31
        //遍历2,取出key组成set后，通过Iterator遍历key
32
        System.out.println("HashMap遍历2,取出key组成set后，通过Iterator遍历key：");
33
        Iterator<String> it = map.keySet().iterator();
34
        while(it.hasNext()) {
35
            String key = it.next();
36
            String value = map.get(key);
37
            System.out.println("key:" + key + ",value:" + value);
38
        }
39
        //遍历3，取出map中实际存储的数据结构--Map.Entry,在HashMap中使用的是Node静态内部类
40
        //推荐这种，尤其是数据很大时
41
        System.out.println("HashMap遍历3，通过Map.Entry：");
42
        Set<Map.Entry<String, String>> entry = map.entrySet();
43
        for(Map.Entry<String, String> entryItem: entry) {
44
            String key = entryItem.getKey();
45
            String value = entryItem.getValue();
46
            System.out.println("key:" + key + ",value:" + value);
47
        }
48
        //遍历4,只能遍历value，不能遍历key,相当于取出map中左右的value组成一个list
49
        System.out.println("HashMap遍历4，只遍历value：");
50
        for(String value: map.values()) {
51
            System.out.println("value:" + value);
52
        }
53
    }
54
​
55
}
Copied!
运行结果：
1
key1对应的valve为：value1
2
最终的map是：{key1=value1, key3=value33}
3
HashMap遍历1，取出map中所有的key组成一个set:
4
key:key1,value:value1
5
key:key3,value:value33
6
HashMap遍历2,取出key组成set后，通过Iterator遍历key：
7
key:key1,value:value1
8
key:key3,value:value33
9
HashMap遍历3，通过Map.Entry：
10
key:key1,value:value1
11
key:key3,value:value33
12
HashMap遍历4，只遍历value：
13
value:value1
14
value:value33
Copied!
可以看到：
遍历Set一般常用2种方式；
遍历List一般常用3种方式；
遍历Map一般常用4种方式；
根据使用场景，选择合适的遍历方式。
Java集合之LinkedList
JavaP反编译命令
Last modified 1yr ago
Copy link
Contents
1. HashSet
2.ArrayList
3.HashMap