使用Map(HashMap)存储自定义类的键值、HashTable

一、使用Map(HashMap)存储自定义类的键值

有点像HashSet存储自定义类型元素（eg:自定义的类）

Map的键要唯一，所以：

String类作为键的话，重写hashCode方法和equals方法（人家已经重写好了，我们不用重写）,可以保证key唯一

而我们自定义的类作为键的话，则必须重写hashcode和equals方法

看代码好懂：

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

class Student{
    private String name;
    private int age;
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        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;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.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;
    }
}
/*
    HashMap存储自定义类型键值
    Map集合保证key是唯一的:
        作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一
 */
public class hashMapTest {
    public static void main(String[] args) {
        show02();
    }

    private static void show02() {
        //这个才需要重写自定义类的hashcode和equals方法
        /*
        HashMap存储自定义类型键值
        key:Person类型
            Person类就必须重写hashCode方法和equals方法,以保证key唯一
        value:String类型
            可以重复
     */
        //创建HashMap集合
        HashMap<Student,String> map=new HashMap<>();
        //往集合中添加元素
        map.put(new Student("张三",20),"北京");
        map.put(new Student("李四",22),"上海");
        map.put(new Student("王五",28),"东京");
        map.put(new Student("张三",20),"美国");

        //这里使用keySet加增强for遍历Map集合，也可以使用entry...
        Set<Student> set = map.keySet();
        for (Student key : set) {
            String value = map.get(key);
            System.out.println(key+"-->"+value);
            /*
            若没重写Student类的hashcode和equals则重复张三哦
            Student{name='王五', age=28}-->东京
            Student{name='张三', age=20}-->美国
            Student{name='李四', age=22}-->上海
            Student{name='张三', age=20}-->北京

            重写后：
            Student{name='张三', age=20}-->美国
            Student{name='李四', age=22}-->上海
            Student{name='王五', age=28}-->东京
             */
        }
    }

    private static void show01() {
        /*
        HashMap存储自定义类型键值
        key:String类型
            String类重写hashCode方法和equals方法（人家已经重写好了，我们不用重写）,可以保证key唯一
        value:Person类型(这里不用重写hashCode()和equals的)
            value可以重复(同名同年龄的人视为同一个)
        */

        //创建HashMap集合
        HashMap<String,Student> map=new HashMap<>();
        //往集合中添加元素
        map.put("北京",new Student("张三",20));
        map.put("上海",new Student("李四",22));
        map.put("东京",new Student("王五",28));
        map.put("北京",new Student("小胡",20));
        //这里只写入最后一个北京哦
        //这里使用keySet加增强for遍历Map集合，也可以使用entry...
        Set<String> set = map.keySet();
        for (String key : set) {
            Student value = map.get(key);
            System.out.println(key+"-->"+value);
            /*
            上海-->Student{name='李四2', age=22}
            东京-->Student{name='王五', age=28}
            北京-->Student{name='小胡', age=20}
             */
        }

    }
}

2.HashTable

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(null,"a");//NullPointerException
        //table.put("b",null);//NullPointerException
        table.put(null,null);//NullPointerException
    }
}