集合--Map集合

Map接口概述及其成员方法 、Map接口与Collection接口的区别

import java.util.HashMap;

/*
    Map接口概述
        将键映射到值的对象
        一个映射不能包含重复的键
        每个键最多只能映射到一个值

    举例：
        <K, V>  键值对
        1001 朱佳乐
        1001 刘生发（不允许）
        1002 朱佳乐

    在Map集合中，K的值不能重复。

    Map接口与Collection接口有什么区别？
        1、Map接口与Collection接口是平级的关系，不存在继承关系，都是属于util包下面的
        2、Map集合中存储的元素都是成对出现的，Map元素的键是唯一的，值是可以重复的
            键值对有其他的称呼：夫妻对
        3、Collection接口中的元素都是单独出现的，Collection接口下面有个子接口Set元素是唯一的
            List集合中的元素是可以重复的，像这样单独出现的元素，有其他的称呼：光棍
    添加功能：
        V put(K key, V value)将指定的值与该映射中的指定键相关联（可选操作）。
        举例：map.put(1001, "朱佳乐");

    删除功能：
        void clear()从该map中删除所有的映射（可选操作）。
        V remove(Object key)如果存在（从可选的操作），从该地图中删除一个键的映射

    判断功能：
        boolean containsKey(Object key)如果此映射包含指定键的映射，则返回true 。
        boolean containsValue(Object value)如果此映射将一个或多个键映射到指定的值，则返回true 。
        boolean isEmpty()如果此map不包含键值映射，则返回 true 。

    获取功能：
        Set<Map.Entry<K,V>> entrySet()返回此map中包含的映射的Set视图。
        V get(Object key)返回到指定键所映射的值，或null如果此映射包含该键的映射。
        Set<K> keySet()返回此map中包含的键的Set视图。
        Collection<V> values()返回此地图中包含的值的Collection视图。
    长度功能：
        int size()返回此地图中键值映射的数量。

*/

public class MapDemo1 {
    public static void main(String[] args) {
        //创建一个Map集合对象
        HashMap<String, String> ssh = new HashMap<>();

        //添加元素
        //V put(K key, V value)将指定的值与该映射中的指定键相关联（可选操作）。
        //返回的是该键对应被覆盖之前的值
        //多次添加同一个key的映射的时候，key只有一个，值被覆盖。
//        System.out.println(ssh.put("邓超", "孙俪"));//null
//        System.out.println(ssh.put("邓超", "孙俪"));//孙俪
//        System.out.println(ssh.put("邓超", "孙俪2"));//孙俪
//        System.out.println(ssh.put("邓超", "孙俪3"));//孙俪3

        ssh.put("邓超", "孙俪");
        ssh.put("吴京", "谢楠");
        ssh.put("张杰", "谢娜");
        ssh.put("小虎", "冯提莫");
        System.out.println(ssh);

        System.out.println("===================================");

        //void clear()从该map中删除所有的映射（可选操作）。
//        ssh.clear();
//        System.out.println(ssh);//-{}

        System.out.println("===================================");

        //V remove(Object key)如果存在（从可选的操作），从该地图中删除一个键的映射
        //key不存在的时候不会报错
        //返回的是被删除的key对应的值，并且从map集合中移除
        System.out.println(ssh.remove("小虎"));
        System.out.println(ssh);

        //boolean containsKey(Object key)如果此映射包含指定键的映射，则返回true 。
        System.out.println("===================================");
        System.out.println(ssh.containsKey("邓超"));
        System.out.println(ssh.containsKey("小虎"));

        // boolean containsValue(Object value)如果此映射将一个或多个键映射到指定的值，则返回true 。
        System.out.println(ssh.containsValue("孙俪"));
        System.out.println(ssh.containsValue("冯提莫"));

        System.out.println("===================================");
        //boolean isEmpty()如果此map不包含键值映射，则返回 true 。
        System.out.println(ssh.isEmpty());

        //int size()返回此地图中键值映射的数量。
        System.out.println("map集合中的键值对个数：" + ssh.size());
    }
}

import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

/*
        Map集合的获取功能：
            V get(Object key)返回到指定键所映射的值，或null如果此映射包含该键的映射。
            Set<K> keySet()返回此map中包含的键的Set视图。
            Collection<V> values()返回此地图中包含的值的Collection视图。
*/

