黑马程序员技术交流社区

标题: 【上海校区】java入门篇 Map集合 [打印本页]

---

作者: 不二晨    时间: 2019-1-26 09:51
标题: 【上海校区】java入门篇 Map集合
1.Map集合

1.1Map集合的特点

a.Map是一个接口 Map<K,V>
b.Map中的每一个元素是一个键，值对,，即每一个元素由<Key, Value>组成。
c.每个键最多只能映射到一个值。
d.不能有重复的键
e.键可以映射到值

1.2Map集合中常用的功能

a.添加元素功能
v put(k key, v value)
如果元素的键存在，则将原来的键值对替换
b.删除功能
void clear()
移除所有的键值对
v remove(Object key)
根据键删除元素，并返回相应的值
c.判断功能
boolean contaubKey(object key)
判断集合是否包含指定键
boolean containValue(Object key)
判断集合是否包含指定的值
boolean isEmpty()
判断集合是否为空
d.获取功能

Set<Map.Entry<K,V>> entrySet()
返回一个键值对的set集合

package day_16;

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

public class Map_class {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("张菜菜", "18");
        map.put("财多多", "19");
        map.put("小卡", "10");
        Set<Map.Entry<String, String>> set = map.entrySet();
        for (Map.Entry<String, String> entry : set) {
            String name = entry.getKey();
            String age = entry.getValue();
            System.out.println(name + " " +age);
        }
    }
}

结果:
张菜菜 18
小卡 10
财多多 19
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
V get(Object key)
根据键获取值
SetkeySet()
获取集合中所所有键集合

Collection values()
获取集合中所有值集合

package day_16;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class Map_class {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("张菜菜", "18");
        map.put("财多多", "19");
        map.put("小卡", "10");
        Collection<String> values = map.values();
        for (String age : values) {
            System.out.println(age);
        }
    }
}

结果:
18
10
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
e.长度功能
int size()
返回集合中键值对的对数

1.3Map集合的遍历

