Map集合

单列集合，一次只能添加一个元素
有的是有索引，有的没有索引
有的集合可以存储重复的元素，有的则不可以
有的元素是无序的，有的是有序的

Map集合是双列集合，由Key和Value组成
Key是不允许重复的，Value是允许重复
Key允许存null值的，但是只能存储唯一的一个

public class MapDemo {
    public static void main(String[] args) {
        //创建 map对象
        HashMap  map = new HashMap();

        //添加元素到集合
        map.put("唐三", "小舞");
        map.put("戴沐白", "朱竹清");
        map.put("奥奇卡", "宁荣荣");
        System.out.println(map);

        //String remove(String key)
        System.out.println(map.remove("奥斯卡"));
        System.out.println(map);

        // 想要查看 谁是谁的对象
        System.out.println(map.get("唐三"));
        System.out.println(map.get("戴沐白")); 
        System.out.println(map.get("马红俊"));//找不到返回null
    }
}

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

public class MapDemo01 {
    public static void main(String[] args) {
        //创建Map集合对象 
        HashMap map = new HashMap();
        //添加元素到集合 
        map.put("唐三", "小舞");
        map.put("戴沐白", "朱竹清");
        map.put("奥奇卡", "宁荣荣");
        //获取所有的键  获取键集
        Set keys = map.keySet();
        // 遍历键集 得到 每一个键
        for (String key : keys) {
            //key  就是键
            //获取对应值
            String value = map.get(key);
            System.out.println(key+"的CP是："+value);
        }  
    }
}

public Set

System.out.println("---------通过iterator-------------");
  Iterator

每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
需要： 学生姓名相同并且年龄相同视为同一名学生。

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

    public Student() {    }
    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(Ob服务器托管网ject 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 class HashMapTest {
    public static void main(String[] args) {
        //1,创建Hashmap集合对象。
        Mapmap = new HashMap();
        //Mapmap2=new HashMap();
        //2,添加元素。
        map.put(newStudent("lisi",28), "上海");
        map.put(newStudent("wangwu",22), "北京");
        map.put(newStudent("zhaoliu",24), "成都");
        map.put(newStudent("zhouqi",25), "广州");
        map.put(newStudent("wangwu",22), "南京");        
        //3,取出元素。键找值方式
        SetkeySet = map.keySet();
        for(Student key: keySet){
            String value = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }
    }
}

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap map = new LinkedHashMap();
       map.put("唐三", "小舞");
        map.put("戴沐白", "朱竹清");
        map.put("奥奇卡", "宁荣荣");
        Set> entrySet = map.entrySet();
        for (Entry entry : entrySet) {
            System.out.println(entry.getKey() + "  " + entry.getValue());
        }
    }
}

public static void main(String[] args) {
        // 创建集合对象 会对key进行排序，并且唯一
        TreeMap tm = new TreeMap();
        // 创建元素并添加元素
        tm.put("a", "你好");
        tm.put("c", "世界");
        tm.put("e", "爪哇");
        tm.put("b", "世界2");
        tm.put("e", "爪哇EE");
        // 遍历集合
        Set set = tm.keySet();
        for (String key : set) {
            String value = tm.get(key);
            System.out.println(key + "---" + value);
        }
    }

/*
HashMap和Hashtable是Java中两种常用的哈希表实现，它们在功能和使用上有一些区别。
1. 线程安全性：
   - HashMap是非线程安全的，不保证在多线程环境下的正确性。
   - Hashtable是线程安全的，通过使用同步方法来确保线程安全。

2. 空值(null)的处理：
   - HashMap允许使用null作为键(key)和值(value)，即可以存储null键和null值。
   - Hashtable不允许使用null作为键和值，如果尝试存储null，则会抛出NullPointerException。

3. 继承和实现关系：
   - HashMap是Hashtable的轻量级实现，实现了Map接口，不是线程安全的。
   - Hashtable是Dictionary类的子类，实现了Map接口，并且是线程安全的。

4. 性能：
   - HashMap因为不需要进行线程安全的同步处理，通常比Hashtable的性能更好。
   - Hashtable在多线程环境下具有额外的开销，可能对性能产生负面影响。

总体来说，如果你在单线程环境下使用哈希表，并且可能需要处理空值，推荐使用HashMap。而如果在多线程环境下使用哈希表，或者需要线程安全性，可以选择Hashtable。
 */
public class HashtableDemo {
    public static void main(String[] args) {
        // HashMap hm = new HashMap();
        Hashtable hm = new Hashtable();

        hm.put("it001", "hello");
        // hm.put(null, "world"); //NullPointerException
        // hm.put("java", null); // NullPointerException

        System.out.println(hm);
    }
}