Java学习记录之Map集合

最新推荐文章于 2024-07-25 05:19:47 发布

路～～～

最新推荐文章于 2024-07-25 05:19:47 发布

阅读量302

点赞数

本文链接：https://blog.csdn.net/cxs_123/article/details/106053869

版权

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

java.util.HashMap<k,v>集合 implements Map<k,v>接口
HashMap集合的特点：
1.HashMap集合底层是哈希表：查询速度特别快
JDK1.8之前：数组+单向链表
JDK1.8之后：数组+单向链表/红黑树(链表的长度超过8)：提高查询速度
2.HashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致
java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合
LinkedHashMap的特点：
1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
2.LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的

import java.util.HashMap;
import java.util.Map;

public class Demo01Map{
    public static void main(String[] args){
       show01();
    }
    /*
      public V put(K key,V value) :指定的键与指定的值添加到Map集合中
          返回值：V
               存储键值对的时候，key不重复，返回值V是null
               存储键值对的时候，key值重复,会使用新的value替换map中重复的value，**返回被替换的value值**
    */
    private static void show01(){
       //创建Map集合对象，多态
       Map<String,String> map = new HashMap<>();
       String v1 = map.put("李晨"，"范冰冰1")；
       System.out.println("v1:"+v1);//v1:null
       String v2 = map.put("李晨"，"范冰冰2")；
       System.out.println("v2:"+v2);//v2：范冰冰1
       System.out.println(map);//{李晨=范冰冰2}  键值重复，value值会将原来的值覆盖掉

       map.put("冷锋"，"龙小云")；
       map.put("杨过"，"小龙女")；
       map.put("尹志平"，"小龙女")；
       System.out.println(map);//{杨过=小龙女,尹志平=小龙女,李晨=范冰冰2,冷锋=龙小云}  无序，存储和取出的顺序不一致
    }
    /*
      public V remove(Object key) :把指定的键 所对应的键值对元素在Map集合中删除，返回被删除元素的值
      返回值：V
          对应的key存在，返回被删除的值
          对应的key不存在，V返回null
    */
    public void show02(){
        //创建Map集合对象
        Map<String,Integer>  map = new HashMap<>();
        map.put("赵丽颖"，168)；
        map.put("杨颖"，165)；
        map.put("林志玲"，178)；
        System.out.println(map);//{林志玲=178,赵丽颖=168,杨颖=165}
        Integer v1 = map.remove("林志玲");
        System.out.println("v1:"+v1);//178

        System.out.println(map);//{赵丽颖=168,杨颖=165}
        Integer v2 = map.remove("林志颖")；
        //int v2 = map .remove("林志颖")；//此时有人想用自动拆箱，用int类型接收v2,普通删除没问题，可是当删除不存在的键值时，返回值是null。而基本数据类型int无法接收null，要接收的话，就会报错NullPointerException 所以只能用包装类Integer ,包装类默认值就是null
        System.out.println("v2:"+v2);//v2:null   因为不存在”林志颖“这个键值
    }
    /*
      public V get(Object key) :根据指定的键，在Map集合中获取对应的值
           返回值：V
              key存在，返回对应的value值
              key不存在，返回null
    */
    public static void show03(){
       //创建Map集合对象
       Map<String,Integer> map = new HashMap<>();
       map.put("赵丽颖"，168)；
       map.put("杨颖"，165)；
       map.put("林志玲"，178)；

       Integer v1 = map.get("杨颖")；
       System.out.println("v1:"+v1);//v1:165
       Integer v2 map.get("迪丽热巴")；
       System.out.println("v2:"+v2);//v2:null
 
    } 
    /*
        boolean containskey(Object key) :判断集合中是否包含指定的键
        包含:返回true
        不包含：返回false
    */
    private static void show04(){
       //创建Map集合对象
       Map<String,Integer> map = new HashMap<>();
       map.put("赵丽颖"，168)；
       map.put("杨颖"，165)；
       map.put("林志玲"，178)；
 
       boolean b1 = map.containsKey("赵丽颖")；
       System.out.println("b1:"+b1);
 
       boolean b2 = map.containsKey("赵颖")；
       System.out.println("b2:"+b2);//false
 
    }
}

