Java Map集合

1Map集合

1.1 Map集合的介绍

• java.util.Map<K,V> 集合，里面保存的数据是成对存在的，称之为双列集合。存储的数据，我们称为键值对。 之前所学的Collection集合中元素单个单个存在的，称为单列集合

1.2 特点

• Map<K,V> K：键的数据类型；V：值的数据类型

• 特点 :

  • 键不能重复，值可以重复
  • 键和值是 一 一 对应的，通过键可以找到对应的值
  • （键 + 值） 一起是一个整体 我们称之为“键值对” 或者 “键值对对象”，在Java中叫做“Entry对象”

• 使用场景

  • 凡是要表示一一对应的数据时就可以Map集合
    • 举例 : 学生的学号和姓名 — (itheima001 小智)
    • 举例 : 夫妻的关系 ---- (王宝强 马蓉 ) (谢霆锋 张柏芝)

1.3 常用实现类

• HashMap：
  • 此前的HashSet底层实现就是HashMap完成的，HashSet保存的元素其实就是HashMap集合中保存的键，底层结构是哈希表结构，具有键唯一，无序，特点。
• LinkedHashMap：
  • 底层结构是有链表和哈希表结构，去重，有序
• TreeMap：
  • 底层是有红黑树，去重，通过键排序

1.4 常用的方法

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
• public Set keySet(): 获取Map集合中所有的键，存储到Set集合中。
• public boolean containKey(Object key):判断该集合中是否有此键。

1.5 Map集合的遍历

public class MapDemo1 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map = new HashMap<>();
        //向map集合中存储元素（key、value)
        map.put("javaee","JavaEE从门到放弃");
        map.put("php","Php从门到放弃");
        map.put("mysql","Mysql从门到放弃");
        map.put("java","Java从门到放弃");
        System.out.println(map);
        //删除map集合中的元素（根据key元素名字删除)
        if (map.containsKey("java")){
            map.remove("java");
        }
        //获取map集合中的value元素
        String mysql=map.get("mysql");
        System.out.println(mysql);
    }
}

遍历map

第一种：
public class MapDemo2 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map = new HashMap<>();
        //添加元素
        map.put("yuwen","语文");
        map.put("math","数学");
        map.put("english","英语");
        map.put("daode","道德");
        //遍历：先获取到所有的key元素， 遍历所有的key元素， 通过key找到value
        //1、先获取到所有的key元素
        Set<String> keys = map.keySet();
        //2、遍历所有的key元素
        for (String key:keys){
            //3、通过key找到value
            String value=map.get(key);
            System.out.println("key="+key +" , value="+value);
        }
    }
}

第二种：
public class MapDemo3 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String, String> map = new HashMap<>();

        //添加元素
        map.put("yuwen","语文");
        map.put("math","数学");
        map.put("english","英语");
        map.put("daode","道德");

        //遍历：先获取到所有的键值对对象(Map.Entry)， 遍历所有的键值对对象， 通过键值对对象(Map.Entry)分别获取 key、value
        //1、先获取到所有的键值对对象(Map.Entry)
        Set<Map.Entry<String,String>> entries=map.entrySet();
        //2、遍历所有的键值对对象
        for (Map.Entry<String,String> entry:entries){
            //3、通过键值对对象(Map.Entry)分别获取 key、value
            String key=entry.getKey();
            String value=entry.getValue();
            System.out.println("key="+key+" , value="+value);
        }

    }
}

1.6 HashMap集合

• 注意 : HashMap集合 , 要想保证键唯一 , 那么键所在的类必须重写hashCode和equals方法

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
/**
 * 注意 : HashMap集合 , 要想保证键唯一 , 那么键所在的类必须重写hashCode和equals方法
 */
public class MapDemo4 {
    public static void main(String[] args) {
        //创建map集合对象
        HashMap<Student, String> studentMap = new HashMap<>();

        //添加元素（ key元素 ： 自定义对象 ）
        studentMap.put(new Student("zs", 23), "北京");
        studentMap.put(new Student("ls", 24), "上海");
        studentMap.put(new Student("zs", 23), "北京"); //学生对象中的内容是重复的

        //遍历集合
        Set<Student> keys = studentMap.keySet();
        for (Student key : keys) {
            System.out.println( key +" --- " + studentMap.get(key));
        }
    }
}

运行的结果：
Student{name='ls', age=24} --- 上海
Student{name='zs', age=23} --- 北京

1.7LinkedHashMap集合

• LinkedHashMap类 , 在最底层采用的数据结构 : 是链表+哈希表。
• 特点 :
  • 元素唯一
  • 元素有序

public class LinkedHashMapDemo1 {
    public static void main(String[] args) {
        LinkedHashMap<String,String> map = new LinkedHashMap<>();
        //添加元素
        map.put("周瑜","小乔");
        map.put("孙策","大乔");
        map.put("刘备","孙尚香");
        map.put("诸葛亮","黄月英");
        map.put("周瑜","小乔2");

        //遍历
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();

            System.out.println( key +" ---- "+ value);
        }
    }
}

