Map顶级接口，File类

1.接口概述

package 异常机制.异常处理;

import java.util.Scanner;

public class Test2 {
//    throw和throws区别:！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！精髓，记住！
//    相同点：
//    他俩都可以进行异常的抛出
//    不同点：
//    throws是用在方法声明后面，throw是用在方法内部抛出异常
//    throws可以跟多个异常类名，用逗号隔开，throw只能抛出一个异常对象名
//    throws表示抛出异常，由该方法的调用者来处理，throw表示抛出异常，由其在的方法体内的语句来处理(一般就是在构造方法里面输点跟异常类有关的语句)
//    throws表示出现异常的一种可能性，并不一定会出现这些异常。throw则是抛出了异常，执行了throw表示一定出现了异常
//    当然throw和throws可以同时用,即使throw和throws抛出的异常完全一样都可以
//    例如：
public static void main(String[] args)/*throws ArithmeticException*/ {
    Scanner scanner = new Scanner(System.in);
    int i = scanner.nextInt();
    int i1 = scanner.nextInt();
    int r=test(i,i1);
}

    private static int test(int i, int i1) /*throws ArithmeticException*/{//方法上可以直接用throws抛异常，当然，如果你愿意，你可以在任何方法上抛任何异常，一般只在出现异常的工具类的方法上抛异常
        int aa=0;
        if(i1==0){
//            如果除数为0，直接就抛出异常
            throw  new ArithmeticException("分母为0了");//这里如果写有参构造的话，异常的那个红字里面就会把这个参数打印出来
//            这里经过判断之后主动抛出异常，让程序不在往下执行，其后果于throws一样
        }else {
           aa=i/i1;
        }
        return aa;
    }
}
//final 是修饰字符：修饰类不能被继承，修饰方法，方法能被继承但不能被重写，修饰常量时，常量不能被修改
//finally是try catch 的后备语句，当有善后工作要做时，就用finally，用fially时，不管异常有没有触发，finally都会执行其代码块儿
//finalize是Object类里面的一个方法,用于垃圾回收器的回收

//只要有return的地方,就会将其所在的方法结束掉,因此只要方法里面有个return,就去看其所在的方法,就知道这个方法结束了
//哪里看到虚拟机退出,后面的代码管你是return还是finally都不会在执行了
//当看到catch{
//            sout("asdsdsad");
//             return;
//             }
//              finally{
//            sout("123");
// }
//问:finally的语句会执行嘛?会,只要不是虚拟机退出,遇到这种情况,会先执行finally,在执行return,因为不管异常发没发生,都要执行finally,加了个return的话也得是这样,不然return完了没执行finally,矛盾了,所以会先执行finally,在return.

package Map顶级接口;

import java.util.HashMap;

public class Test1 {
    public static void main(String[] args) {
        HashMap<String, String> hm = new HashMap<>();
//        HashMap集合中的键存在于哈希表中，所以键是无序的，因为是根据你的hashcode的值再去算一个更小的值，导致了这个键（或set集合中的元素，这里说的是哈希表的原理，都是一样的原理）都是随机的存在哈希表中，就对应了无序了
        hm.put("文章","马伊利");//文章对应键，马伊利对应值，一个键对应一个值
        String put = hm.put("贾乃亮", "李小璐");//这里有返回值，返回值对应的是被替换之前的值，没有被替换过就返回null
        hm.put("王宝强","马蓉");
        String put2 = hm.put("武大郎", "潘金莲");
        String put1 = hm.put("武大郎", "姚笛");//键相同，值不同，新值会覆盖旧值，且返回的是之前对应的旧值，如果没有旧值，就返回null。
//        双列集合的底层数据结构，只跟键有关，跟Set集合中的一样，这里就把set集合中的元素换成了键，根据你的键去算一个hashCode，然后根据hashCode在去算一个更小的值，这个值就是存在哈希表中的数组中的索引，所以键的存储方式也是无序的，当然对应的值也是无序的了。如果键相同的话，值不同会覆盖原来的值，要是值也相同，就不会在存这个元素（跟Colection集合中的Set集合的HashSet一样，值相同就不会存这个值了），还是之前的那个元素，当然之前的那个元素对应的返回值还是null（值没有被替换过）或被替换前的那个元素值（值被替换了）
        System.out.println(hm);
    }
}

