Java学习总结--036Map集合+HashMap和Hashtable的区别+Collections(集合工具类)

1.Map集合概述和特点

Java 为了我们更加方便的去操作，这种键值映射关系的数据，给我们提供了另外一种集合叫做Map集合。
Map<K,V>将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
HashMap, Hashtable, LinkedHashMap TreeMap Properties,

A.需求: 根据学号获取学生姓名

public class MyTest {
    public static void main(String[] args) {
        //我们有学生  有可能会有重名学生
        //  key         value  像这种键值映射关系的数据，在生活中经常键
        //  s001--------张三
        //  s002---------李四
        //  s003---------王五
        ArrayList<String> list = new ArrayList<>();
        list.add("s001--------张三");
        list.add("s002---------李四");
        list.add("s003---------王五");
        //取出 s003   王五
        String s = list.get(2);
        String[] split = s.split("\\-+");
        System.out.println(split[0]);
        System.out.println(split[1]);
        //Java 为了我们更加方便的去操作，这种键值映射关系的数据，给我们提供了另外一种集合叫做Map集合
        //Map<K,V>将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
       // HashMap, Hashtable, LinkedHashMap TreeMap    Properties,
    }
}

B.Map接口概述
将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值

C:Map接口和Collection接口的不同
Map是双列的,Collection是单列的;
Map的键唯一,Collection的子体系Set是唯一的;
Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效;

public class MyTest4 {
    public static void main(String[] args) {
        //   //双列集合，所有的数据结构,只跟键有关，跟值没关系
        //存 键是 Student 值是String
        HashMap<Student, String> hashMap = new HashMap<>();
        hashMap.put(new Student("张三0", 23), "s001");
        hashMap.put(new Student("张三0", 23), "s001");
        hashMap.put(new Student("张三1", 23), "s002");
        hashMap.put(new Student("张三2", 23), "s003");
        hashMap.put(new Student("张三3", 23), "s004");
        hashMap.put(new Student("张三4", 23), "s005");
        System.out.println(hashMap);
    }
}

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

2.Map集合的功能概述

a:添加功能
V put(K key,V value):添加元素。这个其实还有另一个功能?替换
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
b:删除功能
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回
c:判断功能
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
d:获取功能
Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
V get(Object key):根据键获取值
Set keySet():获取集合中所有键的集合
Collection values():获取集合中所有值的集合
e:长度功能
int size()：返回集合中的键值对的对数

3.Map集合的遍历之键找值

键找值思路：
获取所有键的集合;
遍历键的集合，获取到每一个键;
根据键找值;

public class MyTest {
    public static void main(String[] args) {
        TreeMap<Student, String> treeMap = new TreeMap<>();
        treeMap.put(new Student("张三0", 23), "111");
        treeMap.put(new Student("张三0", 23), "222");
        treeMap.put(new Student("张三0", 23333), "222");
        treeMap.put(new Student("张三1", 24), "444");
        treeMap.put(new Student("张三2", 26), "555");
        treeMap.put(new Student("张三3", 25), "666");
        treeMap.put(new Student("张三4", 28), "777");

        Set<Map.Entry<Student, String>> entries = treeMap.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"==="+value);
        }
    }
}

public class Student implements Comparable<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 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);
    }
    @Override
    public int compareTo(Student o) {
        int num=this.age-o.age;
        int num2=num==0?this.name.compareTo(o.name):num;
        return num2;
    }
}

4.Map集合的遍历之键值对对象找键和值

键值对对象找键和值思路：
获取所有键值对对象的集合
遍历键值对对象的集合，获取到每一个键值对对象
根据键值对对象找键和值

public class MyTest2 {
    public static void main(String[] args) {
        TreeMap<Student, String> treeMap = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge()-s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return -num2;
            }
        });
        treeMap.put(new Student("张三0", 23), "111");
        treeMap.put(new Student("张三0", 23), "222");
        treeMap.put(new Student("张三0", 23333), "222");
        treeMap.put(new Student("张三1", 24), "444");
        treeMap.put(new Student("张三2", 26), "555");
        treeMap.put(new Student("张三3", 25), "666");
        treeMap.put(new Student("张三4", 28), "777");
    }
}

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

5.Map集合遍历的两种方式比较

Map集合遍历的两种方式比较

public class MyTest3 {
    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1, "bbb");
        hashMap.put(2, "ccc");
        hashMap.put(3, "ddd");
        hashMap.put(4, "eee");
        hashMap.put(5, "fff");
        //遍历map集合的方式1  键找值
        Set<Integer> integers = hashMap.keySet();
        // String s = hashMap.get(1); //键找值
        for (Integer key : integers) {
            System.out.println(key + "===" + hashMap.get(key));
        }
    }
}

6.HashMap集合键是Stirng值是String的案例

HashMap 允许插入null键 null值
案例演示: HashMap集合键是Stirng值是String的案例

