Map集合

• Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
• Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
• Collection中的集合称为单列集合，Map中的集合称为双列集合。
• 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
  
  
  Map接口中的常用方法

import java.util.HashMap;

/* `public V put(K key, V value)`:  把指定的键与指定的值添加到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<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。
* */
public class test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",18);
        map.put("赵雅芝",60);
        map.put("谢娜",20);
        map.put("Seven",20);
        System.out.println(map);
        map.remove("Seven");
        System.out.println(map);
        Integer xn = map.get("谢娜");
        System.out.println(xn);
        boolean zyz = map.containsKey("赵雅芝");
        System.out.println(zyz);
    }
}

Map集合遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取键所对应的值。方法提示:get(K key)

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


public class test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",18);
        map.put("赵雅芝",60);
        map.put("谢娜",20);
        Set<String> set=map.keySet();
        //迭代器方法
        Iterator<String> it=set.iterator();
        while(it.hasNext()){
            String key=it.next();
            Integer value = map.get(key);
            System.out.println(value);
        }
        //增强for
        for(String key:set){
            System.out.println(map.get(key));
        }
    }
}

Entry键值对对象
键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。
操作步骤与图解：

1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。
2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()
   

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


public class test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",18);
        map.put("赵雅芝",60);
        map.put("谢娜",20);
        Set<Map.Entry<String, Integer>> entry = map.entrySet();

        Iterator<Map.Entry<String,Integer>> it= entry.iterator();

        while(it.hasNext()){
            Map.Entry<String, Integer> a = it.next();
            String key = a.getKey();
            Integer value = a.getValue();
            System.out.println(key+"..."+value);
        }

        for(Map.Entry<String,Integer> entry1:map.entrySet()){
            Integer value = entry1.getValue();
            String key = entry1.getKey();
            System.out.println(key+"..."+value);
        }
    }
}

HashMap存储自定义类型键值

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;
    }

    @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 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 test {
    public static void main(String[] args) {
        //show01();
        show02();
    }

    private static void show02() {
        HashMap<Person,String> map=new HashMap<>();
        map.put(new Person("张三",18),"北京");
        map.put(new Person("李四",19),"上海");
        map.put(new Person("王五",20),"广州");
        map.put(new Person("张三",18),"北京");
        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);
        }
    }

    private static void show01() {
        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));
        Set<String> set = map.keySet();
        for(String key:set){
            Person value=map.get(key);
            System.out.println(key+"--->"+value);
        }
    }
}

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

import java.util.HashMap;
import java.util.LinkedHashMap;

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

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

Hashtable