package Map顶级接口;

import Object类.equals方法.Studen;

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

//记住，只要重写了equals方法，equals相同的，hashcode一定相同，记住就行了，没重写的就不行，还是父类的比较地址
public class Test2 {
    public static void main(String[] args) {
        HashMap<String, Student> stringStudentHashMap = new HashMap<>();
        stringStudentHashMap.put("s001",new Student(23,"zhangsan"));
        stringStudentHashMap.put("s002",new Student(24,"lisi"));
        stringStudentHashMap.put("s003",new Student(25,"wangwu"));
        stringStudentHashMap.put("s004",new Student(26,"dsdasfsf")) ;
        stringStudentHashMap.put("s004",new Student(27,"dsdadasdsdsdassfsf")) ;//键相同值不相同时，新值覆盖旧值，注意逗号左边的是键，逗号右边的是值，这里的键对应的就是Set集合里面的元素，这俩都具有唯一性
        System.out.println(stringStudentHashMap);
//        =========================================================================================
        System.out.println("=========================================================");
//        键是Student类型，值是String类型
        HashMap<Student, String> studenStringHashMap = new HashMap<>();
//        键唯一
//        双列集合的数据结构只跟键有关
//        HashMap键的数据结构是哈希表，你要保证键唯一，要求键重写hashCode和equals方法
      studenStringHashMap.put(new Student(23,"zhangsan"),"s001");
      studenStringHashMap.put(new Student(23,"zhangsan"),"s006");
      studenStringHashMap.put(new Student(23,"zhangsan"),"s007");
      studenStringHashMap.put(new Student(23,"zhangsan"),"s008");
      studenStringHashMap.put(new Student(24,"lisi"),"s002");
      studenStringHashMap.put(new Student(25,"wangwu"),"s003");
      studenStringHashMap.put(new Student(26,"dsdasfsf"),"s004");
      studenStringHashMap.put(new Student(27,"dsdadasdsdsdassfsf"),"s005");
        System.out.println(studenStringHashMap);
//        HashSet底层是用的HashMap存的（之前HashSet中的源码已经分析过了），HashSet中的元素其实就是对应hashMap中的键，都具有唯一性
//        就是直接对应hashMap中的键，跟它后面处理方式一样一样的，就是hashMap中是键值对的方式存在，在键相同值不相同的时候，新值会覆盖旧值，且返回原来的键对应的旧值，除次之外，HashSet的元素和HashMap的键没啥别的处理区别
//        但是hashMap是以Node对象（类）（这个对象也叫做节点，就是链表中得一个单元）的形式存储其键和值的，也就是说，键和值都被封装到Node对象里面，然后在通过键算出最终的哈希表中的数组的索引，如果这个索引对应的是null，就将Node对象放在这个索引处，Node对象里面存着键和值，然后以此类推，如果有通过键算出来的索引对应相等的，和hashSet一样，也是对其进行比较，如果完全一样，注意是完全一样，即键跟值完全一样，就不替换，如果键一样，值不一样，就新值替换旧值
//        clear（）方法表示清空
//      stringStudentHashMap.clear();
//        根据键来删除一对儿键值对：
        Student s002 = stringStudentHashMap.remove("s002");//根据键将这一个键值对儿整体删掉，且返回值为删除的键对应的值
        boolean s005 = studenStringHashMap.remove("s005", new Object());//这种形式的是返回布尔类型，有这个元素删成功了就返回true，没删成功就返回false，且第二个参数为键所对应的值（如果是没有这个键的话，第二个参数固定写new Object就行了，就像这里一样），只有这样才能返回布尔类型
    }
}





















































 class Student {
    private int age;
    private  String name;

    public Student() {
    }

     @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(age, name);
     }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

2.接口的父类功能

package Map顶级接口;

import java.util.HashMap;