a.通过键找值
思路：
1.通过keySet()方法得到键值的set集合
2.通过get(key）方法得到对应键的值

package day_16;

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

public class Map_class {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("张菜菜", "18");
        map.put("财多多", "19");
        map.put("小卡", "10");
        Set<String> set = map.keySet();
        for (String key : set) {
            String value = map.get(key);
            System.out.println(key + " " + value);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
b.键值对对象找值
思路:
1.通过entrySet（）方法得到键值对集合
2.遍历改键值对集合得到键和值
（上面蓝色标记方法有展示)

1.4HashMap特点

a.HashMap允许键为null，值也为null；
b.如果键是其他类类型，必须重写hashcode（）与equals（)方法来保证键的唯一性。如果不重写，就会吹西安键相同的情况。

package day_16;

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

public class Map_class {
    public static void main(String[] args) {
        Map<student, String> map = new HashMap<student, String>();
        map.put(new student("张菜菜", "18"),"老大");
        map.put(new student("财多多", "19"),"老二");
        map.put(new student("小卡", "10"),"老三");
        map.put(new student("小卡", "10"),"老四");
        map.put(new student(null, null), null);
        Set<student> set = map.keySet();
        for (student stu : set) {
            String value = map.get(stu);
            System.out.println(stu.age + " " + stu.name + " " + value);
        }
    }
}

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

package day_16;

import java.util.Objects;

public class student {
    String name;
    String age;
    public student() {
    }
    public student(String name, String age){
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        //比较两个是不是同一个对象
        if (this == o) return true;
        //比较另一个对象是不是student类型
        if (!(o instanceof student)) return false;
        //向下转型为student类型,比较两个队象的内容
        student student = (student) o;
        return name.equals(student.name) &&
                age.equals(student.age);
    }

    @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
重写equals（）方法过程:
1.比较对象参数与使用类实例是不是同一对象
2.比较参数对象类型是不是实用类类型
3.向下转型，比较两个对象具体内容

1.5LinkedHashMap集合特点

a.底层由哈希表和链接列表实现，具有可预知的迭代顺序。
b.元素的有序性由链表数据结构保证，元素的唯一性由哈希表数据结构保证。
c.元素有序且唯一
d.Map集合的数据结构只与键有关

1.6TreeMap集合特点

a.键的数据结构是红黑树，可保证键的排序和唯一性。
b.线程不安全，效率高。
c.键不允许为null。
如果键为null，就会抛出NullPiointerException异常。
d.排序分为自然排序和比较器排序

自然排序

package day_16;

import java.util.Set;
import java.util.TreeMap;

public class Treemap_class {
    public static void main(String[] args) {
        TreeMap<student, String> map = new TreeMap<>();
        map.put(new student("张晓霞", "23"), "18");
        map.put(new student("接口", "34"), "18");
        map.put(new student("第三方", "34"), "18");
        map.put(new student("第三方", "34"), "19");
        map.put(new student(null, null), "18");
        Set<student> set = map.keySet();
        for(student a2:set){
            System.out.println(a2.name + " " + a2.age + " " + map.get(a2));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
自然排序要求键或者值所在的类必须集成Comparable接口，并实现CompareTo()方法。

package day_16;

import java.util.Objects;

public class student implements Comparable{
    String name;
    String age;
    public student() {
    }

    @Override
    public int compareTo(Object o) {
        student o1 = (student)o;
        int num = this.name.compareTo(o1.name);
        int num1 = num == 0 ? this.age.compareTo(o1.age) : num;
        return num1;
    }

    public student(String name, String age){
        this.name = name;
        this.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
比较器排序

package day_16;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

public class Treemap_class {
    public static void main(String[] args) {
        TreeMap<student, String> map = new TreeMap<>(new Comparator<student>() {
            @Override
            public int compare(student o1, student o2) {
                int num = o1.name.compareTo(o2.name);
                int num1 = num == 0 ? -o1.age.compareTo(o2.age) : num;
                return num1;
            }
        });

        map.put(new student("张晓霞", "23"), "18");
        map.put(new student("张晓霞", "26"), "18");
        map.put(new student("接口", "34"), "18");
        map.put(new student("接口", "39"), "18");
        map.put(new student("第三方", "34"), "18");
        map.put(new student("第三方", "34"), "19");
        Set<student> set = map.keySet();
        for (student a2 : set) {
            System.out.println(a2.name + " " + a2.age + " " + map.get(a2));
        }
    }
}
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
2.案例

1.统计字符串中每个字符出现的次数

package day_16;

import java.io.CharConversionException;
import java.util.*;

public class Treemap_class {
    public static void main(String[] args) {
        Scanner as = new Scanner(System.in);
        String str = as.nextLine();
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < str.length(); i++) {
            Character s = new Character(str.charAt(i));
            if(map.get(s) != null){
                Integer a = map.get(s) + 1;
                map.put(s, a);
            }
            else
                map.put(s, 1);
        }
        for (Character s:map.keySet()){
            System.out.println(s + " " +map.get(s));
        }

    }
}
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
2.集合嵌套使用

2.1HashMap嵌套HashMap

基础班

张三        20
李四        22
就业班

赵六        23
王五        21
package day_16;

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

public class Hashmap_double {
   public static void main(String[] args)  {
        HashMap<String, HashMap<String, String>> map3 = new HashMap<>();
        HashMap<String, String> map1 = new HashMap<>();
        map1.put("张三", "20");
        map1.put("李四", "22");
        HashMap<String, String> map2 = new HashMap<>();
        map2.put("王五", "21");
        map2.put("赵六", "23");
        map3.put("基础班", map1);
        map3.put("就业班", map2);
        for (String class1 : map3.keySet()) {
            System.out.println(class1);
            Map<String, String> map4 = map3.get(class1);
            for (String name : map4.keySet()) {
                System.out.println(name + " " + map4.get(name));
            }
        }
    }
}

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
2.2HashMap嵌套ArrayList
三国演义        吕布，周瑜
笑傲江湖        令狐冲，林平之
神雕侠侣        郭靖，杨过
package day_16;

import java.util.*;

public class HashmAap_linglise {
    public static void main(String[] args) {
        HashMap<String, List> map = new HashMap<>();
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<String> list3 = new ArrayList<>();
        list1.add("吕布");
        list1.add("周瑜");
        list2.add("令狐冲");
        list2.add("林平之");
        list3.add("郭靖");
        list3.add("杨过");
        map.put("三国演义", list1);
        map.put("笑傲江湖", list2);
        map.put("神雕侠侣", list3);
        Set<Map.Entry<String, List>> set = map.entrySet();
        for (Map.Entry<String, List> set1 : set) {
            System.out.println(set1.getKey());
            List<String> list = set1.getValue();
            {
                for (String name : list) {
                    System.out.println(name);
                }
            }
        }
    }
}
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
2.3ArrayList嵌套HashMap
周瑜        小乔
吕布        貂蝉
杨过        小龙女
郭靖        黄蓉
令狐冲        任盈盈
林平之        岳灵珊
package day_16;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Arraylist_hashmap {
    public static void main(String[] args) {
        ArrayList<HashMap<String, String>> list = new ArrayList<>();
        HashMap<String, String> map1 = new HashMap();
        map1.put("周瑜", "小乔");
        map1.put("吕布", "貂蝉");
        HashMap<String, String> map2 = new HashMap();
        map1.put("郭靖", "黄蓉");
        map1.put("杨过", "小龙女");
        HashMap<String, String> map3 = new HashMap();
        map1.put("令狐冲", "任盈盈");
        map1.put("林平之", "岳灵珊");
        list.add(map1);
        list.add(map2);
        list.add(map3);
        for(HashMap<String, String> map4:list){
            for(Map.Entry<String,String> entry:map4.entrySet()){
                String man = entry.getKey();
                String woman = entry.getValue();
                System.out.println(man + " " + woman);
            }
        }
    }
}

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
3.HashMap与HashTable的区别

a.HashMap：线程不安全，效率高，允许null值和null键。
b.Hashtable:线程安全，效率低，不允许null值和null键。

4.总结(个人理解）

4.1.Map集合的两种遍历方法:
a.通过得到key值集合，再得到value与key。
b.得到包括key与value的Map.Entry接口，再通过Map.Entry的方法取出key与value。
4.2. TreeMap的数据结构是基于树的，需要知道元素是放在树的左子树还是右子树，所以需要作为元素的类，如student类，定义存放元素的规则，有两种方法:
a.新建TreeMap的无参构造对象，作为元素的类，//TreeMap<student,String>//如该集合里的student类需要实现Comparable接口，并重写CompareTo（）方法。
b.新建TreeMap的有参构造，参数是Comparator对象并重写Compare()方法。
---------------------
【转载，仅作分享，侵删】
作者：初心魏  
原文：https://blog.csdn.net/qq_42306803/article/details/86441540

---

作者: 不二晨    时间: 2019-2-14 14:49
奈斯

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2