1.8TreeMap集合

• TreeMap的底层是红黑树实现的，有排序的能力，键去重。

• 可以自然排序（键所在的类要实现Comparable）

• 若自定义类没有自然排序功能，或自然排序功能不满足要求时。可以自定义比较器排序（Comparator）

public class TreeMapDemo1 {
    public static void main(String[] args) {
        //  定义TreeMap集合存储键值对，键使用Integer，值使用String
        // 创建集合对象
        TreeMap<Integer,String> treeMap = new TreeMap<>();
        treeMap.put(1,"lisus");
        treeMap.put(2,"zhangshan");
        treeMap.put(3,"wangwu");

        System.out.println(treeMap);
    }
}
/*
    需求：创建一个TreeMap集合，键是学生对象(Student)，值是籍贯(String)。
    学生属性姓名和年龄, 要求按照年龄进行升序排序并遍历
 */
public class TreeMapTest2 {
    public static void main(String[] args) {
        // 学生作为键, 家庭住址作为值。
        TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });

        tm.put(new Student("迪丽热巴", 18), "新疆");
        tm.put(new Student("迪丽热巴", 16), "中国");

        System.out.println(tm);
    }
}

2集合嵌套

2.1List嵌套List

public class Test3 {
    public static void main(String[] args) {
        List<String> gradeThreeClassOne = new ArrayList<>();
        gradeThreeClassOne.add("threeClassOne1");
        gradeThreeClassOne.add("threeClassOne2");
        gradeThreeClassOne.add("threeClassOne3");

        List<String> gradeThreeClassTwo = new ArrayList<>();
        gradeThreeClassTwo.add("threeClassTwo1");
        gradeThreeClassTwo.add("threeClassTwo2");
        gradeThreeClassTwo.add("threeClassTwo3");


        List<String> gradeThreeClassThree = new ArrayList<>();
        gradeThreeClassThree.add("threeClassThree1");
        gradeThreeClassThree.add("hreeClassThree2");
        gradeThreeClassThree.add("hreeClassThree3");

        List<List<String>> grades = new ArrayList<>();
        grades.add(gradeThreeClassOne);
        grades.add(gradeThreeClassTwo);
        grades.add(gradeThreeClassThree);

        for (List<String> grade:grades){
            for (String name:grade){
                System.out.println(name);
            }
            System.out.println("-----------------");
        }

    }
}

2.2List嵌套Map

/*
    List嵌套Map :

    使用场景举例：一年级有多个班级，每个班级有多名学生。要求保存每个班级的学生姓名，姓名有与之对应的学号，保存一年级所有的班级信息。

    思路：
        1 可以使用Map集合保存一个班级的学生（键是学号，值是名字）
        2 可以使用List集合保存所有班级

    因此我们可以定义集合如下：

    班级：Map<String,String> 键是学号，值是姓名
        举例 :
            Map<String,String> 一班 = {it001 = 迪丽热巴 , it002 = 古力娜扎 ,it003 = 马尔扎哈 ,it004 = 欧阳娜娜}
            Map<String,String> 二班 = {it001 = 李小璐 , it002 = 白百何 , it003 = 马蓉}
            Map<String,String> 三班 = {it001 = 林丹 ,it002 = 文章, it003 = 陈赫}

    年级：List<Map<String,String>>保存每个班级的信息
        举例 :
              List<Map<String,String>> 年级 = {一班 , 二班 , 三班}
 */
public class ListNestingMapDemo {
    public static void main(String[] args) {
        Map<String, String> clases1 = new HashMap<>();
        clases1.put("it001", "张1");
        clases1.put("it002", "张2");
        clases1.put("it003", "张3");
        clases1.put("it004", "张4");

        Map<String, String> clases2 = new HashMap<>();
        clases2.put("it001", "w1");
        clases2.put("it002", "bbh");
        clases2.put("it003", "mr");

        Map<String, String> clases3 = new HashMap<>();
        clases3.put("it001", "ld");
        clases3.put("it002", "wz");
        clases3.put("it003", "ch");

        //在List集合中存储Map集合
        List<Map<String,String>> grade =new ArrayList<>();
    }
}

2.3Map嵌套Map

public class MapNestingMapDemo {
    public static void main(String[] args) {
        Map<String, String> classes1 = new HashMap<>();
        classes1.put("it001", "dlrb");
        classes1.put("it002", "glnz");
        classes1.put("it003", "mezh");
        classes1.put("it004", "oynn");
        Map<String, String> classes2 = new HashMap<>();
        classes2.put("it001", "lxl");
        classes2.put("it002", "bbh");
        classes2.put("it003", "mr");
        Map<String, String> classes3 = new HashMap<>();
        classes2.put("it001", "ld");
        classes2.put("it002", "wz");
        classes2.put("it003", "ch");

        //Map集合中存储Map集合
        Map<String, Map<String, String>> grade = new HashMap<>();
        grade.put("一班", classes1);
        grade.put("二班", classes2);
        grade.put("三班", classes3);
    }
}