public class Test3 {
    public static void main(String[] args) {
        HashMap<Integer, String> integerStringHashMap = new HashMap<>();
        integerStringHashMap.put(100,"zhangsan");
        integerStringHashMap.put(200,"lisi");
        integerStringHashMap.put(300,"wangwu");
        integerStringHashMap.put(400,"zhaoliu");
//        判断集合中有没有400这个键
        boolean b = integerStringHashMap.containsKey(100);//查看集合中是否有100这个键，返回布尔类型
        boolean b1 = integerStringHashMap.containsKey(4000);
        boolean lisi = integerStringHashMap.containsValue("lisi");//查看集合中是否有lisi这个值，返回布尔类型

        boolean empty = integerStringHashMap.isEmpty();//判断集合是否为空
        integerStringHashMap.size();//获取功能
    }
}

package Map顶级接口;

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

public class Test4 {
    public static void main(String[] args) {
//        查看双列集合怎么遍历：
        HashMap<Integer, String> integerStringHashMap = new HashMap<>();
        integerStringHashMap.put(100,"zhangsan");
        integerStringHashMap.put(200,"lisi");
        integerStringHashMap.put(300,"wangwu");
        integerStringHashMap.put(400,"zhaoliu");
//        Map集合中有个get方法,可以通过获取键来返回值
//        方式一：通过键找值得方式去遍历
        Set<Integer> integers = integerStringHashMap.keySet();//通过这个方法获取所有键，将其放到Set集合中（无序不重复）
        System.out.println(integers);//无序不重复
        for (Integer integer : integers) {
//            键找值得方法：
            String s = integerStringHashMap.get(integer);//参数里面放键就行
            System.out.println(s);
        }
//        方式二：将全部得键值对儿对象（Node类）拿出来
        Set<Map.Entry<Integer, String>> entries = integerStringHashMap.entrySet();//返回得也是一个set集合，无序不重复。泛型里面为内部类(Entry<Integer, String>其实是个接口)，其实就是将这个内部接口作为一个泛型放到Set集合里面了，里面得元素必须是                         Entry<Integer, String>得，当然，这个泛型有点特殊，为内部接口类型，所以这个泛型所对应得类肯定是这个内部接口得实现类咯（类得内部得类还有一个泛型，这个就是集合得嵌套了，跟之前讲得一样）
        for (Map.Entry<Integer, String> entry : entries) {//entry就为泛型为内部类得实现类引用了,这里之所以这样写，运用得是多态得写法，且这样写没错的(父类引用指向子类对象)，源码中已经将每个Node对象都new过了，所以可以遍历（一个节点对应一个Node对象）
            // 从源码可以看到,Node类为其实现类
            String value = entry.getValue();//这里都是Node实现类重写得方法，运用的是多态，这个方法是拿到值
            Integer key = entry.getKey();//这个方法是拿到的键
            System.out.println(key+value);
        }
//方式三：用foreach去迭代也可，这种方式目前是最简单的方式：这种记住就行了，包括collection里面的那个foreach遍历方式，记住就行了，这个底层不知道是什么原理，但是增强for底层是迭代器迭代，迭代时不能改变集合长度，还有数组转换为集合的那个，转换完后的集合底层就是个普通的数组，没有add和remove功能，所以也不能改变最后的集合的长度。
        integerStringHashMap.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer key, String value) {
                System.out.println(key+value);
            }
        });

    }
}

package Map顶级接口;

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

