Map接口

简介

类型参数:
K-此映射所维护的键的类型 键
v-映射值的类型 值

将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值。

collection中的集合,元素是孤立存在的(理解为单身) ,向集合中存储元素采用一个个元素的方式存储。
Map中的集合,元素是成对存在的理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的值。

collection中的集合称为单列集合,Map中的集合称为双列集合。
需要注意的是, Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。

特点

Map集合的特点:
1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)2.Map集合中的元素,key和value的数据类型可以相同,也可以不同3.Map集合中的元素,key是不允许重复的, value是可以重复的
4.Map集合中的元素,key和value是一一对应

注意

Map接口中的集合都有两个泛型变量KV>,在使用时,要为两个泛型变量赋予数据类型。

两个泛型变量<K,V>的数据类型可以相同，也可以不同。

常用方法

public V put (K key, Vvalue) :把指定的键与指定的值添加到Map集合中。
public V remove(object key) :把指定的键所对应的键值对元素在Map集合中删除,返回被删除元素的值。
public V get(object key)根据指定的键,在Map集合中获取对应的值。
boolean containskey (object key)判断集合中是否包含指定的键。
public Set<k> keyset() :获取Map集合中所有的键,存储到Set集合中。
public Set> entryset() :获取到Map集合中所有的键值对对象的集合(Set集合)。

HashMap集合

特点:

1.HashMap集合底层是哈希表:查询的速度特别的快
JDK1.8之前:数组+单向链表
JDK1.8之后:数组+单向链表/红黑树(链表的长度超过8):提高查询的速度

hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致
java.util. LinkedHashMap集合extends HashMap集合

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

public V put(K key, v value)

  1.     private static void show01() {
  2. //创建Map集合对象,多态
  3.         Map<String, String> map = new HashMap<>();
  4.         String v1 =map.put("李晨", "范冰冰1");
  5.         System.out.println("v1:"+v1);//vi:null存储键值对的时候,key不重复,返回值v是null
  6.         String v2 =map.put("李晨", "范冰冰2");
  7.         System.out.println("v2: "+v2);//v2:范冰冰1 存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回被替换的value值
  8.         System.out.println(map);//{李晨=范冰冰2}
  9.         map.put ("冷锋","龙小云");
  10.         map. put ("杨过","小龙女");
  11.         map.put ("尹志平","小龙女");
  12.         System.out. println(map);
  13.     }
  15.     public static void main(String[] args) {
  16.         show01();
  17.     }

public V remove(object key)

  1.  /*
  2.         public V remove(object key):把指定的键所对应的键值对元素在Map集合中删除,返回被删除元素的值。
  3.         返回值:V
  4.         key存在,v返回被删除的值key不存在, v返回null
  5.   */
  6.   private static void show02() {
  7.     //创建Map集合对象
  8.     Map<String, Integer> map = new HashMap<>();
  9.     map.put("赵丽颖",168);
  10.     map. put ("杨颖", 165);
  11.     map. put ("林志玲",178);
  12.     System.out.println(map);//{林志玲=178,赵丽颖-168,杨颖=165}
  13.     Integer v1 =map.remove( "林志玲");
  14.     System.out.println("v1: "+v1);//v1:178
  15.     System.out.println(map);//{赵丽颖=168,杨颖=165}
  16.     //int v2=map. remove ("林志颖");//自动拆箱 NullPointerException
  17.     Integer v2 = map.remove( "林志颖");
  18.     System.out.println("v2:"+v2);//v2:nulL
  19.     System.out.println(map);//{赵丽颖=168,杨颖=165}
  20. }
  22.   public static void main(String[] args) {
  23.         show02();
  24.     }

public V get (object key)

  1.  /*
  2.     public V get (object key)根据指定的键,在Map集合中获取对应的值。
  3.     返回值:
  4.     key存在,返回对应的value值key不存在,返回null
  5.   */
  6.     private static void show03() {
  7.     //创建Map集合对象
  8.     Map<String, Integer> map = new HashMap<>();
  9.     map.put ("赵丽颖",168);
  10.     map.put ("杨颖", 165);
  11.     map.put ("林志玲",178);
  12.     Integer v1 =map. get ("杨颖");
  13.     System.out.println("v1: "+v1);//v1:165
  14.     Integer v2 =map.get("迪丽热巴");
  15.     System.out.println("v2:"+v2);//v2:null
  16. }
  18.     public static void main(String[] args) {
  19.         show03();
  20.     }

