泛型 Set集合 HashMap 异常处理

目的

1.明白什么是泛型
2.清楚集合结构
3.了解Set及HashMap中的方法
4.会异常处理

技术

1.使用泛型
2.使用快速查找HashSet
3.使用有序集合TreeSet
4.HashMap 键值对的操作
5.异常处理
6.自定义异常处理

技术实现

• 泛型
  定义一个类 使用泛型

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

    public void test(E a1,E a2){
        this.a1 = a1;
        this.a2 = a2;

       System.out.println(a1.equals(a2));
    }
}

实现该类中的方法

GenericTest<String> g1 = new GenericTest<>();
        g1.test("dfieFF","sdkjf");

• HashSet的使用

  HashSet<String> names = new HashSet<>();
        names.add("jack");
        names.add("merry");
        names.add("abc");

        names.removeIf(ele -> {
            return ele.compareTo("c") > 0;
        });

• 使用TreeSet自定义排序一个类
  定义一个Person类实现Comparable接口

class Person implements Comparable{
    String name ;
    int age;

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

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

在该类中重写compareTo方法

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

创建对象并实现排序

 TreeSet<Person> score = new TreeSet<>((Person p1,Person p2) -> p1.compareTo(p2));

        Person p1 = new Person("xw",23);
        Person p2 = new Person("zo",23);
        Person p3 = new Person("jw",35);

        score.add(p1);
        score.add(p2);
        score.add(p3);


        // equals 比较的是对象内部的内容
        // 使用的两个对象必须实现Comparable接口的compareTo方法
        // 在compareTo里面实现具体该如何比较

        System.out.println(score);

• HashMap 键值对的操作
  创建一个HashMap对象score并添加键值对

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

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

对键值对的常用操作

// 更改某个键值对的值
        score.put("English",59);
        System.out.println(score);

        // 获取键值对的个数
         System.out.println(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<String,Integer> entry:entrys){
               // 得到Entry对应的key
               String key =(String)entry.getKey();

               // 获取Entry对应的值
               Integer value = (Integer)entry.getValue();

               System.out.println("key:"+key+"   value:"+value);           }
    }

• 异常处理
  Exception1 -
  try{ 执行的代码
  可能出现的异常
  一旦出现异常 系统自动为我们创建一个异常类并抛出
  }catch(NullPointerException e){
  如果需要自己处理异常就catch
  } catch(IOException e){
  如果有多个异常 可以使用多个catch来捕获
  如果有多个异常 catch 的顺序死从小到大
  } catch(Exception1 e){

} finally{
不管有没有异常 finally 都会被执行
处理资源回收 网络链接 数据库链接 I/O流
}

int a = 0 ;
    int b = 20;
        FileReader fr = null;
    try {
        int c = b / a;
        System.out.println("hello");  // 此处hello不会被打印

         fr = new FileReader("");
    }catch (ArithmeticException e){
        System.out.println(e.getMessage());
    }catch (FileNotFoundException e){
        e.printStackTrace();
    }finally {
        try {
            fr.close();
        }catch (IOException i){
            System.out.println(i.getMessage());
        }

    }

// 圆括号里面只能添加可以关闭的对象
// 实现了Closeable接口的对象
// 如果出现异常 系统自动就关闭这个资源
try(FileReader f1 = new FileReader("ddd")){
// 使用对象
} catch (IOException e) {
e.printStackTrace();
}

class TException{
    public static void test() throws FileNotFoundException,NullPointerException{
        FileReader fr = new FileReader("s");
    }

    public static void test2() throws IllegalAccessException {
        // ...
        if (2 > 1 ){
            throw new IllegalAccessException();
        }
    }

 try {
            TException.test();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

• 自定义异常处理
  自定义一个类继承于Exception
  并提供一个无参构造方法和一个有参构造方法（参数为字符串）

class aaException extends Exception{

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

    }

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

写一个方法抛出该异常

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

测试

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

QQ图片20190817192053.png

心得

最近学的东西简单却多杂。虽然容易，但还是容易犯迷糊，还是需要归纳整理和复习才能记得牢。