public class Test5 {
    public static void main(String[] args) {
        HashMap<String, Student> stringStudentHashMap = new HashMap<>();
        stringStudentHashMap.put("s001", new Student(23, "zhangsan"));
        stringStudentHashMap.put("s002", new Student(24, "lisi"));
        stringStudentHashMap.put("s003", new Student(25, "wangwu"));
        stringStudentHashMap.put("s004", new Student(26, "dsdasfsf"));
        stringStudentHashMap.put("s004", new Student(27, "dsdadasdsdsdassfsf"));
//        第一种遍历方式：
        Set<String> strings = stringStudentHashMap.keySet();
        for (String string : strings) {
            Student student = stringStudentHashMap.get(string);
            System.out.println(student);
        }
//            第二种：第一种第二种无论哪种遍历方式都是先调方法，然后在直接新型for循环遍历
        Set<Map.Entry<String, Student>> entries = stringStudentHashMap.entrySet();
        for (Map.Entry<String, Student> entry : entries) {
            String key = entry.getKey();
            Student value = entry.getValue();
            System.out.println(key + value);
        }
//        第三种：
        stringStudentHashMap.forEach(new BiConsumer<String, Student>() {
            @Override
            public void accept(String key, Student value) {
                System.out.println(key + value);
            }
        });
//        =====================================================================
        HashMap<Student, String> studenStringHashMap = new HashMap<>();
        studenStringHashMap.put(new Student(23,"zhangsan"),"s001");
        studenStringHashMap.put(new Student(23,"zhangsan"),"s006");
        studenStringHashMap.put(new Student(23,"zhangsan"),"s007");
        studenStringHashMap.put(new Student(23,"zhangsan"),"s008");
        studenStringHashMap.put(new Student(24,"lisi"),"s002");
        studenStringHashMap.put(new Student(25,"wangwu"),"s003");
        studenStringHashMap.put(new Student(26,"dsdasfsf"),"s004");
        studenStringHashMap.put(new Student(27,"dsdadasdsdsdassfsf"),"s005");
        Set<Student> students = studenStringHashMap.keySet();//记住，不管键是什么类型，爱啥类型啥类型，它只要在Map集合里面，put方法的第一个参数就是key，当然，遍历的时候也是这么想，它就是个键，没任何特别之处
//        第一种遍历方式：
        for (Student student : students) {
            String s = studenStringHashMap.get(student);//对象类也是当键，没毛病
            System.out.println(student.getAge()+student.getName()+s);
        }
//        第二种
        Set<Map.Entry<Student, String>> entries1 = studenStringHashMap.entrySet();
        for (Map.Entry<Student, String> studentStringEntry : entries1) {
            Student key = studentStringEntry.getKey();//这里运用的时多态
            String value = studentStringEntry.getValue();//这里运用的时多态
            System.out.println(key+value);
        }
//        第三种：
        studenStringHashMap.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                System.out.println(student+s);
            }
        });
    }}

3.集合嵌套

package Map顶级接口;

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

public class Test6 {
    public static void main(String[] args) {
//        集合嵌套
        HashMap<Integer, String> foundationClass = new HashMap<>();
        String zhangsan = foundationClass.put(20, "zhangsan");//put方法直接返回键所对应的元素
        foundationClass.put(22, "lisi");//基础班
        HashMap<Integer,String> employmentClass = new HashMap<>();
        employmentClass.put(21, "wangwu");//就业班
        employmentClass.put(23, "zhaoliu");
        HashMap<String, HashMap<Integer, String>> JavaClass = new HashMap<>();//键为String类型,表明哪个班的,值为其共性的,注意:嵌套一定是抽取其共性的类当泛型
        JavaClass.put("就业班",employmentClass);
        JavaClass.put("基础班",foundationClass);
        Set<String> strings = JavaClass.keySet();
//        遍历方式一:
        for (String string : strings) {
            for (Integer integer : JavaClass.get(string).keySet()) {
                System.out.println(string);
                System.out.println(JavaClass.get(string).get(integer));
            }

        }
        System.out.println("=======================");
//        遍历方式二:
        Set<Map.Entry<String, HashMap<Integer, String>>> entries = JavaClass.entrySet();
        for (Map.Entry<String, HashMap<Integer, String>> entry : entries) {
            String key = entry.getKey();
            Set<Map.Entry<Integer, String>> entries1 = entry.getValue().entrySet();
            for (Map.Entry<Integer, String> integerStringEntry : entries1) {
                Integer key1 = integerStringEntry.getKey();
                String value = integerStringEntry.getValue();
                System.out.println(key+key1+value);
            }
        }
        System.out.println("========================");
//        遍历方式三:
        JavaClass.forEach(new BiConsumer<String, HashMap<Integer, String>>() {
            @Override
            public void accept(String s1, HashMap<Integer, String> integerStringHashMap) {
                integerStringHashMap.forEach(new BiConsumer<Integer, String>() {
                    @Override
                    public void accept(Integer integer, String s) {
                        System.out.println(s1);
                        System.out.println(integer+s);
                    }
                });
            }
        });
//        以上三种迭代方式,核心只有一个,谁有嵌套就扒谁,还有,记住,键值对这两个元素,可以存储任何类,任何值,无论是泛型,接口,抽象类,普通类,随意什么类都可以,不要老是固化思维,我这里说的是键和值都是这样,任意存储,哪怕是集合的嵌套,也是可以任意存储,随意存,谁嵌套了就扒谁,扒到最后一层能打印为止,或者扒到有一层重写了toString方法能输出就行.记住这个思路就行了,集合嵌套就没啥问题了
        Set<String> strings1 = JavaClass.keySet();
        for (String s : strings1) {
            Set<Integer> integers = JavaClass.get(s).keySet();
            for (Integer integer : integers) {
                System.out.println(JavaClass.get(s).get(integer));
            }
        }
        Set<Map.Entry<String, HashMap<Integer, String>>> entries1 = JavaClass.entrySet();
        for (Map.Entry<String, HashMap<Integer, String>> stringHashMapEntry : entries1) {
            String key = stringHashMapEntry.getKey();
            Set<Map.Entry<Integer, String>> entries2 = stringHashMapEntry.getValue().entrySet();
            for (Map.Entry<Integer, String> integerStringEntry : entries2) {
                Integer key1 = integerStringEntry.getKey();
                String value = integerStringEntry.getValue();
            }
        }
        JavaClass.forEach(new BiConsumer<String, HashMap<Integer, String>>() {
            @Override
            public void accept(String s1, HashMap<Integer, String> integerStringHashMap) {
                integerStringHashMap.forEach(new BiConsumer<Integer, String>() {
                    @Override
                    public void accept(Integer integer, String s) {
                        System.out.println(s1);
                        System.out.println(integer+s);
                    }
                });
            }
        });
    }
}