public class MyTest {
    public static void main(String[] args) {
        HashMap 此实现不是同步的。线程不安效率高
        //基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，
        //并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）
        // Hashtable 不允许使用null值null键，线程安全效率低
        //HashMap<String, String> map = new HashMap<>();
        //map.put(null,null);
        Hashtable<String, String> hashtable = new Hashtable<>();
        //hashtable.put(null,"abc");
        //hashtable.put("abc",null);
        //hashtable.put(null,null);
    }
}

7.LinkedHashMap的概述和使用

A:LinkedHashMap的概述: Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序;
B:LinkedHashMap的特点： 底层的数据结构是链表和哈希表 元素有序 并且唯一;
元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证;
Map集合的数据结构只和键有关;

8.TreeMap集合键是String值是String的案例

TreeMap 键不允许插入null;
TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性 ;
排序分为自然排序和比较器排序 ;
线程是不安全的效率比较高;

9.HashMap集合键是String值是Student的案例

public class MyTest2 {
    public static void main(String[] args) {
        TreeMap<Student, String> treeMap = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge()-s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return -num2;
            }
        });
        treeMap.put(new Student("张三0", 23), "111");
        treeMap.put(new Student("张三0", 23), "222");
        treeMap.put(new Student("张三0", 23333), "222");
        treeMap.put(new Student("张三1", 24), "444");
        treeMap.put(new Student("张三2", 26), "555");
        treeMap.put(new Student("张三3", 25), "666");
        treeMap.put(new Student("张三4", 28), "777");
    }
}

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

10.统计字符串中每个字符出现的次数

案例演示: 需求：统计字符串中每个字符出现的次数
“aababcabcdabcde”,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

public class MyTest {
    public static void main(String[] args) {
        //A:
        //案例演示:
        //需求：统计字符串中每个字符出现的次数
        //"aababcabcdabcde", 获取字符串中每一个字母出现的次数要求结果:a(5) b(4) c(3) d(2) e(1)

        // "aababcabcdabcde"
        //  "a(5) b(4) c(3) d(2) e(1)"
        // 我们观察发现 a---5
        //   b---4
        //c----3
        // d---2
        // e----1
        //他是一种键值映射关系的数据
        //那我就可以想到双列集合存起来
        //然后遍历集合，拼串
        //难点就是怎么统计字符出现的个数，以及把这个键值对应关系的数据存到集合中
        HashMap<Character, Integer> hashMap = new HashMap<>();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一段字符串");
        String str = sc.nextLine();
        //遍历字符串
        // char[] chars = str.toCharArray();
        //"aababcabcdabcde";
        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            if (!hashMap.containsKey(ch)) {
                hashMap.put(ch, 1);
            } else {
                //取出旧值
                Integer integer = hashMap.get(ch);
                integer++;
                hashMap.put(ch, integer);//键相同值覆盖
            }
        }
        //遍历集合，拼串
        StringBuilder sb = new StringBuilder();
        Set<Map.Entry<Character, Integer>> entries = hashMap.entrySet();
        for (Map.Entry<Character, Integer> entry : entries) {
            sb.append(entry.getKey()).append("(").append(entry.getValue()).append(")");
        }
        String s = sb.toString();
        System.out.println(s);
    }
}

11.集合嵌套之HashMap嵌套HashMap

public class MyTest {
    public static void main(String[] args) {
      /* 基础班
            张三 20
            李四 22
        就业班
            王五 21
            赵六 23

            */
        //HashMap 嵌套 HashMap
        HashMap<String, Integer> jc = new HashMap<>();
        jc.put("张三", 20);
        jc.put("李四", 22);

        HashMap<String, Integer> jy = new HashMap<>();
        jy.put("王五", 21);
        jy.put("赵六", 23);

        HashMap<String, HashMap<String, Integer>> maxMap = new HashMap<String, HashMap<String, Integer>>();
        maxMap.put("基础班", jc);
        maxMap.put("就业班", jy);

        //遍历集合
        Set<String> keySet = maxMap.keySet();
        for (String s : keySet) {
            System.out.println(s);
            HashMap<String, Integer> minMap = maxMap.get(s);
            Set<String> minKey = minMap.keySet();
            for (String s1 : minKey) {
                System.out.println("\t" + s1 + "\t" + minMap.get(s1));
            }
            System.out.println();
        }
        System.out.println("------------------------");
        Set<Map.Entry<String, HashMap<String, Integer>>> entries = maxMap.entrySet();
        for (Map.Entry<String, HashMap<String, Integer>> en : entries) {
            String key = en.getKey();
            System.out.println(key);
            HashMap<String, Integer> minMap = en.getValue();
            Set<Map.Entry<String, Integer>> entries1 = minMap.entrySet();
            for (Map.Entry<String, Integer> stringIntegerEntry : entries1) {
                String key1 = stringIntegerEntry.getKey();
                Integer value = stringIntegerEntry.getValue();
                System.out.println("\t"+key1+"  "+value);
            }
            System.out.println();
        }
    }
}

12.集合嵌套之HashMap嵌套ArrayList