boolean containskey(object key)

  1.   /*
  2.     boolean containsKey(object key)判断集合中是否包含指定的键。
  3.     包含返回true,不包含返回false
  4.     */
  5.     private static void show04(){
  6.     //创建Map集合对象
  7.     Map<String, Integer> map =new HashMap <>();
  8.     map.put ("赵颖",168);
  9.     map. put ("杨颖",165);
  10.     map.put ("林志玲",178);
  11.     boolean b1 =map.containsKey("赵丽颖");
  12.     System.out.println("b1:"+b1);//b1:true
  13.     boolean b2=map.containsKey ("赵颖");
  14.     System.out.println("b2: "+b2);//b2:false
  15. }
  17.     public static void main(String[] args) {
  18.         show04();
  19.     }

Map集合遍历键找值方式

键找值方式:即通过元素中的键,获取键所对应的值分析步骤：
1,获取Map中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键。方法提示: keyset()
2,遍历键的Set集合,得到每一个键。
3根据键,获取键所对应的值。方法提示: get(K key)

034Map接口集合 - 图1

Map集合的第一种遍历方式:通过键找值的方式
Map集合中的方法:
实现步骤:
Set<K>keySet()返回此映射中包含的键的Set视图。
1,使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
2.遍历set集合,获取Map集合中的每一个key
3.通过Map集合中的方法get(key),通过key找到value

  1. public static void main(String[] args) {
  2. //创建Map集合对象
  3. Map<String, Integer> map = new HashMap<();
  4. map.put ("赵丽颖", 168);
  5. map.put("杨颖", 165);
  6. map.put ("林志玲",178);
  7. //1.使用Map集合中的方法keyset(),把Map集合所有的key取出来,存储到一个Set集合中
  8. Set<string> set =map.keySet();
  9. 1/2.遍历set集合,获取Map集合中的每一个key//使用送代器遍历Set集合
  10. Iterator<string> it = set.iterator();
  11. while (it.hasNext()){
  12. string key =it.next();
  13. //3.通过Map集合中的方法get(key),通过key找到value
  14. Integer value =map. get(key);
  15. 5ystem.out.printin(key+"="+value);
  16. }
  17.  //使用增强for遍历Set集
  18. for(String key : set){
  19. //3.通过Map集合中的方法get(key),通过key找到value
  20. Integer value =map.get(key);
  21. System.out.println(key+"="+value);
  22. }
  24. //使用增强for遍历Set集合
  25. for(String key : set)
  26. //3.通过Map集合中的方法get(key),通过key找到value
  27. Integer value =map.get (key);
  28. System.out.println(key+"="+value);
  29. }
  30. }
  31. }

Entry键值对对象

我们已经知道, Map中存放的是两种对象,一种称为key(键),一种称为value(值),它们在在Map中是-对应关系,这一对对象又称做Map中的一个Entry(项). Entry将键值对的对应关系封装成了对象。即键值对对象,这样我们在遍历Map集合时,就可以从每一个键值对( Entry )对象中获取对应的键与对应的值。
既然Entry表示了一对键和值,那么也同样提供了获取对应鏈和对应值得方法:
public K getkey() :获取Entry对象中的键。
public v getvalue() :获取Entry对象中的值。
在Map集合中也提供了获取所有Entry对象的方法:
public set> entryset() :获取到Map集合中所有的键值对对象的集合(Set集合)。

