Java学习笔记24（Map集合）

Map接口：

　　Map接口与Collection接口无继承关系。

　　　　区别：Collection中的元素是孤立的，一个一个存进去的。

　　　　　　　Map作为一个映射集合，每一个元素包含Key-value对（键-值对）。即，Map元素总是成对出现的。

　　Map中的value对象可以重复，但Key不能重复。

　　Map接口的常用集合：

　　1.HashMap集合，HashMap类与HashSet类基本相同，都是无序的，

　　2.LinkedHashMap集合，存储数据是有序的。

Map接口的常用方法：

package Demo2;

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

public class Demo1 {
    public static void main(String[] args) {
        function();
        function1();
        function2();
    }
    

    private static void function2() {
        //处理映射中的键/值对组的视图操作
        HashMap<Integer,String> h=new HashMap<>();
        h.put(10,"aaa");
        h.put(20,"bbb");
        h.put(30,"ccc");
        h.put(40,"ddd");
        System.out.println(h);//{20=bbb, 40=ddd, 10=aaa, 30=ccc}
        Set<Integer> set = h.keySet();//keySet()方法 返回此映射中包含的键的Set视图（即：将该映射中的键都放入 一个Set集合）
        System.out.println(set);//[20, 40, 10, 30]
        //values()方法，返回此映射中包含的值的Collection视图。（将该映射中的值都放入一个Collection集合）
        Collection<String> val = h.values();
        System.out.println(val);//[bbb, ddd, aaa, ccc]
    }

    private static void function1() {
        //查询操作
        HashMap<String,Integer> h=new HashMap<>();
        h.put("张三",18);//put(key,value)方法，将指定的value值与此映射中的指定键key关联
        h.put("李四",20);
        h.put("小明",22);
        h.put("小红",26);
        System.out.println(h);//{李四=20, 张三=18, 小明=22, 小红=26}
        Integer s = h.get("张三");//get(key)返回指定键key的值，如果此映射不包含该键的映射关系，则返回null。
        System.out.println(s);//18
        int size = h.size();//size()返回映射中的键-值关键字（即集合中的元素个数，每一个 键-值 为一个元素）
        System.out.println(size);//4
        boolean b = h.containsKey("张三");//containsKey(key)判断映射中是否存在关键字key
        System.out.println(b);//true    containsValue(value) 判断映射中是否存在值value
        h.clear();
        boolean b1 = h.isEmpty();// 如果此映射不包含键-值映射关系，则返回 true。
        System.out.println(b1);//true
    }

    private static void function() {
        //添加删除操作
        Map<String,Integer> m=new  HashMap<>();
        m.put("张三",18);//put(key,value)方法，将指定的value值与此映射中的指定键key关联
        m.put("李四",20);
        m.put("小明",22);
        m.put("小红",24);
        System.out.println(m);//{李四=20, 张三=18, 小明=22, 小红=24}//输出是无序的
        m.remove("小明");//remove(key) :如果存在一个映射关系，则将其从此映射中 移除。
        System.out.println(m);//{李四=20, 张三=18, 小红=24}
        m.clear();//从此映射中移除所有的映射关系
        System.out.println(m);//{}
    }
}

Map接口的遍历：

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

public class Demo2 {
    public static void main(String[] args) {
        function();
        function2();
    }

    private static void function2() {
        //增强性for循环
        Map<Integer,String> h=new HashMap<>();
        h.put(11,"aa");
        h.put(22,"bb");
        h.put(33,"cc");
        h.put(44,"dd");
        for (Integer key : h.keySet()) {
            System.out.println(key+":"+h.get(key));
           /* 33:cc
            22:bb
            11:aa
            44:dd*/
        }
    }

    private static void function() {
        //迭代器遍历
        Map<Integer,String> m=new HashMap<>();
        m.put(10,"aaa");
        m.put(20,"bbb");
        m.put(30,"ccc");
        m.put(40,"ddd");
        Set<Integer> set = m.keySet();
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {
            Integer key =  it.next();
            String val = m.get(key);
            System.out.println(key+":" +val);/*20:bbb
                                             40:ddd
                                             10:aaa
                                             30:ccc*/

        }
    }
}

Map第二种遍历方式：Map.Entry接口遍历

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*主要用到Entry接口中的entrySet方法来获得映射的Set视图，然后用getKey，getValue方法来获得键和值*/
public class Demo3 {
    public static void main(String[] args) {
        function();
    }

    private static void function() {
        //迭代器循环
        Map<Integer,String> m=new HashMap<>();
        m.put(10,"aa");
        m.put(20,"bb");
        m.put(30,"cc");
        m.put(40,"dd");
        Set<Map.Entry<Integer, String>> set = m.entrySet();
        Iterator<Map.Entry<Integer, String>> it = set.iterator();
        while (it.hasNext()) {
            Map.Entry<Integer, String> next =  it.next();
            Integer key = next.getKey();//getKey返回与此项对应的键
            String value = next.getValue();//getValue 返回与此项对应的值
            System.out.println(key+":"+value);
        }
       /* 20:bb
        40:dd
        10:aa
        30:cc*/
    }
}

