Java学习Map接口

Map集合和Collection集合是完全分开的

Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个一个元素的方式存储   单列集合

Map中的集合，元素是成对存在的，每个元素都是由键与值两部分组成的，通过键找对应的值    双列集合

Map中的集合不能包含重复的键，值可以重复，每个键只能对应一个值

Map中常用的集合为HashMap集合、LinkedHashMap集合

HashMap集合

 HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

LinkedHashMap集合

 LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

Map接口中常用的方法

?
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
package com.oracle.demo1;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
 
public class MapDemo {
    public static void main(String[] args) {
        put();
        System.out.println("======================");
        get();
        System.out.println("======================");
        delete();
        System.out.println("======================");
        bianli();
        System.out.println("======================");
        bianli2();
    }
 
    /*
     * 向集合中添加元素 V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。
     * 如果集合中存储之前没有这个键，那么返回null 如果存储之前集合中存在这个键，那么会替换到这个键所对应的值， 并且返回替换前这个键所对应的值
     */
    public static void put() {
        Map<Integer, String> m = new HashMap<Integer, String>();
        String v1 = m.put(1, "张三");
        String v2 = m.put(2, "李四");
        String v3 = m.put(3, "王五");
        String v4 = m.put(3, "赵六");
        System.out.println(v1 + "---" + v2 + "---" + v4);
        System.out.println(m);
    }
 
    /*
     * 获取Map集合中指定键的值 V get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
     */
    public static void get() {
        Map<Integer, String> m = new HashMap<Integer, String>();
        m.put(1, "张三");
        m.put(2, "李四");
        m.put(3, "王五");
        String v = m.get(1);
        System.out.println(v);
    }
 
    /*
     * 删除元素 V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。<br>         * 1、删除传入的键以及对应的值
     * 2、返回你要删除的键对应的值
     */
    public static void delete() {
        Map<Integer, String> m = new HashMap<Integer, String>();
        m.put(1, "张三");
        m.put(2, "李四");
        m.put(3, "王五");
        System.out.println(m);
        String v = m.remove(3);
        System.out.println(v);
        System.out.println(m);
    }
 
    /*
     * 遍历Map集合 键找值
     * 1、获取你的所有键所对应的set集合
     * 2、遍历你的set集合，然后取对应的values值
     */
    public static void bianli() {
        Map<Integer, String> m = new HashMap<Integer, String>();
        m.put(1, "张三");
        m.put(2, "李四");
        m.put(3, "王五");
        // 1、获取装有键的set集合
        // Set<Integer> s=m.keySet();
        // 2、增强for遍历set集合
        for (Integer i : m.keySet()) {
            // 获取键
            int key = i;
            // 获取值
            String values = m.get(key);
            System.out.println(key + "===" + values);
        }
        System.out.println("================");
        // Iterator遍历
        Set<Integer> set = m.keySet();
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {
            int key = it.next();
            String values = m.get(key);
            System.out.println(key + "===" + values);
        }
    }
 
    /*
     * 通过映射关系遍历Map
     * 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。
     * 通过增强for循环和Iterator遍历set集合获取Map中的数据
     */
    public static void bianli2() {
        Map<Integer, String> m = new HashMap<Integer, String>();
        m.put(1, "张三");
        m.put(2, "李四");
        m.put(3, "王五");
        // 1、先得到set集合
        // Set<Map.Entry<Integer, String>> set = m.entrySet();
        // Iterator<Map.Entry<Integer, String>> it = set.iterator();
        // while (it.hasNext()) {
        // Map.Entry<Integer, String> map = it.next();
        // int k = map.getKey();
        // String v = map.getValue();
        // System.out.println(k + "======" + v);
        // }
        // 增强for遍历集合
        for (Map.Entry<Integer, String> map : m.entrySet()) {
            int k = map.getKey();
            String v = map.getValue();
            System.out.println(k + "======" + v);
        }
    }
}

Map中键找值的方式

键找值方式：即通过元素中的键，获取键所对应的值

操作步骤与图解：

1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键

2.遍历键的Set集合，得到每一个键

3.根据键，获取键所对应的值

Entry键值对

Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

Entry是Map接口中提供的一个静态内部嵌套接口，可以直接用类名调用

 getKey()方法：获取Entry对象中的键

 getValue()方法：获取Entry对象中的值

entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回

Map中遍历键值对的方式

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。

 

2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象

3.通过键值对(Entry)对象，获取Entry对象中的键与值。

HashMap存储自定义类型键值

?
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
package com.oracle.demo1;
 
public class Person {
    String name;
    int 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() {
    }
 
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
 
    @Override
    public String toString() {
 
        return name + "----" + age;
    }
 
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return 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
package com.oracle.demo1;
 
import java.util.HashMap;
 
public class HashMapDemo {
    public static void main(String[] args) {
        key();
        System.out.println("=============");
        values();
    }
 
    public static void key() {
        //当自定义类作为键时，由于类中没有重写hashCode和equals方法
        //所以输入的数据中尽管有重复的数据，也会存进去
        //由于Java中对键值对的规范，键不能重复，
        //所以需要在自定义类中重写hashCode和equals方法
        HashMap<Person, String> hs = new HashMap<Person, String>();
        hs.put(new Person("张三", 18), "java");
        hs.put(new Person("李四", 34), "php");
        hs.put(new Person("张三", 18), "python");
        hs.put(new Person("王五", 18), "java");
        System.out.println(hs);
    }
 