public class MyTest2 {
    public static void main(String[] args) {

        /**
         *
         三国演义
            吕布
            周瑜
         笑傲江湖
            令狐冲
            林平之
         神雕侠侣
            郭靖
            杨过
         */
        //  HashMap 嵌套 ArrayList
        ArrayList<String> sgList = new ArrayList<>();
        sgList.add("吕布");
        sgList.add("周瑜");
        ArrayList<String> xaList = new ArrayList<>();
        xaList.add("令狐冲");
        xaList.add("林平之");

        ArrayList<String> sdList = new ArrayList<>();
        sdList.add("郭靖");
        sdList.add("杨过");
        sdList.add("尹志平");

        LinkedHashMap<String, ArrayList<String>> maxMap = new LinkedHashMap<>();
        maxMap.put("三国演义", sgList);
        maxMap.put("笑傲江湖", xaList);
        maxMap.put("神雕侠侣", sdList);
        //遍历
        /**
         *
         三国演义
             吕布
             周瑜
         笑傲江湖
             令狐冲
             林平之
         神雕侠侣
             郭靖
             杨过
         */
        Set<String> keySet = maxMap.keySet();
        for (String key : keySet) {
            System.out.println(key);
            ArrayList<String> list = maxMap.get(key);
            for (String s : list) {
                System.out.println("\t"+s);
            }
            System.out.println();
        }
    }
}

13.集合嵌套之ArrayList嵌套HashMap

public class MyTest3 {
    public static void main(String[] args) {
        //周瑜-- - 小乔
        //吕布-- - 貂蝉
        //
        //郭靖-- - 黄蓉
        //杨过-- - 小龙女
        //
        //令狐冲-- - 任盈盈
        //林平之-- - 岳灵珊

        //ArrayList 嵌套 HashMap
        HashMap<String, String> sgMap = new HashMap<>();
        sgMap.put("周瑜", "小乔");
        sgMap.put("吕布", "貂蝉");

        HashMap<String, String> sdMap = new HashMap<>();
        sdMap.put("郭靖", "黄蓉");
        sdMap.put("杨过", "小龙女");

        HashMap<String, String> xaMap = new HashMap<>();
        xaMap.put("令狐冲", "任盈盈");
        xaMap.put("林平之", "岳灵珊");

        ArrayList<HashMap<String, String>> maxList = new ArrayList<>();
        maxList.add(sgMap);
        maxList.add(sdMap);
        maxList.add(xaMap);
        for (HashMap<String, String> map : maxList) {
            Set<Map.Entry<String, String>> entries = map.entrySet();
            for (Map.Entry<String, String> entry : entries) {
                String key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key + "-----" + value);
            }
            System.out.println();
        }
    }
}

14.HashMap和Hashtable的区别

HashMap和Hashtable的区别: 查看API可以知道
HashMap: 线程不安全,效率高.允许null值和null键
Hashtable: 线程安全 , 效率低.不允许null值和null键

public class MyTest {
    public static void main(String[] args) {
        HashMap 此实现不是同步的。线程不安效率高
        //基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，
        //并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）
        //        Hashtable 不允许使用null值null键，线程安全效率低
        //HashMap<String, String> map = new HashMap<>();
        //map.put(null,null);
        Hashtable<String, String> hashtable = new Hashtable<>();
        //hashtable.put(null,"abc");
        //hashtable.put("abc",null);
        //hashtable.put(null,null);
    }
}

15.Collections工具类的概述和常见方法讲解

A:Collections类概述: 针对集合操作 的工具类
B:Collections成员方法
public static void sort(List list): 排序,默认按照自然顺序
public static int binarySearch(List<?> list,T key): 二分查找
public static T max(Collection<?> coll): 获取最大值
public static void reverse(List<?> list): 反转
public static void shuffle(List<?> list): 随机置换

public class MyTest2 {
    public static void main(String[] args) {
        // Collection Set List
        // A:
        // Collections类概述:
        // 针对集合操作 的工具类
        // B:
        // Collections成员方法
        // public static <T > void sort (List < T > list):排序, 默认按照自然顺序
        // public static <T > int binarySearch (List < ? > list, T key):二分查找
        // public static <T > T max(Collection < ? > coll):获取最大值
        // public static void reverse (List < ? > list):反转
        // public static void shuffle (List < ? > list):随机置换

        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(1002);
        list.add(1030);
        list.add(1050);
        list.add(100);
        //list.sort();

        Collections.sort(list);
        //Collections.sort(list, new Comparator<Integer>() {
        //    @Override
        //    public int compare(Integer o1, Integer o2) {
        //        return 0;
        //    }
        //});
        //System.out.println(list);
        int i = Collections.binarySearch(list, 1050);
        System.out.println(i);

        System.out.println(Collections.max(list));
        System.out.println(Collections.min(list));
        Collections.reverse(list);//反转集合中的元素
        System.out.println(list);

        Collections.shuffle(list);//随机打乱集合中元素的顺序
        System.out.println(list);
    }
}