一、泛型

泛型，也可说是“参数化类型”，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

泛型的使用

1，定义一个泛型类：

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

使用这个类：

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

2，关于泛型最好的例子就是ArrayList的使用，ArrayList可以存放所有的对象。

    ArrayList<String> strings = new ArrayList<>();//可以放字符串
    ArrayList<Integer> integers = new ArrayList<>(); //可以存放整数

二、Set接口

Set集合里面对象不能重复，如果重复对象重复就添加不进去。内部使用HashMap来实现，键key不能重复。集合是无序的添加顺序和存储顺序无关使用了一种默认的排序方式
如何实现HashMap里面的key不相同？
计算这个key对应的hash值，计算方式是在对象的地址的基础上按照一定的算法计算出来的一个整数，如果两个对象相同那么计算出来的哈希值就相同，此时就不能再添加进去。

Set集合的方法摘要

方法摘要

HashSet类

HashSet和ArrayList都是间接继承Collection接口，在方法上面相差不大，下面只写两种方法
向集合里添加数据

    HashSet<String> names = new HashSet<>();
    names.add("jack ");
    names.add("and ");
    names.add("Merry");
    names.add("Tom");
    System.out.println(names);

输出结果

注意：由此可见添加顺序和存储顺序无关
删除符合某种条件的元素

    names.removeIf(element -> {
        return element.compareTo("T") < 0;
    });
    System.out.println(names);

TreeSet类

1，1.TreeSet可以用来排序时候默认升序排的,,但是只能排常量的

TreeSet<integer> set = new TreeSet<>();
set.add(1);
set.add(4);
set.add(2);
set.add(3);
System.out.println(set);

2，如果想要比较对象就需要在类里面重写CompareTo方法

重写CompareTo方法：

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) {
    //判断o对象是不是Person类的一个对象
    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;
    }
  }
}

TreeSet的第一种方法：

    //可以排序的集合
    TreeSet<Person> score = new TreeSet<>(new Comparator<Person>() {
        @Override
        public int compare(Person person, Person t1) {
            return person.compareTo(t1);
        }
    });
    Person p1 = new Person("jack",20);
    Person p2 = new Person("tom",21);
    Person p3 = new Person("merry",19);
    score.add(p1);
    score.add(p2);
    score.add(p3);
    //equals比较的是对象内部的内容 使用的两个对象必须实现Comparable接口的CompareTo方法
    // 在CompareTo方法里面具体实现该如何比较
    System.out.println(p1==p2); //输出结果为false

TreeSet排序的第二种方法：

    //可以排序的集合
    TreeSet<Person> score = new TreeSet<>((Person p1,Person p2) -> p1.compareTo(p2));
    Person p1 = new Person("jack",20);
    Person p2 = new Person("tom",21);
    Person p3 = new Person("merry",19);
    score.add(p1);
    score.add(p2);
    score.add(p3);
    //equals比较的是对象内部的内容 使用的两个对象必须实现Comparable接口的CompareTo方法
    // 在CompareTo方法里面具体实现该如何比较
    System.out.println(score); //输出结果为false

    if(p1.hashCode() ==p2.hashCode()){
        System.out.println("相同");
    }else{
        System.out.println("不相同");
    }

HashMap类

HashMap 集合存储数据的特点：键值对，键key-值value，key不能重复可以是任意的对象对象类型，通常使用字符串
创建一个HashMap对象

    HashMap<String,Integer> score1 = new HashMap<>(); //创建一个HashMap ，键是字符串类型，值是Integer类型

添加数据，键值对

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

修改键值对的值

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

获取键值对的个数

  //获取键值对的个数
    score1.size();

得到所有的键组成的集合

    //获取所有的键key,返回所有的key组成的集合
    System.out.println(score1.keySet());

得到所有值组成的集合

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

得到所有键值对组成的集合

    //获取每一个键值对 Entry 所有键值对组成的集合
    System.out.println(score1.entrySet());

获取一个键key对应的值

    System.out.println(score1.get("Chinese"));

键值对的遍历
1，通过遍历key来得到每一个key对应的值

    for(String key:score1.keySet()){
        //通过key得到值
        int value = score1.get(key);
        System.out.println("key:"+key+"value"+value);
    }

2,通过EntrySet 得到Entry对象的集合

    // 一个Entry管理一个键值对 getKey getValue
    Set<Map.Entry<String,Integer>> entrys = score1.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);
    }

异常处理

异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw 语句手动抛出的，只要在Java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE就会试图寻找异常处理程序来处理异常。
常见异常处理的结构

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

注意如果异常出现，则后面的代码将不会执行，所以 try代码块不要抓太多代码块避免后面的代码无法执行

代码举例

抛出异常
当特殊情况出现了自己可以抛出异常throws，使用throws抛出异常交给外部处理

   public static void test() throws FileNotFoundException {
    FileReader fr = new FileReader(" ");
  }
    public static void test2() throws IllegalAccessException {
    if(1 > 2){
        throw new IllegalAccessException();
    }
}

自己定义异常类
自己定义的抛出异常类要继承Exception类后Throwable类

class TExcepetion  {
public static void test3() throws XWJException {
    StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
    StackTraceElement e = stackTrace[2];
    String detail = e.getFileName()+"->"+e.getMethodName()+"-      >"+e.getLineNumber();
    throw new XWJException("自己的异常类：无所作为"+detail);
  }
}
class XWJException extends java.lang.Exception{
//1,提供一个无参构造方法
public XWJException(){}

//2,提供一个有参构造方法
public XWJException(String desc){
    super(desc);
}

使用这个类

   try {
        TExcepetion.test3();
    } catch (XWJException e) {
        System.out.println(e.getMessage());
    }