Map集合共有两个遍历方式：
第一种遍历方式：通过键找值的方式

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
Map集合中的方法：
      **Set<K> keySet()**   返回此映射中包含的键的Set视图。
实现步骤：
     1.使用Map集合中的方法KeySet(),把Map集合所有的key取出来，存储到一个Set集合中
     2.遍历Set集合，获取Map集合中的每一个key
     3.通过Map集合中的方法get(key)，通过key找到value
*/
public class Demo02KeySet{
   public static void main(String[] args){
       //创建Map集合对象
       Map<String,Integer> map = new HashMap<>();
       map.put("赵丽颖"，168)；
       map.put("杨颖"，165)；
       map.put("林志玲"，178)；
 
       //1.使用Map集合中的方法keySet()，把Map集合中所有的key取出来，存储到一个Set集合中
       Set<String> set = map.keySet();
       //2.遍历set集合，获取Map集合中的每一个key
       //使用迭代器遍历Set集合
       Iterator<String> it = set.iterator();
       while(it.hashNext()){
          String key = it.next();
          //3.通过Map集合中的方法get(key),通过key找到value
          Integer value = map.get(key);
          System.out.println(key+"="+value);
       }
       //1.使用增强for遍历Set集合
       for(String key : set){
           Integer value = map.get(key);
           System.out.println(key+"=="+value);
       }
       //2.使用增强for遍历Set集合
       for(String key : map.keySet()){
           Integer value = map.get(key);
           System.out.println(key+"=="+value);
       }
   
   }
}

第二种遍历方式：使用Entry对象遍历
Map.Entry<K,V> :在Map接口中有一个内部接口Entry 它表示Map中的一个实体(一个key-value对)
作用：当Map集合一创建，那么就会在Map集合中创建一个Entry对象，用来记录键与值(键值对对象，键与值的映射关系)

entrySet()方法的返回值也是返回一个Set集合，此集合的类型为Map.Entry.

/*
  Map集合中的方法;
      Set<Map.Entry<K,V>> entrySet()  返回此映射中包含的映射关系的Set视图
  实现步骤：
      1.**使用Map集合中的方法entrySet()**,把Map集合中多个Entry对象取出来，存储到一个Set集合中
      2.遍历Set集合，获取每一个Entry对象
      3.使用Entry对象中的方法getKey()和getValue()获取键值
*/
public class Demo03EntrySet{
    public static void main(String[] args){
       //创建Map集合对象
       Map<String,Interger> map = new HashMap<>();
       map.put("赵丽颖"，168)；
       map.put("杨颖"，165)；
       map.put("林志玲"，178)；

       //1.使用Map集合中的方法entrySet()把Map集合中多个Entry对象取出来，存储到一个Set集合中
       Set<Map.Entry<String,Integer>> set = map.entrySet();
       //2.遍历Set集合，获取每一个Entry对象
       //使用迭代器遍历Set集合
       Iterator<Map.Entry<String,Integer>> it = set.iterator();
       while(it.hashNext()){
          Map.Entry<String,Integer> entry = it.next();
          Integer value = entry.getValue();
          String key = entry.getKey();
          System.out.println(key+"="+value);
       }
       //使用增强for遍历Set集合
       for(Map.Entry<String,Integer> entry : set){
          Integer value = entry.getValue();
          String key = entry.getKey();
          System.out.println(key+"="+value);
       }
    }
}

HashMap存储自定义类型键值
Map集合保证key是唯一的：
作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一

//创建一个Person类
public class Person{
    private String name;
    private int age;
   