    public static void values() {
        //String类作为键，由于String中重写了hashCode和equals方法
        //所以当输入的键有重复数据时，会自动识别，保证键的唯一性
        HashMap<String, Person> hs = new HashMap<String, Person>();
        hs.put("java", new Person("张三", 18));
        hs.put("php", new Person("李四", 34));
        hs.put("python", new Person("张三", 18));
        hs.put("java", new Person("王五", 18));
        System.out.println(hs);
    }
}

　　当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法

       如果要保证map中存放的key和取出的顺序一致，可以使用LinkedHashMap集合来存放。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.oracle.demo1;
 
import java.util.HashMap;
import java.util.LinkedHashMap;
 
public class LinkedHashMapDemo {
     public static void main(String[] args) {
         //LinkedHashMap是有序的，就是怎么存怎么取
         LinkedHashMap<String,String> lhm=new LinkedHashMap<String,String>();
         lhm.put("abc", "张三");
         lhm.put("java", "李四");
         lhm.put("aac", "王五");
         lhm.put("gdr", "张三");
         System.out.println(lhm);
       //HashMap不是有序的，不一定怎么存怎么取
         HashMap<String,String> hm=new HashMap<String,String>();
         hm.put("abc", "张三");
         hm.put("java", "李四");
         hm.put("aac", "王五");
         hm.put("gdr", "张三");
         System.out.println(hm);
    }
}

静态导入

在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。

静态导入格式：

import static XXX.YYY;   导入后YYY可直接使用。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.oracle.demo2;
 
import static java.lang.System.out;
import static java.util.Arrays.sort;
 
public class StsticDemo {
    public static void main(String[] args) {
        out.println("这是静态导入");
        int[] arr = { 2, 4, 6, 3, 6, 1, 8 };
        sort(arr);
        for (int i : arr) {
            out.println(i);
        }
    }
}

可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.oracle.demo2;
 
public class Demo {
    public static void main(String[] args) {
        System.out.println(add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
    }
 
    // 可变参数 参数类型相同，但是参数个数不定
    // int ...a实际上是一个数组
    //注：1、如果在一个参数列表中需要传入多种类型，则可变列表必须放到最后
    //       如：public static void add(String str,int ...a){}        
    //    2、在一个参数列表中只能有一个可变参数
    public static int add(int... a) {
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum = sum + a[i];
        }
        return sum;
    }
    // public static int add(int a, int b) {
    // return a + b;
    // }
}

Collections集合工具类

常用方法

?
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.oracle.demo2;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class CollectionsDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(4);
        list.add(2);
        list.add(3);
        list.add(9);
        list.add(7);
        System.out.println(list);
        System.out.println("=====================");
        // 将集合中元素的顺序打乱
        // 该方法返回值是静态的，所以直接用类名调用方法
        //该方法仅限于list集合
        Collections.shuffle(list);
        System.out.println(list);
        System.out.println("=====================");
        Collections.sort(list);
        System.out.println(list);
    }
}

集合嵌套

所谓的集合嵌套就是集合内容又是集合，如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。

1、 ArrayList嵌套 ArrayList

ArrayList< ArrayList<String> >

Collection< ArrayList<Integer> >

2、 Map嵌套 ArrayList

HashMap<String, ArrayList<Person>>

ArrayList< HashMap<String, String>>

3、 Map集合嵌套

HashMap<String, HashMap<String,String>>

HashMap<String, HashMap<Person,String>>

?
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
package com.oracle.demo2;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//集合中Map嵌套Map 的存和取
public class MapQianTao {
    public static void main(String[] args) {
        // 集合嵌套
        HashMap<String, HashMap<Integer, String>> map = new HashMap<String, HashMap<Integer, String>>();
        HashMap<Integer, String> m1 = new HashMap<Integer, String>();
        m1.put(1, "张三");
        m1.put(2, "李四");
        map.put("Java01", m1);
        HashMap<Integer, String> m2 = new HashMap<Integer, String>();
        m2.put(1, "小红");
        m2.put(2, "小李");
        map.put("Java03", m2);
        System.out.println(map);
        // 获取元素(keySet) 获取set集合
        Set<String> set = map.keySet();
        // 遍历set集合
        for (String str : set) {
            //获取班级名称
            String key = str;
            //获取班级Map
            HashMap<Integer, String> value = map.get(key);
            System.out.println(key+"-------"+value);
            //获取班级Map中的keySet
            Set<Integer> set2=value.keySet();
            //遍历学号
            for(int i:set2){
                //获取学生学号
                int key2=i;
                //获取学生学号所对应的姓名
                String value2=value.get(key2);
                System.out.println(key+"----"+key2+"-----"+value2);
            }
        }
        System.out.println("==========================");
        //用EntrySet获取元素
        //获得映射关系set
        Set<Map.Entry<String, HashMap<Integer, String>>> set2=map.entrySet();
        for(Map.Entry<String, HashMap<Integer, String>> a:set2){
            //获取班级名称
            String k1=a.getKey();
            //获取班级Map
            HashMap<Integer, String> v1=a.getValue();
            //获取班级Map的映射关系
            Set<Map.Entry<Integer, String>> s3=v1.entrySet();
            //遍历
            for(Map.Entry<Integer, String> b:s3){
                //获取学生学号
                int k2=b.getKey();
                //获取学生姓名
                String v2=b.getValue();
                System.out.println(k1+"--"+k2+"-------"+v2);
            }
        }
         
    }
}

　　

posted @   低调的小孩儿  阅读(188)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示