package Map顶级接口;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class Test7 {
    public static void main(String[] args) {
//        仍旧集合嵌套
//        Map集合套 List集合
        ArrayList<String> san = new ArrayList<>();
        san.add("吕布");
        san.add("周瑜");
        ArrayList<String> xiao = new ArrayList<>();
        xiao.add("令狐冲");
        xiao.add("林平之");
        ArrayList<String> shen = new ArrayList<>();
        shen.add("郭靖");
        shen.add("杨过");
        HashMap<String, ArrayList<String>> tv = new HashMap<>();//Map集合套list,原理一样的,嵌套的是以公共部分嵌套,将公共部分放到泛型里面
//        迭代的时候是找嵌套的扒,扒到最后一层为止
        tv.put("三国演义",san);
        tv.put("笑傲江湖",xiao);
        tv.put("神雕英雄传",shen);

//        方式一:
        Set<String> strings = tv.keySet();
        for (String string : strings) {
            for (String s : tv.get(string)) {
                System.out.println(string);
                System.out.println(s);
            }
        }
        System.out.println("=============================");
//        方式二:
        Set<Map.Entry<String, ArrayList<String>>> entries = tv.entrySet();
        for (Map.Entry<String, ArrayList<String>> entry : entries) {
            String key = entry.getKey();
            for (String s : entry.getValue()) {
                System.out.println(key);
                System.out.println(s);
            }
        } System.out.println("=============================");
//        方式三:
        tv.forEach(new BiConsumer<String, ArrayList<String>>() {
            @Override
            public void accept(String s1, ArrayList<String> strings) {
                strings.forEach(new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s1);
                        System.out.println(s);
                    }
                });
            }
        }); System.out.println("=============================");
//        方式四:
        tv.forEach(new BiConsumer<String, ArrayList<String>>() {
            @Override
            public void accept(String s1, ArrayList<String> strings) {
                Iterator<String> iterator = strings.iterator();
                while (iterator.hasNext()){
                    String next = iterator.next();
                    System.out.println(s1);
                    System.out.println(next);
                }
            }
        }); System.out.println("=============================");
//        方式五:增强for循环的时候别用这个迭代器迭代了,报异常
//        Set<String> strings1 = tv.keySet();
//        for (String s : strings1) {
//            Iterator<String> iterator = tv.get(strings1).iterator();
//            while (iterator.hasNext()){
//                String next = iterator.next();
//                System.out.println(s);
//                System.out.println(next);;
//            }
//        } System.out.println("=============================");
        System.out.println("=============================");