LinkedHashMap类：

import java.util.LinkedHashMap;

public class Demo4 {
    public static void main(String[] args) {
        function();
    }

    private static void function() {
        LinkedHashMap<Integer,String> link=new LinkedHashMap<>();
        link.put(10,"aaa");
        link.put(20,"bb");
        link.put(30,"cc");
        link.put(40,"dd");
        System.out.println(link);
        for (Integer key : link.keySet()) {
            System.out.println(key+":" +link.get(key));
        }
      /*  {10=aaa, 20=bb, 30=cc, 40=dd}
        10:aaa
        20:bb           结果可以看出是有序的
        30:cc
        40:dd*/
    }
}

综合练习：

　　Map嵌套Map：

package Zuoye;

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

public class Demo {
    public static void main(String[] args) {
        function1();
        function2();
        function3();//增强型for循环遍历嵌套Map
    }

    private static void function3() {
        Map<String, Map<Integer, String>> aaa = function();
        //创建aaa映射的Set视图
        Set<Map.Entry<String, Map<Integer, String>>> aSet = aaa.entrySet();
        for (Map.Entry<String, Map<Integer, String>> amap : aSet) {
            //获得下一个aaa映射对象的键
            String className = amap.getKey();
            System.out.println(className);
            //获得值
            Map<Integer, String> classInfo = amap.getValue();
            Set<Map.Entry<Integer, String>> student = classInfo.entrySet();
            for (Map.Entry<Integer, String> stu : student) {
                Integer stuNum = stu.getKey();
                String stuName = stu.getValue();
                System.out.println(stuNum+":"+stuName);
            }
        }
    }

    private static void function2() {
        //调用Map嵌套对象
        Map<String, Map<Integer, String>> aaa = function();
        //创建aaa的Set视图对向eMap，通过Entry接口
        Set<Map.Entry<String, Map<Integer, String>>> eMap = aaa.entrySet();
        //创建eMop的迭代器对象it
        Iterator<Map.Entry<String, Map<Integer, String>>> it = eMap.iterator();
        while (it.hasNext()) {
            //获得下一个元素(Map(Map))对象赋值给classMap
            Map.Entry<String, Map<Integer, String>> classMap =  it.next();
            //获得Map(Map)的键，即班级名 ，通过getKey方法
            String className = classMap.getKey();
            //获得Map(Map)的值，即(Map)对象赋值给classInfo
            Map<Integer, String> classInfo = classMap.getValue();
            //给(map)映射对象创建Set视图，存储学生信息
            Set<Map.Entry<Integer, String>> stu = classInfo.entrySet();
            //创建迭代器
            Iterator<Map.Entry<Integer, String>> itstu = stu.iterator();
            while (itstu.hasNext()) {
                //获取下一个学生元素
                Map.Entry<Integer, String> Student =  itstu.next();
                //获得学生对象的键
                Integer key = Student.getKey();
                //获得学生的值
                String value = Student.getValue();
                System.out.println(className+":"+key+":"+value);
            }
        }
    }

    private static void function1() {
        //迭代器第一种map循环
        Map aaa = function();
        Set set = aaa.keySet();
        Iterator it = set.iterator();
        while (it.hasNext()) {
            Object className =  it.next();
            System.out.println(className);
            Map ClassInfo = (Map) aaa.get(className);
            Set Student = ClassInfo.keySet();
            Iterator its = Student.iterator();
            while (its.hasNext()) {
                Integer StudentNum = (Integer) its.next();
                String studentName = (String) ClassInfo.get(StudentNum);
                System.out.println(StudentNum+":"+studentName);
                /*hoodp班
                1:许锦迪
                2:王家宝
                java班
                1:朱东阳
                2:常军凯*/
            }
        }
    }

    private static Map<String, Map<Integer, String>> function() {
        //创建Map嵌套Map的对象
        //创建java班Map集合
        Map<Integer,String> java=new HashMap<Integer,String>();
        java.put(001,"朱东阳");
        java.put(002,"常军凯");
        //创建hoodp班Map集合
        Map<Integer,String> hoodp=new HashMap<Integer,String>();
        hoodp.put(001,"许锦迪");
        hoodp.put(002,"王家宝");
        //创建aaaMap集合
        Map<String,Map<Integer,String>> aaa=new HashMap<String,Map<Integer,String>>();
        aaa.put("java班",java);
        aaa.put("hoodp班",hoodp);

        return aaa;
    }
}