Map集合：常用方法：put，remove，get，containsKey，keySet，entrySet，HashMap接口(使用自定义类型)和LinkedHashMap接口

Map集合（接口）

特点：

1.双列集合：两个泛型

Map:K:键，V:值

K唯一，V可重复，两个的类型可以相同或者不同。可以通过键找到值

如果K重复，则新的K对应的V值会替换旧的V值

常用方法

• public V put(K key,V value):把指定的键与指定的值添加到Map集合中，如果有重复的k值想录入，会将新的k值对应的v值替换旧的v值并返回旧v值
  

• public V remove(Object key):把指定的键，所对应的键值对元素在Map集合中删除，并返回被删除的元素
  

• public V get(Object key):根据指定的键，在Map集合中获取对应的值
  

• boolean containsKey(Object key):判断集合中是否包含指定的键
  

• public Set<K> keySet();获取Map集合中所有的键，存储到Set集合中(集合遍历方法)
  

• public Set<Map.Entry<K,V>> entrySet():获取到Map集合中所有的键值对对象的集合（Set集合）(集合遍历方法)
  

  代码：

  import java.util.*;
  
  public class G10 {
      public static void main(String[] args) {
          Map<String, String> map = new HashMap<>();
  1.
          //public V put(K key,V value):把指定的键与指定的值添加到Map集合中，如果有重复的k值想录入，会将新的k值对应的v值替换旧的v值并返回旧v值
          map.put("a","1");
          map.put("b","2");
          map.put("c","3");
          map.put("d","4");
          System.out.println(map);
  2
          //public V remove(Object key):把指定的键，所对应的键值对元素在Map集合中删除，并返回被删除的元素
          System.out.println("remove:"+map.remove("b"));
  3
          //public V get(Object key):根据指定的键，在Map集合中获取对应的值
          System.out.println("get:"+map.get("a"));
  4
          //boolean containsKey(Object key):判断集合中是否包含指定的键
          System.out.println("containsKey:"+map.containsKey("d"));
  5
          /*public Set<K> keySet();获取Map集合中所有的键，存储到Set集合中
           1.用来遍历Map集合，先取键值，然后用迭代器或者增强for遍历Set集合，遍历过程中有Map集合中的get方法取出键对应的V值
              */
          Set<String> set=map.keySet();
          Iterator<String> iterator=set.iterator();
          System.out.println("keySet:");
          while (iterator.hasNext()){
              System.out.println(map.get(iterator.next()));
  6        }
          //public Set<Map.Entry<K,V>> entrySet():获取到Map集合中所有的键值对对象的集合（Set集合）
          /*
          1.使用这个方法获取Map的K与V值到Set集合中
          2.遍历Set集合
          3.遍历时利用getKey()和getValue()方法取出K和V
           */
          Set<Map.Entry<String,String>> set1=map.entrySet();
          Iterator<Map.Entry<String,String>> i=set1.iterator();
          System.out.println("entrySet:");
          while (i.hasNext()){
              //接收要用：            Map.Entry<String,String> entry
              Map.Entry<String,String> entry=i.next();
              System.out.println(""+entry.getKey()+"="+entry.getValue());
          }
      }
  
  }
  结果：
      {a=1, b=2, c=3, d=4}
  remove:2
  get:1
  containsKey:true
  keySet:
  1
  3
  4
  entrySet:
  a=1
  c=3
  d=4
  
  

接口：

1.HashMap<K,V>集合（接口）

1.底层是哈希表，1.8jdk以前是数组+（单向）链表，1.8jdk以后是数组+链表/红黑树（超过8个）

2.无序

3.多线程，速度快，不安全，可以存储null值，null键

2.LinkedHashMap<K,V>集合

1.继承至HashMap<K,V>

2.有序：是哈希表+链表（记录录入顺序）

HashMap接口使用自定义类型

1.接口中有两个元素K和V，K不可以重复，V可以重复，所以使用自定义类型面临的问题是当K是自定义类型时不能让录入的K有重复的，那么就需要对比较重复的方法进行重写，即重写：hashCode方法和equals方法，而其他java中有的类型（八点基本类型+String）java已经重写过这两个方法了，所以不用手动重写。

代码：

import java.util.*;

public class G11 {
    public static void main(String[] args) {
        
        //定义集合，K的类型是自定义的类型
        HashMap<G111,String> hashMap=new HashMap<>();
        
        //用构造方法来初始化类中的变量
        hashMap.put(new G111("zou",12),"1");
        hashMap.put(new G111("fei",13),"2");
        hashMap.put(new G111("ming",14),"3");
        
        //在重写了两个方法的情况下，因为和第一个录入的K重复，所以会抹除第一个的V，并录入新的V。
        hashMap.put(new G111("zou",12),"4");
        
        //Set集合接收的类型是Map接口中的，Map.Entry<G111,String>
        //HashMap中的entrySet方法将集合转换成Set集合
        Set<Map.Entry<G111,String>> set=hashMap.entrySet();
        
        //定义迭代器，循环，用来遍历Set集合中的K和V的值
        Iterator<Map.Entry<G111,String>> iterator=set.iterator();
        while (iterator.hasNext()){
            Map.Entry<G111,String> a=iterator.next();
            System.out.println("K="+a.getKey()+"V="+a.getValue());
        }
    }

}
class G111{
    
    //为了方便，将变量设置成公开的修饰符，一般应该将变量设置成私有的你，并用get，set方法来操作变量
    public String name;
    public int age;
    public G111(){};
    public G111(String name,int age){
        this.age=age;
        this.name=name;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "G111{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写hashCoed和equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        G111 g111 = (G111) o;
        return age == g111.age &&
                Objects.equals(name, g111.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
结果：
    K=G111{name='zou', age=12}V=4
	K=G111{name='fei', age=13}V=2
	K=G111{name='ming', age=14}V=3

LinkedHashMa（存取顺序不变）