//        方式六:
        Set<Map.Entry<String, ArrayList<String>>> entries1 = tv.entrySet();
        for (Map.Entry<String, ArrayList<String>> stringArrayListEntry : entries1) {
            String key = stringArrayListEntry.getKey();
            stringArrayListEntry.getValue().forEach(new Consumer<String>() {
                @Override
                public void accept(String s) {
                    System.out.println(key);
                    System.out.println(s);
                }
            });
        } System.out.println("=============================");
//        方式七:
        Set<String> strings2 = tv.keySet();
        for (String s : strings2) {
            for (String s1 : tv.get(s)) {
                System.out.println(s);
                System.out.println(s1);
            }
        }
    }

}

package Map顶级接口;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class Test8 {
    public static void main(String[] args) {
//        单列表集合种嵌套双列表集合(List集合嵌套Map集合)
//        就记住了,填泛型的时候,是抽取公共得元素,迭代的时候,是扒公共的元素,记住这两点就没问题了
        HashMap<String, String> san = new HashMap<>();
        san.put("周瑜","小乔");
        san.put("吕布","貂蝉");
        HashMap<String, String> she = new HashMap<>();
        she.put("郭靖","黄蓉");
        she.put("杨过","小龙女");
        HashMap<String, String> shui = new HashMap<>();
        shui.put("令狐冲","任盈盈");
        shui.put("林平之","岳灵珊");
        ArrayList<HashMap<String, String>> hashMaps = new ArrayList<>();
        hashMaps.add(san);
        hashMaps.add(she);
        hashMaps.add(shui);
//        方式一:
        for (HashMap<String, String> hashMap : hashMaps) {//list集合扒完是个map集合,先用list集合的办法扒,扒完用map集合在扒到底
            Set<String> strings = hashMap.keySet();
            for (String string : strings) {
                String s = hashMap.get(string);
                System.out.println(string+"=="+"=="+s);
            }
        }
        System.out.println("=============================");
//  方式二:
        Iterator<HashMap<String, String>> iterator = hashMaps.iterator();
        while (iterator.hasNext()){
            HashMap<String, String> next = iterator.next();
            Set<Map.Entry<String, String>> entries = next.entrySet();
            for (Map.Entry<String, String> entry : entries) {
                String value = entry.getValue();
                String key = entry.getKey();
                System.out.println(key+"========"+value);
            }
        } System.out.println("=============================");
//        方式三:
        hashMaps.forEach(new Consumer<HashMap<String, String>>() {
            @Override
            public void accept(HashMap<String, String> stringStringHashMap) {
                stringStringHashMap.forEach(new BiConsumer<String, String>() {
                    @Override
                    public void accept(String s, String s2) {
                        System.out.println(s+"==="+s2);
                    }
                });
            }
        });
    }
    }
//还有记住了:只要sout输出的时候,输出的是一个或多个类的引用,那么不管你输入几个引用(不同引用间用加号连接),一定是输出的每个引用的toString方法

4.HashTable集合：

package Map顶级接口.HashTable;

import java.util.HashMap;
import java.util.Hashtable;

public class Test {
    public static void main(String[] args) {
//        hashMap 和hashTbale的区别:
//        其两个底层都是哈希表
//        hashMap  允许存null值和null键的 线程不安全的 效率高
//        hashTable 不允许存null值和null键的 线程安全的 效率低
        HashMap<Integer, String> integerStringHashMap = new HashMap<>();
        integerStringHashMap.put(null,null);
        Hashtable<Integer, String> integerStringHashtable = new Hashtable<>();
        integerStringHashtable.put(null,null);//这里虽然没报错,但是会报异常,键或值为null都不行,用null就报错

    }
}

5.LinkedHashMap

package Map顶级接口.LinkedHashMap实现类;



import java.util.HashMap;
import java.util.LinkedHashMap;

