集合【Map集合】

Map【Map集合】

Map集合部分思维导图

1、Map集合概述

java.util.Map<k,v>集合

1.1、Map集合的概述及引入

在学习了数组和Collection集合后，我们说当数据多了使用数组来存放，对象多了使用Collection集合来存放。

当对象与对象之间有了对应的关系：

• 若采用数组只能存放具有简单对应关系的数据，显然不合适；
• 若采用Collection集合，但也只能存放一个对象，无法维护这种关系。

所以就引出了Map集合。将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

通俗点说，Map集合就是用来存放具有对应关系的数据的。即一个key对应一个value，并且要求key不能重复。

1.2、Map集合的特点

• Map集合是一个双列集合，一个元素包含两个值（一个key,一个value)
• Map集合中的元素，key和value数据类型可以相同，也可以不同
• Map集合中的元素，key是不允许重复的，value是可以重复的
• Map集合中的元素，key和value是一一对应

1.3、代码示例

代码：

public class MapDemo {
    public static void main(String[] args) {
        // 创建map集合
        Map<Integer, String> map = new HashMap<>();
        // map集合添加元素
        map.put(34, "abc1");
        map.put(14, "abc2");
        map.put(29, "abc3");
        // 存放时原来的key有值，就会返回原来的value值。
        System.out.println(map.put(34, "abc4"));
        String s = map.get(29);
        System.out.println(s);

        // 根据key删除元素,会返回key对应的value值
        String remove = map.remove(14);
        System.out.println(remove);
        System.out.println("map:" + map);
    }
}

运行结果：

abc1
abc3
abc2

map:{34=abc4, 29=abc3}

2、Map集合常用的两种遍历方式

2.1、keySet 方法

如何获取Map中的所有key呢？

由于Map中的所有key都是不重复的，所以获取到Map中的所有key应该会存放在Set集合中。查询Map的API发现，有个方法keySet。

说简单点就是keySet方法就是通过键–>来找值

keySet（键找值）遍历思路：

• 通过map.keySet()方法，获取所有键(key)的集合
• 遍历键的集合，获取到每一个键(key)
• 根据键找值map.get(key)

public class keySetDemo {
    public static void main(String[] args) {
        //创建Map对象
        Map<String, String> map = new HashMap<String,String>();
        //给map中添加元素
        map.put("星期一", "Monday");
        map.put("星期二", "Tuesday");
        map.put("星期三", "Wednesday");
        map.put("星期四", "Thursday");
        //获取Map中的所有key
        Set<String> keySet = map.keySet();
        //遍历存放所有key的Set集合
        Iterator<String> it =keySet.iterator();
        while(it.hasNext()){
            //得到每一个key
            String key = it.next();
            //通过key获取对应的value
            String value = map.get(key);
            System.out.println(key+"="+value);
        }
    }
}

运行结果：

星期二=Tuesday
星期三=Wednesday
星期四=Thursday
星期一=Monday

2.2、entrySet 方法

这个方法的描述是得到所有key和value的映射关系。

可能这块有些难以理解。

• 就比如Map中存放一对一对的夫妻，那么entrySet获取到是每一对夫妻这种夫妻关系。
• 再或者说Map中存放每个人的姓名和电话，那么entrySet获取到的是每一个人的姓名和电话的对应关系。而keySet获取的仅仅是每个人的姓名，之后再通过姓名去获取对应的电话。

entrySet（键值对对象找值）思路：

• 通过map.entrySet()方法获取键值对对象集合Set<Entry<K,V>>
• 遍历键值对对象获取键(key)和值(value)

