JAVASEday11 集合之Map

Map集合

Map集合用于保存具有映射关系的数据，Map集合中 保存着两组值key和value，key和value可以是任意类型的数据，但是key值不允许重复，而且key和value存在着一对一的关系，所有Map集合的数据结构，只跟键有关，跟值没关系。
Map三个子类的特点:
HashMap:键的 数据结构是哈希表，允许插入null键 null值，线程不安全效率高
LinkedHashMap: 底层的数据结构是链表和哈希表 元素有序 并且唯一
TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性

HashMap

方法：
public V put(K key, V value)：
给集合中插入键值对元素
public void clear()：
清空集合中的全部元素
public V remove(Object key):
删除某一对元素
public boolean containsKey(Object key)：
判断有没有这个键
public boolean containsValue(Object value)：
判断有没有这个值
public boolean isEmpty():
判断集合是否是空
public Set<Map.Entry<K,V>> entrySet()：
获取键值对对象的集合
public V get(Object key):
键找值
public Set keySet() :
获取所有键的集合
public Collection values():
获取所有值的集合
public int size()：
获取集合中键值对个数

    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        map.put("文章", "马伊琍");
        map.put("贾乃亮", "李小璐");
        map.put("陈思成", "佟丽娅");
        map.put("大郎", "金莲");
        //删除某一对
        String s = map.remove("大郎"); //根据键，删除键值对，返回的是，这个键，对应的那个值
        System.out.println(s);
        //全部情清空集合中的元素
        map.clear();
        boolean b = map.isEmpty(); //判断集合是否为空
        int size = map.size(); //获取集合的长度
         //判断有没有这个键
        boolean b = map.containsKey("文章");
        //判断有没有这个值
        boolean b1 = map.containsValue("李小璐2");

键找值
        String value = map.get("文章");
        System.out.println(value);

        //遍历 键找值

        //获取所有键的集合
        Set<String> keySet = map.keySet();
        //遍历键集 键找值
        for (String key : keySet) {
            System.out.println(key+"=="+map.get(key));
        }

        System.out.println("--------------------------");
        //获取所有值的集合
        Collection<String> values = map.values();
        System.out.println(values);

集合的遍历：
一种是键找值，另一种是遍历键值对集合，通过键值对集合中的的方法去除键和值

 HashMap<String, String> map = new HashMap<>();
        map.put("文章", "马伊琍");
        map.put("贾乃亮", "李小璐");
        map.put("陈思成", "佟丽娅");
        map.put("大郎", "金莲");
        System.out.println(map.size());
        //遍历方式1
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key+"===="+map.get(key));
        }
        System.out.println("---------------------------------");
        //遍历方式2
        //获取出，键值对  对象 的集合
        Set<Map.Entry<String, String>> entries = map.entrySet();
        //遍历键值对 集合 ，通过键值对 对象 里面的方法取出键和值
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();//获取键
            String value = entry.getValue();//获取值
            System.out.println(key+"====="+value);
        }

HashMap和HashTable的区别：
HashMap 允许存储null键和null值 线程不安全效率高
Hashtable 不允许null键和null值 线程安全效率低

LinkedHashMap

 public static void main(String[] args) {
        //键唯一且有序，链表保证了键有序，哈希表保证了键唯一
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put(10,"abc");
        linkedHashMap.put(20, "abc");
        linkedHashMap.put(30, "abc");
        linkedHashMap.put(40, "abc");
        linkedHashMap.put(50, "abc");
        linkedHashMap.put(60, "abc");
        linkedHashMap.put(70, "abc");
        linkedHashMap.put(70, "abcdddd");

        System.out.println(linkedHashMap);

    }

TreeMap

 TreeMap<Integer, String> treeMap = new TreeMap<>();
        treeMap.put(14,"abc");
        treeMap.put(16, "abc");
        treeMap.put(155, "abc");
        treeMap.put(11, "abc");
        treeMap.put(12, "abc");

        System.out.println(treeMap);

TreeMap的排序
TreeMap有自然排序和比较器排序两种，
空参构造，自然排序
有参构造，比较器排序
我们以自定义学生对象为例，

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

    @Override
    public int compareTo(Student s) {
        int i = this.age - s.age;
        int j=i==0?this.name.compareTo(s.name):i;

        return j;
    }
}

TreeMap<Integer, String> treeMap = new TreeMap<>();
        treeMap.put(14,"abc");
        treeMap.put(16, "abc");
        treeMap.put(155, "abc");
        treeMap.put(11, "abc");
        treeMap.put(12, "abc");

        System.out.println(treeMap);

比较器排序使用的是有参构造

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

    public Student(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public static void main(String[] args) {
        //Map集合的数据结构，只跟键有关

        TreeMap<Student, Integer> treeMap = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int i = s1.getAge() - s2.getAge();
                int j=i==0?s1.getName().compareTo(s2.getName()):i;
                return j;
            }
        });

        new TreeSet<Integer>().add(100);
        treeMap.put(new Student("zhangsan",1),1);
        treeMap.put(new Student("zhangsan", 10), 1);
        treeMap.put(new Student("zhangsan", 12), 1);
        treeMap.put(new Student("zhangsan", 122), 1);
        treeMap.put(new Student("zhangsan", 144), 1);
        treeMap.put(new Student("zhangsan", 109), 1);
        treeMap.put(new Student("zhangsan", 156), 1);
        treeMap.put(new Student("zhangsan", 124), 1);
        treeMap.put(new Student("zhangsan", 124), 1);

        Set<Map.Entry<Student, Integer>> entries = treeMap.entrySet();

        for (Map.Entry<Student, Integer> en : entries) {
            Student key = en.getKey();
            Integer value = en.getValue();
            System.out.println(key.getName()+"=="+key.getAge()+"======="+value);
        }

    }

Set和Map的区别

set是一种关联式容器，其特性如下：
set以RBTree作为底层容器
所得元素的只有key没有value，value就是key
不允许出现键值重复
所有的元素都会被自动排序
不能通过迭代器来改变set的值，因为set的值就是键
map和set一样是关联式容器，它们的底层容器都是红黑树，区别就在于map的值不作为键，键和值是分开的。它的特性如下：

map以RBTree作为底层容器
所有元素都是键+值存在
不允许键重复
所有元素是通过键进行自动排序的
map的键是不能修改的，但是其键对应的值是可以修改的