public class MapDemo2 {
    public static void main(String[] args) {
        //创建map集合对象
        HashMap<String, String> ssh = new HashMap<>();

        //添加元素
        ssh.put("邓超", "孙俪");
        ssh.put("吴京", "谢楠");
        ssh.put("张杰", "谢娜");
        ssh.put("小虎", "冯提莫");

        //V get(Object key)返回到指定键所映射的值，或null如果此映射包含该键的映射。
        //如果map中不包含该键，返回的是null
        System.out.println(ssh.get("邓超"));
        System.out.println("===================================");

        //Set<K> keySet()返回此map中包含的键的Set视图。
        Set<String> strings = ssh.keySet();
        for(String s : strings){
            System.out.println(s);
        }
        System.out.println("===================================");

        //Collection<V> values()返回此地图中包含的值的Collection视图。
        Collection<String> values = ssh.values();
        for (String s : values){
            System.out.println(s);
        }
    }
}

遍历Map集合的方式

import java.util.HashMap;
import java.util.Set;

/*
        遍历map集合的方式1：根据键找值
            1、获取Map集合中所有映射的键的Set集合
            2、遍历键的集合，根据键找对应的值
            3、输出
*/

public class MapDemo3 {
    public static void main(String[] args) {
        HashMap<String, String> ssh = new HashMap<>();

        //添加元素
        ssh.put("洛", "霞");
        ssh.put("卢锡安", "塞纳");
        ssh.put("蛮王", "艾希");
        ssh.put("盖伦", "卡特");
        ssh.put("卢锡安", "塞纳");

        //获取Map集合中所有映射的键的Set集合
        Set<String> keySet = ssh.keySet();

        for (String key : keySet) {
            String value = ssh.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

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

/*
        遍历Map集合的方式2：根据键值对对象找键和值
        1、获取所有键值对的集合
        2、遍历获取每一个键值对，得到每一个键值对对象
        3、根据获取到的每一个键值对对象，来进一步获取键和值
*/

public class MapDemo4 {
    public static void main(String[] args) {
        HashMap<String, String> ssh = new HashMap<>();

        //添加元素
        ssh.put("洛", "霞");
        ssh.put("卢锡安", "塞纳");
        ssh.put("蛮王", "艾希");
        ssh.put("盖伦", "卡特");
        ssh.put("卢锡安", "塞纳");

        //获取所有键值对的集合
        Set<Map.Entry<String, String>> entries = ssh.entrySet();
        for (Map.Entry<String, String> keyValue : entries) {
            //HashMap中重写了getKey()和getValue()方法
            String key = keyValue.getKey();
            String value = keyValue.getValue();

            System.out.println(key + "---" + value);
        }
    }
}

HashMap的概述及案例

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

/*
    HashMap类概述
    
    	键是哈希表结构，可以保证键的唯一性

    HashMap案例

        HashMap<Integer,String>
*/

public class MapDemo5 {
    public static void main(String[] args) {
        //创建Map集合对象
        HashMap<Integer, String> map = new HashMap<>();

        map.put(1001, "朱佳乐");
        map.put(1002, "刘生发");
        map.put(1003, "张咪");
        map.put(1004, "吕常福");

        //遍历集合
        System.out.println("=======方式1：根据键找值========");
        Set<Integer> keys = map.keySet();

        for (Integer key : keys) {
            String value = map.get(key);
            System.out.println(key + "---" + value);
        }

        System.out.println("=======方式2：根据键值对找键和值========");
        Set<Map.Entry<Integer, String>> keyValue = map.entrySet();
        for (Map.Entry<Integer, String> kv : keyValue) {
            Integer key = kv.getKey();
            String value = kv.getValue();
            System.out.println(key + "---" + value);
        }
    }
}

import java.util.Objects;

public class Student4 {
    private String name;
    private int age;

    public Student4() {
    }

    public Student4(String name, int age) {
        this.name = name;
        this.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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student4 student4 = (Student4) o;
        return age == student4.age &&
                Objects.equals(name, student4.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}

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

/*
    HashMap<String,Student>
*/
public class MapDemo6 {
    public static void main(String[] args) {
        //创建map集合对象
        HashMap<String, Student4> map = new HashMap<>();

        //创建4个学生对象
        Student4 s1 = new Student4("朱佳乐", 18);
        Student4 s2 = new Student4("刘生发", 17);
        Student4 s3 = new Student4("张咪", 19);
        Student4 s4 = new Student4("张梦云", 19);

        //向map集合中添加键值对
        map.put("帅气男孩", s1);
        map.put("亿气风发", s2);
        map.put("犹抱琵琶半遮面", s3);
        map.put("仙女下凡", s4);

        //获取键值对遍历
        Set<Map.Entry<String, Student4>> entries = map.entrySet();
        for (Map.Entry<String, Student4> keyValue : entries) {
            String key = keyValue.getKey();
            Student4 value = keyValue.getValue();

            System.out.println(key + "---" + value);
        }
    }
}

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

/*
        HashMap<Student,String>
*/

public class MapDemo7 {
    public static void main(String[] args) {
        HashMap<Student4, String> map = new HashMap<>();

        //创建学生对象
        Student4 s1 = new Student4("貂蝉", 17);
        Student4 s2 = new Student4("西施", 18);
        Student4 s3 = new Student4("杨玉环", 16);
        Student4 s4 = new Student4("王昭君", 19);
        Student4 s5 = new Student4("貂蝉", 17);

        //将元素添加到集合中
        map.put(s1, "1111");
        map.put(s2, "2222");
        map.put(s3, "3333");
        map.put(s4, "4444");
        map.put(s5, "5555");

        //遍历
        Set<Map.Entry<Student4, String>> entries = map.entrySet();
        for (Map.Entry<Student4, String> kv : entries) {
            Student4 key = kv.getKey();
            String value = kv.getValue();

            System.out.println(key + "---" + value);
        }
    }
}

LinkedHashMap

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

/*
        LinkedHashMap:
   			public class LinkedHashMap<K,V>  extends HashMap<K,V> implements Map<K,V>
   
       哈希表和链表实现的Map接口，具有可预测的迭代次序。
       
       哈希表保证元素的唯一，保证的是key的唯一
       链表保证的是有序，存储和取出的顺序一致。

*/

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> linkedMap = new LinkedHashMap<>();

        //添加元素到集合中
        linkedMap.put("3213", "hello");
        linkedMap.put("1234", "world");
        linkedMap.put("3456", "java");
        linkedMap.put("1234", "hadoop");
        linkedMap.put("3456", "spark");
        linkedMap.put("4567", "hello");

        //遍历
        Set<Map.Entry<String, String>> entries = linkedMap.entrySet();
        for (Map.Entry<String, String> kv : entries) {
            String key = kv.getKey();
            String value = kv.getValue();

            System.out.println(key + "---" + value);
        }
    }
}

TreeMap的概述及案例

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
    TreeMap类概述
		键是红黑树结构，可以保证键的排序和唯一性
        
	TreeMap案例
    TreeMap<String,String>
*/
public class TreeMapDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        TreeMap<String, String> map = new TreeMap<>();

        //添加元素到集合中
        map.put("hello", "你好");
        map.put("java", "面向对象编程的语言");
        map.put("hadoop", "适合海量数据存储的分布式计算和分布式存储的平台");
        map.put("hive", "是数据仓库建模工具之一");
        map.put("java", "面向对象编程的语言2");

        //遍历
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> kv : entries) {
            String key = kv.getKey();
            String value = kv.getValue();

            System.out.println(key + "--" + value);
        }
    }
}

