集合框架 第4天（Map集合概述，Map接口使用，HashMap使用，Hashtable和Properties，TreeMap使用，Collections工具类）

1. Map集合概述

• Interface Map
  • Class HashMap
  • Interface SortedMap
    • Class TreeMap
• Map接口的特点：
  • 用于存储任意键值对（Key-Value）
  • 键：无序、无下标、不允许重复（唯一）
  • 值：无序、无下标、允许重复
• 方法：
  • V put(K key, V value)：将对象存入到集合中，关联键值。key重复则覆盖原值
  • Object get(Object key)：根据键获取对应的值
  • Set< K >：返回所有Key
  • Collection< V > values()：返回包含所有值的Collection集合
  • Set< Map.Entry<K, V> >：键值匹配的Set集合

2. Map接口使用

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

public class Test {
    public static void main(String[] args) {
        // 创建Map集合
        Map<String, String> map = new HashMap<>();

        // 添加元素
        map.put("ABC", "abc");
        map.put("DEF", "def");
        map.put("GHI", "ghi");
        System.out.println(map);
        System.out.println(map.size());

        // 删除元素
        map.remove("GHI");
        System.out.println(map);

        // 遍历
        // 使用keySet()
        Set<String> set1 = map.keySet();
        for (String str : set1) {
            System.out.println(str + ":" + map.get(str));
        }

        // 使用entrySet()
        Set<Map.Entry<String, String>> set2 = map.entrySet();
        for (Map.Entry<String, String> entry : set2) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

        // 判断
        System.out.println(map.containsKey("ABC"));
        System.out.println(map.containsValue("abc"));
        System.out.println(map.isEmpty());
    }
}

3. HashMap使用

• JDK1.2版本，线程不安全，运行效率快；允许用null作为key或是value

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        HashMap<Student, String> students = new HashMap<>();

        // 添加元素
        Student student1 = new Student("A", 10);
        Student student2 = new Student("B", 20);
        Student student3 = new Student("C", 30);
        students.put(student1, "a");
        students.put(student2, "b");
        students.put(student3, "c");
        students.put(new Student("B", 20), "d");
        System.out.println(students);
        System.out.println(students.size());

        // 删除元素
        students.remove(student3);
        System.out.println(students);

        // 遍历
        // 使用keySet
        for (Student stu : students.keySet()) {
            System.out.println(stu + ":" + students.get(stu));
        }

        // 使用entrySet
        for (Map.Entry<Student, String> entry : students.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }
}

class Student {
    String name;
    int age;

    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 instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

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

4. Hashtable和Properties

• Hashtable：
  • JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value
• Properties：
  • Hashtable的子类，要求key和value都是String，通常用于配置文件的读取

5. TreeMap使用

• 实现了SortedMap接口（是Map的子接口），可以对key自动排序

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        TreeMap<Student, String> students = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num1 = o1.name.compareTo(o2.name);
                int num2 = o1.age - o2.age;
                System.out.println("123");
                return num2 == 0 ? num1 : num2;
            }
        });

        // 添加元素
        Student student1 = new Student("A", 10);
        Student student2 = new Student("B", 20);
        Student student3 = new Student("C", 30);
        students.put(student1, "a");
        students.put(student2, "b");
        students.put(student3, "c");
        students.put(new Student("B", 20), "d");
        System.out.println(students);
        System.out.println(students.size());

        // 删除元素
        students.remove(student3);
        System.out.println(students);

        // 遍历
        // 使用keySet
        for (Student stu : students.keySet()) {
            System.out.println(stu + ":" + students.get(stu));
        }

        // 使用entrySet
        for (Map.Entry<Student, String> entry : students.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }
}

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

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public int compareTo(Student o) {
        int num1 = this.name.compareTo(o.name);
        int num2 = this.age - o.age;
        System.out.println("abc");
        return num1 == 0 ? num2 : num1;
    }
}

6. Collections工具类

• 概念：集合工具类，定义了除了存取以外的集合常用方法
• 方法：
  • public static void reverse(List< ? > list)：反转集合中元素的顺序
  • public static void shuffle(List< ? > list)：随机重置集合元素的顺序
  • public static void sort(List< T > list)：升序排序（元素类型必须实现Comparable接口）

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();
        list1.add(20);
        list1.add(10);
        list1.add(30);
        list1.add(40);
        System.out.println(list1);

        // sort:从小到大排序
        Collections.sort(list1);
        System.out.println(list1);

        // binarySearch:二分查找
        System.out.println(Collections.binarySearch(list1, 30));

        // copy:复制
        List<Integer> list2 = new ArrayList<>();
        for (int i = 0; i < list1.size(); i++) {
            list2.add(i);
        }
        Collections.copy(list2, list1);
        System.out.println(list2);

        // reverse:反转
        Collections.reverse(list1);
        System.out.println(list1);

        // shuffle:随机排序
        Collections.shuffle(list1);
        System.out.println(list1);

        // list转换成数组
        Integer[] arr = list1.toArray(new Integer[10]);
        System.out.println(Arrays.toString(arr));
        System.out.println(arr.length);

        // 数组转换成集合，转换成的集合是一个受限集合，无法添加或删除
        String[] names = {"ABC", "DEF", "GHI"};
        List<String> list3 = Arrays.asList(names);
        System.out.println(list3);

        // 基本类型数组转换成集合是需要修改成包装类
        Integer[] nums = {10, 20, 30, 40};
        List<Integer> list4 = Arrays.asList(nums);
        System.out.println(list4);

    }
}