（java总结）Map集合

快来打我* 2023-05-30 10:47 25阅读 0赞

package Demo33;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /*
    java.util.Map<K,V>集合
        Map的特点：
            1、Map集合是一个双列集合，一个元素包含俩个值()
            2、Map集合中的元素，key和value的数据类型可以相同，可以不同
            3、Map集合中的元素，key是不允许重复的，value是可以重复的
            4、Map集合中的元素，key和value是意义对应的
    java.util.HashMap<K,V>集合 implements Map<K,V>接口
        HashMap集合的特点：
             1、HashMap集合底层是哈希表，查询速度特别的快
                数组+单向列表/红黑树(链表的长度超过8):提高查询速度
             2、hashMap集合是一个无需的集合，在存储元素和取出元素的顺序肯呢个不一致
    java.util.LinkedHashMap<K,V>集合 extends HashMap<K,V>集合
         LinkedHashMap的特点：
             1、LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
             2、LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一样的
    
     */
    public class CollectionMap {
        
        public static void main(String[] args) {
        
            show1();
            show2();
            show3();
        }
    
        private static void show3() {
        
            Map<String, String> map2 = new HashMap<>();
            map2.put("杨过","小龙女");
            map2.put("杨逍","纪晓芙");
            map2.put("张无忌","赵敏");
            String s3 = map2.get("杨过");
            System.out.println("s3" + s3);
        }
    
    
        /*public V put(K key, V value):把指定的键与值添加到Map集合中
                返回值：V
                    存储键值对的时候，key不重复，返回的v是null
                    存储键值对的时候，key不重复，会使用新的value替换map中重复的value，返回被替换的value
    
    
         */
        private static void show1() {
        
            //创建Map集合的对象
            Map<String, String> map = new HashMap<>();
            //集合中没有和沉香一样的，就返回空
            String v1 = map.put("沉香", "小玉1");//null
            System.out.println(v1);
            System.out.println(map);
            System.out.println("=================");
    
            String v2 = map.put("沉香", "小玉2");
            //会使用新的value替换map中重复的value，返回被替换的value
            System.out.println(v2);//小玉1
            System.out.println(map);
            System.out.println("===================");
        }
    
            private static void show2() {
        
    
                Map<String, String> map1 = new HashMap<>();
                map1.put("杨过","小龙女");
                map1.put("杨逍","纪晓芙");
                map1.put("张无忌","赵敏");
                System.out.println(map1);
                //有键值对就删除，并返回对应的value，没有就返回null
                String s1 = map1.remove("杨过");
                System.out.println("s1"+s1);
    
    
            }
    }

package Demo33;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /*
    Map集合中的第一种遍历方式： 通过键找值set<K> keySet()
    Map集合中的方法：
        set<K> keySet() 返回此映射中包含的键的set视图
    实现步骤：
        1、使用Map集合中的方法keySet(),把Map集合所有的key取出来，存储到一个Set集合中
        2、遍历Set集合，获取Map集合中的每一个Key
        3、通过Map集合中的方法get(Key),通过key找value
     */
    public class DemoKeySet {
        
        public static void main(String[] args) {
        
    
           //创建Map集合对象
            Map<String, Integer> map = new HashMap<>();
            map.put("赵丽颖",168);
            map.put("张天爱",178);
            map.put("王丽坤",188);
    
            //1、使用Map集合中的方法keySet，把Map集合所有的key取出来，存储到一个Set集合中
            Set<String> set = map.keySet();
    
            //2、遍历Set集合，获取Map集合中的每一个Key
            Iterator<String> it = set.iterator();
            while(it.hasNext()){
        
                String key = it.next();
                //3、通过Map集合中的方法get(Key),通过key找value
                Integer value = map.get(key);
                System.out.println(key + value);
            }
            System.out.println("=================");
    
            for (String key : map.keySet()) {
        
                Integer value = map.get(key);
                System.out.println(key + value);
            }
        }
    }

package Demo33;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /*
    Map集合遍历第二种方式：
        Map集合的方法：
            Set<Map.Entry<K,V>> entrySet() 返回此映射包含的映射管的的set视图
        实现步骤：
            1、使用Map集合中的方法entrySet(), 把Map集合中多个Entry对象取出来，存储到一个set集合中
            2、使用Set集合，获取每一个Entry对象
            3、使用Entry对象中的方法getKey()和getValue获取键与值
     */
    public class DemoEntrySet {
        
        public static void main(String[] args) {
        
            Map<String, Integer> map = new HashMap<>();
            map.put("赵丽颖",168);
            map.put("张天爱",178);
            map.put("王丽坤",188);
    
            //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.hasNext()){
        
                Map.Entry<String, Integer> entry = it.next();
                //3、使用Entry对象中的方法getKey()和getValue()获取键与值
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key + value);
            }
            System.out.println("==================");
    
            for (Map.Entry<String, Integer> entry : set) {
        
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key+value);
            }
    
        }
    }

package Demo33;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class DemoHashMapSavePerson {
        
        public static void main(String[] args) {
        
            show1();
            System.out.println("==================");
            show2();
        }
       /* HashMap存储自定义类型键值
        key:Person类型
        Person类型自己重写了hashCode方法和equals方法，尅保证key唯一
        value： String类型
    
         */
        private static void show2() {
        
            HashMap<Person, String> map = new HashMap<>();
           map.put(new Person("女王",18),"英国");
           map.put(new Person("秦始皇",18),"秦国");
           map.put(new Person("普京",18),"俄罗斯");
           map.put(new Person("女王",18),"毛里求斯");
        //使用entrySet
            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唯一
        value： Person类型
            value可以重复
         */
    
        private static void show1() {
        
            //K是字符串 V是Person
            //字符串重写了toString方法
            HashMap<String, Person> map = new HashMap<>();
            map.put("北京",new Person("张三",18));
            map.put("上海",new Person("李四",19));
            map.put("广州",new Person("王五",17));
            map.put("北京",new Person("赵六",16));
        //使用keySet
            Set<String> set = map.keySet();
            for (String key : set) {
        
                Person value = map.get(key);
                System.out.println(key + value);
            }
        }
    }

package Demo33;
    
    import java.util.Objects;
    
    public class Person {
        
        private String name;
        private int age;
    
        public Person() {
        
        }
    
        public Person(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        @Override
        public String toString() {
        
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @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);
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    }

package Demo33;
    
    import java.util.HashMap;
    import java.util.LinkedHashMap;
    
    
    /*
    java.util.LinkedHashMap<K,V> extends HashMap<K,V>
    Map接口的哈希表和链接列表实现，具有可预知的迭代顺着
    底层原理：
        哈希表+链表(记录元素顺序)
     */
    public class DemoLinkedHashMap {
        
        public static void main(String[] args) {
        
            HashMap<String,String> map = new LinkedHashMap<>();
            map.put("a","a");
            map.put("c","c");
            map.put("b","b");
            map.put("a","d");
            System.out.println(map);//key不允许重复，有序的
        }
    
    }