public class Test {
    public static void main(String[] args) {
//        HashMap的底层时哈希表,保证键唯一(键不重复),键无序,原理说过无数次了
//        LinkedHashMap底层是哈希表加链表,跟LinkedHashSet一样,链表保证了键有序,哈希表保证了键唯一(键不重复),记住就行
//        上面这些记住就行了
        LinkedHashMap<Integer, String> integerStringHashMap = new LinkedHashMap<>();//用这个集合一定是保证键有序且唯一
        integerStringHashMap.put(100,"zhangsan");
        integerStringHashMap.put(200,"lisi");
        integerStringHashMap.put(300,"wangwu");
        integerStringHashMap.put(400,"zhaoliu");
        System.out.println(integerStringHashMap);
    }
}

6.TreeMap

package Map顶级接口.TreeMap;

import java.util.Comparator;
import java.util.TreeMap;
import java.util.TreeSet;
//注意:treeSet和treeMap的放元素的方式并不是根据元素的hashcode的值去算的,而就只是单纯的根据元素的大小去放,当然要提前规定好元素大小的比较方式
//只有哈希表才是根据元素的hashcode去放元素
public class Test {
    public static void main(String[] args) {
//        TreeMap
//        键的数据结构是红黑树(二叉树),可保证键的排序和唯一性(对比TreeSet去理解,跟treeSet里面的元素原理一毛一样)
//        排序分为自然排序和比较器排序
//        线程不安全,效率高
//      (1)  要使用空参构造的话,需要对键的类,注意是键的类要实现Comprarble接口,重写CompareTo方法,对值无要求
        TreeMap<Integer, String> integerStringTreeMap = new TreeMap<>();
         integerStringTreeMap.put(20,"aaa");
         integerStringTreeMap.put(20,"aaa");
         integerStringTreeMap.put(4140,"aaa");
         integerStringTreeMap.put(13510,"aaa");
         integerStringTreeMap.put(4546450,"aaa");
         integerStringTreeMap.put(60,"aaa");
         integerStringTreeMap.put(70,"aaa");
         integerStringTreeMap.put(80,"aaa");
         integerStringTreeMap.put(90,"aaa");
         integerStringTreeMap.put(100,"aaa");//调用put方法就会对键排序,跟TreeSset调用add方法一样
        System.out.println(integerStringTreeMap);//Integer只能升序排,其Compareto方法没办法重写其方法
//        (2)  使用有参构造,用匿名内部类的方式可以重写Compareto方法,这两种当时暂时不知道原理,记住就行了
             new TreeMap<Student,String>(new Comparator<Student>() {
                 @Override
                 public int compare(Student o1, Student o2) {
                     int num = o1.getAge() - o2.getAge();
                     int num2=num==0?o1.getName().compareTo(o2.getName()):num;
                     return  num2;
                 }
             });
    }
}

7.测试题

package Map顶级接口.测试题;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
//        随便输入一段字符串，统计其所出现的次数：
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一段字符串");
        String s = scanner.nextLine();
//        可以用键值对儿去算,选用双列集合去充当容器

        HashMap<Character, Integer> characterIntegerHashMap = new HashMap<>();

//         难点在于怎么统计每个字符出现的个数：
//        遍历用户输入的字符串：
       /* for (int i = 0; i < s.length(); i++) {//字符串是多个字符组成的序列
                                               //字符串可以看作是字符数组,其就是一个数组
                                              //字符串的每个字符，从左往右都可以看成是有索引的，从0开始
//            且字符对象只要写出来就放到了常量池里，其地址固定不变了，每相加一个新字符床对象所形成的字符串对象就是一个新的对象

              s.charAt(i);//就将每个字符遍历出来了
        }*/
//        或者将字符串直接变成字符数组进行遍历：
        char[] chars = s.toCharArray();

        for (char aChar : chars) {//每个字符遍历出来
//            在这里，匹配的字符放到第一个参数那，统计的次数放到第二个参数里
             if(!characterIntegerHashMap.containsKey(aChar)){
                 characterIntegerHashMap.put(aChar,1);
             }else {

                Integer integer=characterIntegerHashMap.get(aChar);
               integer++;//这里一定要用这个，通过键获取值，因为每个键得值都是在不断变换，没有什么共性，只能通过键自身去获取这个值了
                 characterIntegerHashMap.put(aChar,integer); //让字符当键，让匹配的次数充当值，键是不变得，而值是不断变换得，正好新值替换旧值，妙啊
             }




        }
        System.out.println(characterIntegerHashMap);
    }
}