Java Map接口

Map 接口

 1. 以键值对形式保存数据
        key --- value
 2. 键保持唯一

HashSet和HashMap之间的关系

底层都是使用哈希算法

HashSet底层依赖HashMap来实现

    Map的添加方法

    HashMap<String, Integer> map = new HashMap<>();
        Integer i1 = map.put("张三", 19);
        Integer i2 = map.put("李四", 13);
        Integer i3 = map.put("王五", 12);
        Integer i4 = map.put("赵六", 13);
        Integer i5 = map.put("赵六", 33);
        // 赵六的13 被 33 覆盖了
        // put返回的是 被覆盖的值
        // 没被覆盖就返回null
        System.out.println(map);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);

---

    HashMap<String, Integer> map = new HashMap<>();
        map.put("张三", 19);
        map.put("李四", 13);
        map.put("王五", 12);
        map.put("赵六", 13);

    // 是否包含key
        boolean key = map.containsKey("李四");
        System.out.println(key);

    // 是否包含value
        boolean value = map.containsValue(13);
        System.out.println(value)

    // 获取所有key的set
        Set<String> keySet = map.keySet();
        System.out.println(keySet);

    // 获取所有value的集合
        Collection<Integer> values = map.values();
        System.out.println(values);

    // 通过key删除整个键值对
        Integer value = map.remove("张四");
        System.out.println(value);

    // 清空map
        map.clear();

---

Student 类:
public class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        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 int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "[ 姓名 : " + name + " , 年龄 : " + age + " ]";
    }

    @Override
    public int compareTo(Student o) {
        int num = this.age - o.getAge();
        return num == 0 ? 1 : num;
    }

}

    // 创建一个map key保存学生 value保存 户籍
        HashMap<Student, String> map = new HashMap<>();
        map.put(new Student("张三", 13), "江苏");
        map.put(new Student("李四", 18), "河南");
        map.put(new Student("王五", 17), "安徽");
        // 重写之后 key相同 value会被新值覆盖
        map.put(new Student("李四", 18), "河北");
        // 重写 HashCode 和 Equals
        System.out.println(map);

Map的遍历

keySet

迭代器遍历
    // 遍历map
        HashMap<String, Integer> map = new HashMap<>();
        map.put("张三", 19);
        map.put("李四", 13);
        map.put("王五", 12);
        map.put("赵六", 13);
        // 通过keySet遍历
        // 取出所有key的Set集合
        Set<String> keySet = map.keySet();
        Iterator<String> iterator = keySet.iterator();
        // 遍历所有key
        while (iterator.hasNext()) {
            String key = iterator.next();
            Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }

增强for循环遍历
    // 遍历map
        HashMap<String, Integer> map = new HashMap<>();
        map.put("张三", 19);
        map.put("李四", 13);
        map.put("王五", 12);
        map.put("赵六", 13);
        // 增强for循环
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }

entrySet

迭代器遍历
    // 遍历map
        HashMap<String, Integer> map = new HashMap<>();
        map.put("张三", 19);
        map.put("李四", 13);
        map.put("王五", 12);
        map.put("赵六", 13);
        // 通过获取 键值对 对象 的set集合 来遍历
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        // 获取迭代器
        Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            // 获取Entry对象
            Entry<String, Integer> entry = iterator.next();
            // 获取key
            String key = entry.getKey();
            // 获取value
            Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }

快速遍历
    // 遍历map
        HashMap<String, Integer> map = new HashMap<>();
        map.put("张三", 19);
        map.put("李四", 13);
        map.put("王五", 12);
        map.put("赵六", 13);
        // 增强for循环 entry遍历
        for (Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }

LinkedHashMap

特点: 有序存入 有序取出

    // 创建一个TreeMap key保存学生 value保存户籍
    // 按年龄排序
        TreeMap<Student, String> map = new TreeMap<>();
        map.put(new Student("张三", 19), "安徽");
        map.put(new Student("李四", 16), "江苏");
        map.put(new Student("王五", 17), "浙江");
        map.put(new Student("赵六", 12), "湖南");
        System.out.println(map);

    { 姓名: 赵六 年龄: 12  湖南,  姓名: 李四 年龄: 16  江苏,  姓名: 王五 年龄: 17  浙江,  姓名: 张三 年龄: 19  安徽}

    // Collections类中方法(静态方法)
        ArrayList<Integer> list = new ArrayList<>();
        list.add(14);
        list.add(11);
        list.add(12);
        list.add(13);
        // 随机交换集合中值的位置(洗牌)
        /*
        Collections.shuffle(list);
        System.out.println(list);
        */
        // 排序
        Collections.sort(list);
        System.out.println(list);

        // 二分查找
        int binarySearch = Collections.binarySearch(list, 13);
        System.out.println(binarySearch);
        // 反转集合
        Collections.reverse(list);
        System.out.println(list);

        // 排序
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("张三", 11));
        list.add(new Student("李四", 13));
        list.add(new Student("王五", 12));
        // 排序 实现 compareable接口 只要排的是对象 都需要编写排序规则
        Collections.sort(list);
        System.out.println(list);

        [ 姓名: 张三 年龄: 11,  姓名: 王五 年龄: 12,  姓名: 李四 年龄: 13]

---

---

  ArrayList    数组实现 线程不安全  查询快 增删慢
  LinkedList   链表实现 线程不安全  查询慢 增删快
  Vector       数组实现 线程安全  被ArrayList替代

  HashSet           哈希算法  线程不安全  作用去重
  LinkedHashSet     线程不安全 特点: 有序(怎么存怎么取)
  TreeSet           线程不安全 作用:排序(两种方法)

  HashMap           线程不安全 作用: 键位可以去重
  LinkedHashMap     线程不安全 特点: 有序(怎么存怎么取)    
  TreeMap           线程安全 被HashMap取代 不能保存null值