import java.util.Objects;

public class Student4 {
    private String name;
    private int age;

    public Student4() {
    }

    public Student4(String name, int age) {
        this.name = name;
        this.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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student4 student4 = (Student4) o;
        return age == student4.age &&
                Objects.equals(name, student4.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}

import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
        TreeMap<Student,String>

        键：Student
        值：String
*/

public class TreeMapDemo2 {
    public static void main(String[] args) {
        //创建TreeMap对象
        TreeMap<Student4, String> map = new TreeMap<>(new Comparator<Student4>() {
            @Override
            public int compare(Student4 o1, Student4 o2) {
                //年龄
                int i = o1.getAge()-o2.getAge();
                //姓名
                int i2 = i == 0 ? o1.getName().compareTo(o2.getName()) : i;

                return i2;
            }
        });

        //创建学生对象
        Student4 s1 = new Student4("唐伯虎", 18);
        Student4 s2 = new Student4("祝枝山", 19);
        Student4 s3 = new Student4("朱佳乐", 20);
        Student4 s4 = new Student4("杨旭", 17);
        Student4 s5 = new Student4("唐伯虎", 18);

        //添加元素到集合中
        map.put(s1, "唐伯虎点秋香");
        map.put(s2, "小鸡吃米图");
        map.put(s3, "水淹电脑");
        map.put(s4, "申报才子");
        map.put(s5, "唐伯虎点秋香");

        //遍历
        Set<Map.Entry<Student4, String>> entries = map.entrySet();
        for (Map.Entry<Student4, String> entry : entries) {
            Student4 key = entry.getKey();

            String value = entry.getValue();
            System.out.println(key + "---" + value);
        }
    }
}