Map系列的遍历方式与Map系列集合及集合的嵌套

一.键找值（先获取Map集合全部的键，再通过遍历键来找值）

需要用到的Map方法如下：

keySet() 获取所有键的集合

get(Object key) 根据键获取其对应的值

二.键值对（把“键值对”看成一个整体进行遍历）

需要用的方法如下：

entrySet() 获取所有“键值对”的集合

getKey() 获取键

getValue() 获取值

三.Lambda（JDK1.8开始之后的新技术）

需要用的方法如下：

forEach(BiConsume<? super K,? super V> action)  结合Lambda遍历Map集合

四.示例：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;

public class MapTest3 {
    public static void main(String[] args) {
        Map<String,Double> Teacher = new HashMap<>();
        Teacher.put("刘林森", 172.5);
        Teacher.put("陆广敏", 159.3);
        Teacher.put("唐清泉", 178.4);
        Teacher.put("王珂", 157.9);
        Teacher.put("戴俊刚", 164.4);

        //1.键找值
        Set<String> keys = Teacher.keySet();
        for (String key : keys) {
            Double height = Teacher.get(key);
            System.out.println(key+"------>"+height);
        }

        //2.键值对
        Set<Map.Entry<String, Double>> entries = Teacher.entrySet();
        for (Map.Entry<String, Double> entry : entries) {
            String k = entry.getKey();
            Double v = entry.getValue();
            System.out.println(k+"------->"+v);
        }

        //3.Lambda
        //        Teacher.forEach(new BiConsumer<String, Double>() {
        //            @Override
        //            public void accept(String k, Double v) {
        //                System.out.println(k+"------->"+v);
        //            }
        //        });
        Teacher.forEach((k,v) ->{
            System.out.println(k+"------->"+v);
        });
    }
}

五.案例：

一个班中的80名学生秋游有四个地点供选择，每人只能选择一次，请统计处每个景点想去的人数。

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

public class MapTest4 {
    public static void main(String[] args) {
        //1.将80个学生选择的数据拿到程序中去
        String[] yield = {"A","B","C","D"};
        Random r = new Random();
        ArrayList<String> Selection = new ArrayList<>();
        for (int i = 1; i <= 80; i++) {
            int index = r.nextInt(4);
            Selection.add(yield[index]);
        }

        //2.准备一个Map集合用于存储统计的结果。
        Map<String,Integer> Count = new HashMap<>();

        //3.遍历80个学生选择的景点，每遍历一个景点，就看Map集合中是否存在该景点，不存在存入”景点=1“，存在则其对应值加1
        for (String s : Selection) {
            if (Count.containsKey(s)){
                Count.put(s, Count.get(s)+1);
            }else {
                Count.put(s, 1);
            }
        }
        System.out.println(Count);
    }
}

---------------------------------------------------------------------------------------------------------------------------------Map系列集合

一:HashMap集合的底层原理

1.HashMap跟HashSet的底层原理是一模一样的，都是基于哈希表实现的。

实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。

2.·HashMap集合是一种增删改查数据，性能都较好的集合

·但是它是无序，不能重复，没有索引支持的（由键决定特点）

·HashMap的键依赖HashCode方法和equals方法保证键的唯一

·如果键存储的是自定义类型的对象，可以通过重写HashCode和equals方法，这样可以保证多个对象内容一样时，HashMa集合就能认为是重复的。

3.示例：

import java.util.Objects;

public class Friend {
    private String name;
    private double height;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Friend friend = (Friend) o;
        return Double.compare(friend.height, height) == 0 && age == friend.age && Objects.equals(name, friend.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, height, age);
    }

    public Friend() {
    }

    public Friend(String name, double height, int age) {
        this.name = name;
        this.height = height;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

import java.util.Map;

public class HashMap {
    public static void main(String[] args) {
        Map<Friend,String> local = new java.util.HashMap<>();
        local.put(new Friend("王凯",168.8,19),"新疆");
        local.put(new Friend("蔡建宇",159.7,18),"湖北");
        local.put(new Friend("蔡建宇",159.7,18),"固始");
        local.put(new Friend("卢硕",178.6,18),"西藏");
        local.put(new Friend("李畅",174.6,19),"郑州");
        System.out.println(local);
    }
}

二:LinkedHashMap的底层原理

1.底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序（保证有序）

实际上：原来学习的LinkedHashSet集合的底层原理就是;LinkedHashMap。

2.同样LinkedHashMap的键也同样依赖HashCode方法和equals方法来保证键的唯一

；如果键存储的是自定义类型的对象，也可以通过重写HashCode和equals方法，也可以保证多个对象内容一样时，LinkedHashMa集合就能认为是重复的。

三:TreeMap集合的底层原理

1.特点：不重复，无索引，可排序（按照键的大小默认升序排序，只能对键排序）

2.原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。

3.TreeMap集合同样也支持两种方式来指定排序规则

①让类实现Comparable接口，重写比较规则。

public class Friend implements Comparable<Friend>{}

@Override
public int compareTo(Friend o) {
return Double.compare(this.height, o.height);
}

②TreeMap集合有一个有参数构造器，支持创建Comparable比较器对象，以便用来指定比较规则。

//        Map<Friend,String> local =new java.util.TreeMap<>(new Comparator<Friend>() {
//            @Override
//            public int compare(Friend o1, Friend o2) {
//                return Double.compare(o1.getHeight(), o2.getHeight());
//            }
//        });
Map<Friend,String> local =new java.util.TreeMap<>(( o1,  o2) -> Double.compare(o1.getHeight(), o2.getHeight()));

---------------------------------------------------------------------------------------------------------------------------------集合的嵌套

意思就是集合中的元素又是一个集合

示例：

import java.util.*;
import java.util.HashMap;

public class AddKnowledge {
    public static void main(String[] args) {
        Map<String, List<String>> local = new HashMap<>();
        List<String> Discipline1 = new ArrayList<>();
        Collections.addAll(Discipline1,"地理","政治","历史");
        List<String> Discipline2 = new ArrayList<>();
        Collections.addAll(Discipline2,"化学","物理","生物");
        local.put("文科", Discipline1);
        local.put("理科", Discipline2);
        System.out.println(local);
        List<String> list1 = local.get("文科");
        for (String s : list1) {
            System.out.println(s);
        }List<String> list2 = local.get("理科");
        for (String s : list2) {
            System.out.println(s);
        }
        local.forEach((l , d) -> System.out.println(l + "------->" + d));
    }
}