public class entrySet {
    public static void main(String[] args) {
        //创建Map对象
        Map<String, String> map = new HashMap<String,String>();
        //给map中添加元素
        map.put("星期一", "Monday");
        map.put("星期二", "Tuesday");
        map.put("星期三", "Wednesday");
        map.put("星期四", "Thursday");
        //获取Map中的所有key与value的对应关系
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        //遍历Set集合
        Iterator<Map.Entry<String,String>> it =entrySet.iterator();
        while(it.hasNext()){
            //得到每一对对应关系
            Map.Entry<String,String> entry = it.next();
            //通过每一对对应关系获取对应的key
            String key = entry.getKey();
            //通过每一对对应关系获取对应的value
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
        // 简化如下:
		/*for (Entry<String, String> en : map.entrySet()) {
			System.out.println(en.getKey() + "的值为：" + en.getValue());
		}*/
    }
}

运行结果：

星期二=Tuesday
星期三=Wednesday
星期四=Thursday
星期一=Monday

3、Map集合常用子类介绍

3.1、Map常见子类的特点

Map有多个子类，这里我们主要讲解常用的HashMap和TreeMap集合。

HashTable：数据结构-哈希表。是同步的，不允许null作为键和值。被hashMap替代。

Properties：属性集，键和值都是字符串，而且可以结合流进行键值的操作。等到了IO流，你会更清楚。

HashMap：数据结构-哈希表。不是同步的，允许null作为键和值。

• HashMap下有个子类LinkedHashMap基于链表+哈希表。可以保证map集合有序（存入和取出的顺序一致）。

TreeMap：数据结构-二叉树。不是同步的。可以对map集合中的键进行排序。

3.2、HashMap存储自定义键值

// 在这里先把Student类单独写出来，HashMap和TreeMap练习中都会用到
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = result * prime + age;
        result = result * prime +((name == null) ? 0 : name.hashCode());
        System.out.println(name+ " :" + result);
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }
        if(!(obj instanceof Student)){
            throw new ClassCastException("死鬼,类型错了");
        }
        Student s = (Student)obj;
        return this.age == s.age && this.name.equals(s.name);
    }
}

练习一：

学生对象(姓名，年龄)都有自己的归属地，既然有对应关系。将学生对象和归属地存储到map集合中。注意：同姓名同年龄视为重复的键。

代码演示：

public class HashMapTest {
    public static void main(String[] args) {

        //1,创建hashmap集合对象。
        Map<Student,String> map = new HashMap<Student,String>();

        //2,添加元素。
        map.put(new Student("张三",28), "上海");
        map.put(new Student("李四",22), "北京");
        map.put(new Student("王五",24), "成都");
        map.put(new Student("赵六",25), "广州");
        map.put(new Student("张三",39), "上海");
        map.put(new Student("张三",28), "上海");

        //3,取出元素。keySet  entrySet
//		Set<Student> keySet = map.keySet();
//		for(Student key : keySet){}
        for(Student key : map.keySet()){
            String value = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }
    }
}

运行结果：

张三 :776718
李四 :843704
王五 :938770
赵六 :1145184
张三 :777059
张三 :776718
赵六 :1145184
Student{name=‘赵六’, age=25}…广州
李四 :843704
Student{name=‘李四’, age=22}…北京
张三 :776718
Student{name=‘张三’, age=28}…上海
张三 :777059
Student{name=‘张三’, age=39}…上海
王五 :938770
Student{name=‘王五’, age=24}…成都

注意：

当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
Set接口及其抽象类

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

HashMap如何保证去重？

HashMap当键(key)是对象(Student)时，如果对象(Student)没有重写hashCode()和equals()方法，则不会去重，即键值可能会有重复。如果需要去重，则需要重写对象的hashCode()和equals()方法。

3.3、TreeMap存储自定义键值

练习二：

学生对象(姓名，年龄)都有自己的归属地，既然有对应关系。 将学生对象和归属地存储到map集合中。

注意：同姓名同年龄视为重复的键。

新增功能： 按照学生的年龄进行从小到大的排序。

// 所以就需要在原来的Student类中实现Comparable接口，重写其compareTo方法；
// 或者实现Comparator接口，重写其compare方法。
public class Student implements Comparable, Comparator{
   @Override
    public int compareTo(Object o) {
        if(!(o instanceof Student)){
            throw new ClassCastException("死鬼，类型错了");
        }
        Student s = (Student)o;
        int temp = this.age - s.age;
        //以年龄为主
        return temp == 0 ? this.name.compareTo(s.name) : temp;
        //以名字为主
        //return this.name.compareTo(s.name) == 0 ? temp : this.name.compareTo(s.name);
    }

