Map接口

l Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

l Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。

l Collection中的集合称为单列集合，Map中的集合称为双列集合。

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

l Map中常用的集合为HashMap集合、LinkedHashMap集合。

Map接口中常用集合概述

l HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

l LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

l 注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

Map接口中的常用方法

l put方法：将指定的键与值对应起来，并添加到集合中（存值）

方法返回值为键所对应的值

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

使用put方法时，若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

l get方法：获取指定键(key)所对应的值(value)

l remove方法：根据指定的键(key)删除元素，返回被删除元素的值(value)。

Map集合遍历键找值方式

获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键（Key）

1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键

2.遍历键的Set集合，得到每一个键

3.根据键，获取键所对应的值

Entry键值对对象

l Entry是Map接口中提供的一个静态内部嵌套接口。

l getKey()方法：获取Entry对象中的键

l getValue()方法：获取Entry对象中的值

l entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。

Map集合遍历键值对方式

1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。

2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象

3.通过键值对(Entry)对象，获取Entry对象中的键与值。

Map接口的四种遍历方式

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

public class Demo03 {
public static void main(String[] args) {
    Map<String, Integer> map=new HashMap<String, Integer>();
    map.put("张三", 18);//存值
    map.put("李四", 28);
    map.put("张三", 19);
    //删除元素
    /*map.remove("张三");
    //取值
    System.out.println(map.get("张三"));
    System.out.println(map.get("李四"));*/
    //遍历1.keySet+增强for
    //先获得所有Key所在的Set集合
    Set<String> set=map.keySet();//获取的是Key
    //遍历
    /*for(String key:set){
        System.out.println(key+"..."+map.get(key));
    }*/
    Iterator<String> arr=set.iterator();//获取迭代器对象
    while(arr.hasNext()){
        String i=arr.next();//next方法不能多次出现，出现一次调用一次方法，向后走一个
        System.out.println(i+"..."+map.get(i));
    }
    
}
}

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

public class Demo04 {
public static void main(String[] args) {
    HashMap<String, Double> map=new HashMap<String, Double>();
    map.put("小红帽", 12.3);
    map.put("小兰猫", 13.6);
    map.put("小黑猫", 12.8);
    //1.entrySet+增强for
    //获取所有结婚证对象所在的Set集合
    Set<Map.Entry<String, Double>> entry=map.entrySet();
    //遍历取每个结婚证对象
    for(Map.Entry<String, Double> en:entry){
        String key=en.getKey();
        double value=en.getValue();
        System.out.println(key+"..."+value);
    }
    //获取迭代器对象
    Iterator<Map.Entry<String, Double>> arr=entry.iterator();
    while(arr.hasNext()){
        Map.Entry<String, Double> i=arr.next();
        String j=i.getKey();//获取Key
        double k=i.getValue();//获取Value
        System.out.println(j+"..."+k);
    }
}
}

public class Demo05 {//引用数据类型
public static void main(String[] args) {
    //LinkedHashMap怎么存怎么取
    LinkedHashMap<Person, Integer> map=new LinkedHashMap<Person, Integer>();
    map.put(new Person("小红",18), 20);
    map.put(new Person("小绿",10), 24);
    map.put(new Person("小绿",10), 40);
    Set<Person> set=map.keySet();
    for(Person i:set){
        System.out.println(i+"..."+map.get(i));
    }
    Iterator<Person> arr=set.iterator();
    while(arr.hasNext()){
        Person i=arr.next();
        System.out.println(i+"ooo"+map.get(i));
    }
    Set<Map.Entry<Person, Integer>> set2=map.entrySet();
    for(Map.Entry<Person, Integer> i:set2){
        Person j=i.getKey();
        int k=i.getValue();
        System.out.println(j+"aaa"+k);
    }
    Iterator< Map.Entry<Person, Integer>> arr1=set2.iterator();
    while(arr1.hasNext()){
        Map.Entry<Person, Integer> i=arr1.next();
        System.out.println(i.getKey()+"///"+i.getValue());
    }