    public Person{
    }
    public Person(String name,int age){
         this.name = name;
         this.age = age;
    }
    //为了不保存重复的数据，需要重写hashCode方法和equals方法,之**前简单的字符串用equals方法比较，没有使用重写equals,是因为String类里已经重写类equals方法**
    @Override
    public boolean equals(Object o){
      if(this == o) return true;
      if(o==null||getClass()!=o.getClass()) return false;
      Person person = (Person) o;
      return age == person.age && Objects.equals(name,person.name);
    }
    @Override
    public int hashCode(){
       return Objects.hash(name,age);
    }
    //重写toString方法，否则打印对象名时，就会出现地址值
    @Override
    public String toString(){
       return "Person{" + "name=" + name + '\' +",age=" + age + '}';
    }
    public String getName(){
        return name;
    } 
    public void setName(String name){
        this.name=name;
    }
     public int getAge(){
        return age;
    } 
    public void setAge(int age){
        this.age=age;
    }
}

//主程序
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo01HashMapSavePerson{
    public static void main(String[] args){
       show02();
    }
    /*
      HashMap存储自定义类型键值
      key:Person类型
           Person类就必须重写hashCode方法和equals方法，以保证key唯一
           value:String类型    可以重复
    */
    private static void show02(){
       //创建HashMap集合对象
       HashMap<Person,String> map = new HashMap<>();
       //往集合中添加元素
       map.put(new Person("女王"，18)，"英国")；
       map.put(new Person("秦始皇"，18)，"秦国")；
       map.put(new Person("普京"，30),"俄罗斯")；
       map.put(new Person("女王"，18)，"毛里求斯")；

       //使用entrySet()方法获取Entry键值对，并用增强for对Set集合进行遍历
       Set<Map.Entry<Person,String>> set = map.entrySet();
       for(Map.Entry<Person,String>  entry : set){
           Person key = entry.getKey();
           String value = entry.getValue();
           System.out.println(key+"="+value);
       }
    }
    /*
      HashMap存储自定义类型键值
      key:String类型
          String类型重写hashCode方法和equals方法，可以保证key唯一  //String类型中已经重写这两个方法
      value:Person类型
           value可以重复(同名同年龄的人视为同一个)
    */
    private static void show01(){
        //创建HashMap集合对象
        HashMap<String,Person> map = new HashMap<>();
        map.put("北京",new Person("张三"，18))；
        map.put("上海",new Person("李四"，19))；
        map.put("广州",new Person("王五"，20))；
        map.put("北京",new Person("赵六"，18))；
        //使用keySet(）方法获取键，并用增强for遍历
        Set<String> set = map.keySet();
        for(String key : set){
           Person value = map.get(key);
        }
    }
}

java.util.LinkedHashMap<K,V> extends HashMap<K,V>
是Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。相对于HashMap，多了记录元素顺序的功能
底层原理：
哈希表+链表(记录元素的顺序)

public class Demo01LinkedHashMap{
    public static void main(String[] args){
      HashMap<String,String> map = new HashMap<>();
      map.put("a","a");
      map.put("c","c");
      map.put("b","b");
      map.put("a","d");
      System.out.println(map);//key值不允许重复，无序{a=d,b=b,c=c}

      LinkedHashMap<String,String> linked = new LinkedHashMap<>();
      linked.put("a","a");
      linked.put("c","c");
      linked.put("b","b");
      linked.put("a","d");
      System.out.println(linked);//key不允许有重复，有序{a=d,c=c,b=b}
    }
}

java.util.Hashtable<K,V>集合 implements Map<K,V>接口
Hashtable:底层也是一个哈希表，是一个线程安全的集合模式单线程集合，速度慢
HashMap:底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快

HashMap集合(之前学的所有集合)：可以存储null值，null键
Hashtable集合，不能存储null值，null键

Hashtable 和Vector集合一样，在jdk1.2版本之后别更先进的集合(HashMap,ArrayList)取代了
Hashtable的子类Properties依然活跃在历史舞台
Properties集合是一个唯一和IO流相结合的结合

public class Demo02Hashtable{
   public static void main(String[] args){
       HashMap<String,String> map = new HashMap<>();
       map.put(null,"a");
       map.put("b",null);
       map.put(null,null);
       System.out.println(map);//{null=null,b=null}

       Hashtable<String,String> table = new Hashtable<>();
       table.put("b",null);//NullPoniterException
   }
}