    @Override
    public int compare(Object o1, Object o2) {
        Student s1 = (Student)o1;
        Student s2 = (Student)o2;
        int temp = s1.getName().compareTo(s2.getName());
        return temp==0? s1.getAge()-s2.getAge():temp;
    }
}

代码演示：

public class TreeMapTest {
    public static void main(String[] args) {
        // 1,创建TreeMap集合对象。
        Map<Student, String> map = new TreeMap<Student, String>();
        // 2,添加元素。
        map.put(new Student("张三",28), "上海");
        map.put(new Student("李四",22), "北京");
        map.put(new Student("王五",24), "成都");
        map.put(new Student("赵六",25), "广州");
        map.put(new Student("张三",39), "上海");
        map.put(new Student("张三",28), "上海");
        //3,取出所有元素，entrySet()
        for(Map.Entry<Student, String> me : map.entrySet()){

            Student key = me.getKey();
            String value = me.getValue();
            System.out.println(key+"::"+value);
        }
    }
}

运行结果：

Student{name=‘李四’, age=22}::北京
Student{name=‘王五’, age=24}::成都
Student{name=‘赵六’, age=25}::广州
Student{name=‘张三’, age=28}::上海
Student{name=‘张三’, age=39}::上海

注意：

给TreeMap存放自定义对象，自定义对象作为key进行排序时，自定义对象必须具备比较功能，即实现Comparable接口。

如果需要特定方式进行比较，我们也可以给TreeMap集合传递自定义的比较器进行比较。

TreeMap如何保证去重？

• 实现Comparable接口，重写其compareTo方法；
• 实现Comparator接口，重写其compare方法。

4、Map练习–字母出现次数

练习：

“dfjskgks=!#$%^%&gdsfkgfgdsgfdhj”,获取字符串中每一个字母出现的次数。要求返回结果个格式是 a(1)b(2)d(4)…;

思路：

1，获取到字符串中的每一个字母。

2，用字母取查表，如果查到了该字母对应的次数，就将这个次数+1后重新存回表中。

​ 如果没有查到呢？将该字母和1存到表中(除字母外其他字符跳过)。

3，每一字母都查完表后，表中记录的就是所有字母出现的次数。

字母和次数之间存在对应关系，而且字母是唯一性的，所以可以使用map集合做表进行查询。通过结果发现 字母有顺序的，所以可以通过Map集合中的Treemap作为表。

代码：

public class LetterCount {
    public static void main(String[] args) {

        String str = "dfjskgks=!#$%^%&gdsfkgfgdsgfdhj";
        str = getCharCount(str);
        System.out.println(str);
    }
    /*
     * 获取字符串中的字母出现次数。
     */
    public static String getCharCount(String str) {

        //1，将字符串转成字符数组。
        char[] chs = str.toCharArray();

        //2，定义表。treemap.
        TreeMap<Character, Integer> map = new TreeMap<Character, Integer>();

        //3，遍历字符数组。
        for (int i = 0; i < chs.length; i++) {

            //判断必须是字母。
            if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z')){
                continue;
            }

            //4，将遍历到的字母作为键去查map这个表。获取对应的次数。
            Integer value = map.get(chs[i]);

            //5，有可能要查询的字母在表中不存在对应的次数，需要判断。
            //如果返回是null，说明字母没有对应的次数。就将这个字母和1存储到表中。
            if(value == null){
                //将字母和1存储。
                map.put(chs[i],1);
            }else{
                //否则，说明有对应的次数对次数自增。将字母和新的次数存储到表中。
                value++;
                map.put(chs[i],value);
            }
        }
        return mapToString(map);
    }

    /*
     * 将map集合中的键值转成   格式是  a(1)b(2)d(4)......
     * map中有很多数据，无论是多少个，什么类型，最终都变成字符串。
     * StringBuffer 这个容器就符合这个需求。如果是单线程，建议使用StringBuilder。
     *
     */
    private static String mapToString(Map<Character, Integer> map) {
        //1，明确容器。
        StringBuilder sb = new StringBuilder();

        //2,遍历map集合。
        for(Character key  : map.keySet()){
            Integer value = map.get(key);

            sb.append(key+"("+value+")");
        }
        return sb.toString();
    }
}

运行结果：

d(4)f(4)g(5)h(1)j(2)k(3)s(4)