黑马教程强化day2-2

一、Map

1.定义

map集合也被叫做“键值对集合”，格式：{key1=va;ue1，key2=value2}
Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值。

2. Map集合的体系

• 接口：Map
• 实现类：HashMap,TreeMap
• HashMap:LinkedHashMap

3.Map集合体系的特点

注意Mao集合体系的特点是由键决定的，值只是一个附属品，值是不做要求的。

• hashMap（由键决定特点）：无序，不重复，无索引；（用的最多）
• LinkedHashMap(由键决定特点）；有序、不重复、无索引
• TreeMao(有键决定特点）：按照大小默认升序排序、不重复、无索引。

代码演示

package com.item.demo2map;
import java.util.*;
public class Mapdemo1 {
    public static void main(String[] args) {
        //1.创建一个Map集合
        Map<String,Integer> map=new HashMap<>();//一行经典结构
        map.put("张三", 18);
        map.put("李斯", 19);
        map.put("叠山", 20);
        map.put("叠山", 20);
        map.put("王五", 20);
        map.put(null,null);
        System.out.println(map);//{null=null, 张三=18, 王五=20, 叠山=20, 李斯=19}
        System.out.println("=========");
        Map<String,Integer> map1=new LinkedHashMap<>();//一行经典结构
        map1.put("张三", 18);
        map1.put("李斯", 19);
        map1.put("叠山", 20);
        map1.put("叠山", 20);
        map1.put("王五", 17);
        map1.put(null,null);
        System.out.println(map1);//{张三=18, 李斯=19, 叠山=20, 王五=17, null=null}
    }
}

4.Map常用方法

代码演示

package com.item.demo2map;
import java.util.*;
public class Mapdemo2 {
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("张三", 18);
        System.out.println(map.put("张三", 24));//18,返回被重复的。
        map.put("李斯", 19);
        map.put("叠山", 20);
        map.put("叠山", 20);
        map.put("王五", 20);
        map.put(null,null);
        System.out.println(map);//{null=null, 张三=24, 王五=20, 叠山=20, 李斯=19}
        //写代码演示常用方法
        System.out.println("=========");
        System.out.println(map.get("张三"));//24
        System.out.println(map.get("王五"));//20
        System.out.println(map.get("lisi"));//null
        System.out.println(map.get(null));//null
        System.out.println("=======");
        System.out.println(map.containsKey("张三"));//true
        System.out.println(map.containsKey("lisi"));//false
        System.out.println(map.containsValue(20));//true
        System.out.println(map.containsValue(18));//false
        System.out.println("=======");
        System.out.println(map.isEmpty());
        System.out.println(map.size());
        System.out.println("=======");
        map.remove("李斯");
        System.out.println(map);
        System.out.println("=======");
        //获取所有的键放到一个Set集合返回给我们。
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key);
        }
        System.out.println("=======");
        //获取所有的值放到一个Collection集合返回给我们。
        Collection<Integer> values = map.values();
        for (Integer value : values) {
            System.out.println(value);
        }
        map.clear();
        System.out.println(map);
    }
}

5.Map集合的遍历方法

Map集合的遍历方式一：键找值

• 先获取Map集合全部的键，再通过遍历键来找值。
• public Set keySet():获取所有键的集合
• public V get(Object key):根据键获取其对应的值

Map集合的遍历方式二：键值对

• 把"键值对“看成一个整体进行遍历（难度挺大）
• Set entrySet():获取所有键值对的集合。

Map集合的遍历方式三：Lambda遍历

• JDK1.8开始之后的新技术（非常的简单）
• default void forEach(BiConsumeraction):结合lambda遍历Map集合

代码演示：

package com.item.demo2map;

