Map接口

Map

　　map每个元素由键与值两部分组成，通过键可以找对所对应的值。

　　Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

　　Map 初始化

　　　　Map<String, String> map = new HashMap<String, String>();

　　插入元素

　　　　map.put("key1", "value1");

　　获取元素

　　　　map.get("key1")

　　移除元素

　　　　map.remove("key1");

　　清空map

　　　　map.clear();
　　例：

public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String, Integer> map=new HashMap<String, Integer>();
        //添加元素
        map.put("a", 1);
        map.put("b", 2);
        map.put("d", 2);
        map.put("a", 9);
        
        //根据key获取value
        System.out.println(map.get("a"));
        System.out.println(map.get("b"));
        System.out.println(map.get("d"));
        //根据key删除指定元素
        System.out.println(map.remove("b"));
        //遍历
        //1.从map集合中获取所有key所在的set集合
        Set<String> set=map.keySet();
        //2.遍历所有key所在的set集合取到的每一个key
        for(String key:set){
            System.out.print(key+map.get(key));
        }
        System.out.println();
        System.out.println("===================");
        //遍历:keySet+Iterator
        Set<String> set1=map.keySet();
        Iterator<String> it=set1.iterator();
        while(it.hasNext()){
            String a=it.next();
            Integer b=map.get(a);
            System.out.println(a+b);
        }
    }
}

　　如图所示：

　　　　

Entry键值对对象

　　Entry将键值对的对应关系封装成了键值对对象，遍历Map集合时，可以从每一个键值对对象中获取相应的键与值。

　　例：

    public static void main(String[] args) {
        Map<String, Integer> map=new HashMap<String, Integer>();
        //添加元素
        map.put("a", 1);
        map.put("b", 2);
        map.put("d", 2);
        map.put("a", 9);
        //entrySet+增强for遍历
        //1.获取所有键值对应的结婚证对象的set集合
        Set<Map.Entry<String, Integer>> set=map.entrySet();
        //2.从结婚证集合中取出每一个结婚证
        for(Map.Entry<String, Integer> entry:set){
            //从每一个结婚对象中取出key
            String key=entry.getKey();
            //从每一个结婚对象中取出value
            int value=entry.getValue();
            System.out.println(key+value);
        }
        System.out.println("===============");
        Set<Map.Entry<String, Integer>> set1=map.entrySet();
        Iterator<Map.Entry<String, Integer>> it=set1.iterator();
        while(it.hasNext()){
            Map.Entry<String, Integer> map1=it.next();
            String a=map1.getKey();
            int b=map1.getValue();
            System.out.println(a+b);
        }
    }

集合嵌套示例

　　先写一个person类

　　

public class Person {
    private String name;
    private Integer age;
    public Person() {
        super();
    }
    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((age == null) ? 0 : age.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age == null) {
            if (other.age != null)
                return false;
        } else if (!age.equals(other.age))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

　　嵌套：

　　

public class Demo04 {
    public static void main(String[] args) {
        //大Map
        HashMap<String,HashMap<Person,String > >oracle
        =new HashMap<String,HashMap<Person,String > >();
        //小Map1
        HashMap<Person, String> java0723=
                new     HashMap<Person, String>();
        java0723.put(new Person("小红",18), "女");
        java0723.put(new Person("小黑",19), "男");
        //小Map2
        HashMap<Person, String> java0611=
                new     HashMap<Person, String>();
        java0611.put(new Person("小蓝",18), "男");
        java0611.put(new Person("小绿",18), "男");
        //封装大Map
        oracle.put("java0723", java0723);
        oracle.put("java0611", java0611);
        //ketset+增强for
        //1.获取装有大Map中所有key的set集合
        get1(oracle);
    }
    public static void get1(HashMap<String,HashMap<Person,String > >oracle){
        //ketset+增强for
                //1.获取装有大Map中所有key的set集合
        Set<String> bigkeys=oracle.keySet();
        //2.循环遍历取到大Map中每一个key
        for(String bigkey:bigkeys){
            //根据每一个key获取对应的值
            HashMap<Person, String> bigValue=oracle.get(bigkey);
            //获取小Map的所有key所在的jihe
            Set<Person> keys=bigValue.keySet();
            //循环遍历每一个xiaokey
            for(Person key:keys){
                System.out.println(bigkey+key+bigValue.get(key));
            }
        }
        //获取大Map的结婚证对象集合
        Set<Map.Entry<String,HashMap<Person,String >>> bigkey1=oracle.entrySet();
        Iterator<Map.Entry<String,HashMap<Person,String >>> it=bigkey1.iterator();
        while(it.hasNext()){
            Map.Entry<String,HashMap<Person,String >> map=it.next();
            String a=map.getKey();
            HashMap<Person, String> bigValue2=map.getValue();
            //获取小Map
            Set<Map.Entry<Person, String>> keys1=bigValue2.entrySet();
            Iterator<Map.Entry<Person, String>> it1=keys1.iterator();
            while(it1.hasNext()){
                Map.Entry<Person, String> map2=it1.next();
                Person x=map2.getKey();
                String y=map2.getValue();
                //System.out.println(a+x+y);
                System.out.println(a+map2.getKey()+map2.getValue());
            }
        }
    }
}