Set、Map、异常

泛型：

定义一个泛型类：

class GenericTest<T>{
    int age;
    T a1;
    T a2;

定义一个泛型方法

    public void test(T a1, T a2){
        this.a1 = a1;
        this.a2 = a2;
        
        System.out.println(a1.equals(a2));
    }
}

Set

Set:集合接口

HashSet :无序（添加的顺序和存储的顺序无关），不支持同步
TreeSet 有序，不支持同步
LinkedHashSet 可排序，不支持同步
方法：
add 添加一个元素
clear 清除整个HashSet
contains 判断是否包含一个元素
remove 删除一个元素 size大小
retainAll 计算两个集合交集
LinkedHashSet：方法和HashSet基本一致，可容纳null元素
HashSet TreeSet LinkedHashSet 的元素都只能是对象

HashSet和LinkedHashScr判定元素重复的原则

一判定两个元素的hashCodc返回值是否相同，若不同，返回false一若两者hashCode相同，判定equals方法，若不同，返回false; 否则返回true

        //HashSet HashMap
        HashSet<String> names = new HashSet<>();
        names.add("jack");
        names.add("merry");
        names.add("abc");
        names.add("abc"); // abc重复 HashSet不会添加此对象
System.out.println(names);//输出结果的顺序和上述顺序不一致

TreeSet判定元素重复的原则

需要元素继承自Comparable接口
比较两个元素的compareTo方法

可以排序的集合

注：equals、hashCode、toString方法三者往往三位一体，重写的话三个方法写一致

        
        TreeSet<Person> score = new TreeSet<>();

        Person p1 = new Person("jack",20);
        Person p2 = new Person("jack",30);
        Person p3 = new Person("rose",20);

        score.add(p1);
        score.add(p2);
        score.add(p3);
       
        //equals 比较的是对象内部的内容
        //使用的两个对象必须实现Comparable接口的compareTo方法
 //在compareTo里面实现具体该如何比较
        System.out.println(p1==p2);
    }
}

class Person implements Comparable{
    String name;
    int age;

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

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

@Override
    public int compareTo(Object o) {
        //1. 判断o对象是不是peron的一个对象
        if (o instanceof Person){
            Person o1 = (Person)o;
            //自己规定比较的策略
            if (this.age != o1.age){
                return this.age - o1.age;
            }else{
                //年龄相同的情况下 再比姓名的字母
                return this.name.compareTo(o1.name);
            }
        }else{
            return -1;
        }
    }

Map

image.png

Hashtable

-K-V对，K和V 都不允许为null

• 同步，多线程安全
  -无序的
  -适合小数据量

HashMap

-K-V对，K和V 都允许为null

• 不同步，多线程不安全
  -无序的

LinkedHashMap

-基于双向链表的维持插入顺序的HashMap

TreeMap

-基于红黑树的Map，可以根据key的自然排序或者compareTo方法进行排序输出

HashMap

 HashMap<String,Integer> score = new HashMap<>();

        //添加对象  ： 键值对
        score.put("Chinese",89);
        score.put("Math",94);
        score.put("English",92);

        //更改某个键对应的值
        score.put("Chinese",91);

        //获取键值对的个数
        score.size();
        //获取所有的key
     System.out.println(score.keySet());

     //获取所有的value
        System.out.println(score.values());

        //获取entry: key-value
        System.out.println(score.entrySet());

        //获取一个键key 对应的值
        System.out.println(score.get("English"));

        //键值对的遍历
        //1.通过遍历key 来得到每一个key对应的值
          for(String key :score.keySet()){

               // 通过key得到值
              int s = score.get(key);
              System.out.println("key"+key+"value"+s);
          }

          //2. 通过Entryset   得到 Entry对象的集合
        // 一个Entry管理一个键值对  getKey getValue
         Set <Map.Entry<String,Integer>>entrys = score.entrySet();
          for(Map.Entry entry:entrys){

              // 得到Entry对应的key
              String key = (String )entry.getKey();

              //获取Entry对应的值
              Integer value = (Integer)entry.getValue();
              System.out.println("key"+key+"value"+value);
          }
    }

异常

异常： 程序不正常的行为或者状态
例如：数组的越界访问、读取不存在的文件
异常处理：
1.异常的分类：

image.png
image.png

2.异常的处理结构

try{
 *     执行的代码
 *     // 可能会出现异常
 *    //一旦出现异常系统自动为我们创建一个异常类并抛出
 * }catch（NUllPointerException e）{
 *  如果需要自己处理异常就catch
 * }catch(IOException){
 *     如果有多个异常 可以使用多个catch来捕获异常
 *     如果有多个异常 catch的顺序是从小到大
 * }catch(Exception e){
 *
 * }
 * finally{
 * 不管有没有异常 finally都会被执行
 *     处理资源回收  网络链接  数据库链接  I/O流
 *
 * }

try(){}

注： 圆括号里面只能添加可以关闭的对象，并且该对象要实现了closeable接口。那么如果出现异常 系统自动就关闭这个资源

        try(FileReader fr1 = new FileReader("ddd")){
              //使用对象，如果在使用过程中出现异常，那么系统将释放这个对象。
        } catch (IOException e) {
            e.printStackTrace();
        }

3.注意事项：

1.如果出现异常try里面在出现异常点之后的代码块不会被执行，出现异常时，会取寻找能与异常类型对应的catch代码块，代码块执行完毕之后不会再返回到try中，会继续按顺序向下执行，但不会执行之后的catch代码块。
2.将小的异常写在前面，大的宽泛的异常写在后面
3.方法存在可能异常的语句，但不处理，那么可以使用throws来声明异常。
4.调用带有throws异常(checked exception)的方法，要么处理这些异常，或者再次向外throws，直到main函数为止。

4.自定义异常：

（1）继承Exception类或其子类
—继承自Exception，就变成Checked Exception
—继承自RuntimeException，就变成UncheckedException
（2）自定义重点在构造函数
调用父类Exception的message构造函数
--可以定义自己的成员变量
（3）在程序中采用throw主动抛出异常
Demo:

自定义一个异常类继承于Exception

    //1.提供一个无参构造方法
    public ZHTException(){

    }
    //2.提供一个有参构造方法 参数是一个字符串
    public ZHTException(String desc){
       super(desc);
    }
}

编写方法，抛出自定义异常

  public static void test3() throws ZHTException{
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        StackTraceElement e = stackTrace[2];
        String detail = e.getFileName()+"->"+e.getMethodName()+"->"+e.getLineNumber();
        throw  new ZHTException("自己异常类： 无所作为"+detail);
    }

在主程序中抛出

   try {
            TException.test3();
        }catch (ZHTException e){
            System.out.println(e.getMessage());
        }

运行结果：

image.png

感悟：
上课听的也是有点懵，下课看了视频才搞明白，觉得还是得多敲才能记得住，多敲代码！多敲代码！多敲代码！