import java.util.HashMap;
import java.util.*;
import java.util.function.BiConsumer;
public class Mapdemo3 {
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("张三", 18);
        map.put("李斯", 19);
        map.put("叠山", 20);
        map.put("叠山", 20);
        map.put("王五", 20);
        System.out.println(map);//{张三=18, 王五=20, 叠山=20, 李斯=19}
        //一、遍历一
        //1.获取所有键的集合
        Set<String> keySet = map.keySet();
        System.out.println(keySet);//[张三, 王五, 叠山, 李斯]
        //2.遍历键，通过键获取值
        for (String key : keySet) {
            //3.获取值
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
        System.out.println("=======");
        //二、遍历二，Map.Entry接口的实现类
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"="+value);
        }
        System.out.println("======");
        //三、遍历三
        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s+"="+integer);
            }
        });
        //简化
        map.forEach((key,value)->{
            System.out.println(key+"="+value);
        });
    }
}

6.小案例

Map集合的案例-统计投票信息
需求：

• 某个班级80名学生，现在需要组织秋游活动，班长提供了四个景点，每个学生只能选择一个景点，请统计出最终那个景点想去的人数最多。

代码演示

package com.item.demo2map;
import java.util.*;
public class Mapdemo4 {
    public static void main(String[] args) {
         show();
    }
    public static void show()
    {
        //1.把80个学生的投票信息保存到一个Map集合中
        List<String> location = new ArrayList<>();
        String[] names={"玉龙雪山","长城","少林寺","丽江"};
        Random r=new Random();
        for (int i = 0; i < 80; i++) {
            int index=r.nextInt(names.length);
            location.add(names[index]);
        }
        System.out.println(location);
        //2.创建Map集合
        Map<String,Integer> map=new HashMap<>();
        for (String s : location) {
            Integer count=map.get(s);
            if(count==null)
            {
                map.put(s,1);
            }
            else
            {
                map.put(s,count+1);
            }
        }
        //3.遍历Map集合
        map.forEach((key,value)->{
            System.out.println(key+"被选择"+value+"次");
        });
    }
}

7.HashMap集合的底层原理

实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。
HashMap跟HashSet的底层原理是一摸一样的，都是基于哈希表实现的
原因：

 public HashSet(){
     map=new HashMap();
}

8. LinkedHashMap的底层原理

实际上：原来学的LinkedHashSet集合的底层就是基于LinkedHeadMap实现的。
底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序（保证有序）

9.TreeMap的底层原理

实际上：原来学的TreeSet集合的底层就是基于TreeMap实现的，
TreeMap集合同样也支持两种方式来指定排序规则：

• 1.让类实现Comparable接口，重写比较规则。
• 2.TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，以便用来指定比较规则。

代码演示

主类代码;

package com.item.demo2map;
import com.item.demo1hashset.Teacher;
import java.util.*;
public class Mapdemo5 {
    public static void main(String[] args) {
        Map<Teacher,String> map=new TreeMap<>();
        map.put(new Teacher("小王", 18,3245.2),"424期");
        map.put(new Teacher("小李", 19,3345.3),"423");
        map.put(new Teacher("小孙", 20,3609.4),"421");
        map.put(new Teacher("小张", 18,2780.3),"234");
        System.out.println(map);//方法1
        System.out.println("======");
        //2.方法二
        Map<Teacher,String> map1=new TreeMap<>((o1,o2)->Double.compare(o1.getSalary(),o2.getSalary()));
        map1.put(new Teacher("小王", 18,3245.2),"424期");
        map1.put(new Teacher("小李", 19,3345.3),"423");
        map1.put(new Teacher("小孙", 20,3609.4),"421");
        map1.put(new Teacher("小张", 18,2780.3),"234");
        System.out.println(map1);//方法1
    }
}

Teacher类代码：

package com.item.demo1hashset;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Teacher implements Comparable<Teacher>{
    private String name;
    private int age;
    private double salary;
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}'+"\n";
    }
    //解决方法1：重写方法，比较两个对象的大小
    @Override
    public int compareTo(Teacher o) {
        //按照年龄升序
        return this.getAge()-o.getAge();
    }
}