键值对方式:即通过集合中每个键值对(Entry)对象,获取键值对(Entry)对象中的键与值。
操作步骤与图解：
1,获取Map集合中,所有的键值对(Entry)对象,以Set集合形式返回。方法提示: entryset()
2.遍历包含键值对(Entry对象的Set集合,得到每一个键值对(Entry)对象。
3,通过键值对(Entry)对象,获取Entry对象中的键与值。方法提示: getkey () getvalue()

034Map接口集合 - 图2

Map集合遍历的第二种方式:使用Entry对象遍历
Map集合中的方法:
Set> entrySet()返回此映射中包含的映射关系的Set视图。
实现步骤:
1,使用Map集合中的方法entryset(),把Map集合中多个Entry对象取出来,存储到一个set集合中2·遍历Set集合,获取每一个Entry对象
3,使用Entry对象中的方法getkey()和getvalue ()获取键与值

  1.    public static void main(String[] args) {
  2.         //创建Map集合对象
  3.         Map<String, Integer> map = new HashMap<>();
  4.         map.put("赵E颖", 168);
  5.         map.put("杨颖", 165);
  6.         map.put("林志玲", 178);
  7.         //1,使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
  8.         Set<Map.Entry<String, Integer>> set = map.entrySet();
  10.         //2.遍历Set集合,获取每一个Entry对象//使用迭代器遍历Set集合
  11.         Iterator<Map.Entry<String, Integer>> it = set.iterator();
  12.         while (it.hasNext()) {
  13.             Map.Entry<String, Integer> entry = it.next();
  15.             //3.使用Entry对象中的方法getkey()和getValue()获取键与值
  16.             String key = entry.getKey();
  17.             Integer value = entry.getValue();
  18.             System.out.println(key + "=" + value);
  19.         }
  20.         System.out.println("----");
  21.         for (Map.Entry<String, Integer> entry : set) {
  23.             //3.使用Entry对象中的方法getKey()和getValue ()获取键与值
  24.             String key = entry.getKey();
  25.             Integer value = entry.getValue();
  26.             System.out.println(key + "=" + value);
  27.         }
  28.     }

HashMap存储自定义类型键值

练习:每位学生(姓名，年龄)都有自己的家庭住址。那么,既然有对应关系,则将学生对象和家庭住址存储到map集合中。学生作为键,家庭住址作为值。

  1.  /*
  2.         HashMap存储自定义类型键值
  3.         Map集合保证key是唯一的:
  4.         作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一
  5.     */
  6.     public static void main(String[] args) {
  7.         show01();
  8.         show02();
  9.     }
  11.     /*
  12.     HashMap存储自定义类型键值
  13.       key: String类型
  14.       String类重写hashCode方法和equals方法,可以保证key唯一value:Person类型
  15.       value可以重复(同名同年龄的人视为同一个)
  16.   */
  17.     private static void show01() {
  18.         //创建HashMap集合
  19.         HashMap<String, Person> map = new HashMap<>();
  20.         //往集合中添加元素
  21.         map.put("北京", new Person("张三", 18));
  22.         map.put("上海", new Person("李四", 19));
  23.         map.put("广州", new Person("王五", 20));
  24.         map.put("北京", new Person("赵六", 18));
  25.         //使用keySet加增强for遍历Map集合
  26.         Set<String> set = map.keySet();
  27.         for (String key : set) {
  28.             Person value = map.get(key);
  29.             System.out.println(key + "-->" + value);
  30.         }
  31.     }
  33.     /*
  34.       HashMap存储自定义类型键值
  35.         key: Person类型
  36.         Person类就必须重写hashCode方法和equals方法,以保证ke唯value:String类型
  37.     */
  38.     private static void show02() {
  39.         //创建HashMap集合
  40.         HashMap<Person, String> map = new HashMap<>();
  41.         //往集合中添加元素
  42.         map.put(new Person("女王", 18), "英国");
  43.         map.put(new Person("秦始皇", 18), "秦国");
  44.         map.put(new Person("普京", 30), "俄罗斯");
  45.         map.put(new Person("女王", 18), "毛里求斯");
  46.         //使用entrySet和增强for遍历Map集合
  47.         Set<Map.Entry<Person, String>> set = map.entrySet();
  49.         for (Map.Entry<Person, String> entry : set) {
  50.             Person key = entry.getKey();
  51.             String value = entry.getValue();
  52.             System.out.println(key + "--" + value);
  53.         }
  54.     }
  1. public class Person {
  2.     private String name;
  3.     private int age;
  5.     public Person() {
  6.     }
  8.     public Person(String name, int age) {
  9.         this.name = name;
  10.         this.age = age;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  29.     @Override
  30.     public boolean equals(Object o) {
  31.         if (this == o) return true;
  32.         if (o == null || getClass() != o.getClass()) return false;
  33.         Person person = (Person) o;
  34.         return age == person.age && name.equals(person.name);
  35.     }
  37.     @Override
  38.     public int hashCode() {
  39.         return Objects.hash(name, age);
  40.     }
  42.     @Override
  43.     public String toString() {
  44.         return "Person{" +
  45.                 "name='" + name + '\'' +
  46.                 ", age=" + age +
  47.                 '}';
  48.     }
  49. }

LinkedHashMap

1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的

LinkedHashMap通过链表结构可以保证元素的存取顺序一致;通过哈希表结构可以保证的键的唯一、不重复,
需要重写键的hashCode()方法、equals0方法。

  1. public class LinkedHashMapDemo {
  2.   public static void main(String[] args) {
  3.         LinkedHashMap<String, String> map = new LinkedHashMap<>();
  4.         map.put("邓超", "孙丽");
  5.         map.put("李晨", "范冰冰");
  6.         map.put("刘德华", "朱丽倩");
  7.         Set<Map.Entry<String, String>> entrySet = map.entrySet();
  8.         for (Map.Entry<String, String> entry : entrySet) {
  9.             System.out.println(entry.getKey() + " " + entry.getValue());
  10.         }
  11.     }
  12. }