零基础学习java------day15--------collections用法，比较器，Set（TreeSet，TreeMap），异常

1. Collections用法

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) 随机打乱
public static <T> void sort(List<T> list, Comparator<? super T> c)

Collection 和Collections 区别:
　　Collection: 是单列集合的根接口
　　Collections: 集合的工具类

2. 比较器***

2.0 前提

通过Collections.sort()方法已经可以对一些集合实现排序功能，如下对List<Integer> list进行了排序

public class ComparableDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(100);
        list.add(124);
        list.add(99);
        list.add(300);
        Collections.sort(list);
        System.out.println(list);//[99, 100, 124, 300]
    }
}

此时若将集合改为List<Person>会直接报错，如下（The method sort(List<T>) in the type Collections is not applicable for the arguments (List<Person>)）

排序是通过Collections.sort()方法，那么，为什么List<Integer>可以进行排序呢？我们可以去看下Collections下sort方法以及Integer源码

sort()源码部分

由此处可看出，sort内的参数类型必须是Comparable<? super T>本身或者其父类，接下来看下Integer的源码部分

可见其继承类Comparable<Integer>接口，那么如何让List<Person>类型的list也为comparable类型呢，首先想到的是继承，让Person类继承Integer类，Person就自然符合sort()方法中的参数类型了，但是有上面Integer源码可知，Integer有final修饰，其是不能被继承的，没办法，只能自己去继承并实现Comparable接口了。查看Comparable接口的源码，发现发现接口内部有个抽象方法待实现（compareTo()）,而这个方法便是定义排序规则的，以便sort可以按此规则对list进行排序。这里我们先看下Integer类中是怎么实现comparable接口的，查看起源码，如下：

可见实现compareTo的方法最终返回值有三种（0，-1,1），但sort（）是怎么实现这个排序的呢？（以后再去看详细的源码）

大致调用过程如下：

Collections.sort()----->list.sort()------->Arrays.sort()------>Arrays.legacyMergeSort()----->Arrays.mergeSort（）   ，可见，最终是用归并排序来实现的

所以，要利用Collections.sort()对List<Person>集合进行排序，只需让Person实现Comparable接口即可（可参照Integer类）

2.1 Comparable用法

（1）

　　要想让一个List可以使用Collections.sort进行排序，需要要求集合中的元素所在的类实现Comparable(java.lang)接口，实现了该接口就具备了排序的能力，才能进行排序，实现该接口我们需要重写里面的compareTo方法，该方法的主要目的就是定义排序的规则（即告诉接口按照上面规则比较大小），重写该方法时要注意，该方法返回值是int类型

　　返回值为正数，表明this中的数据大于参数中的数据，排序时将大的数移至后面

　　返回值为0，表明this中的数据等于参数中的数据

　　返回值为负数，表明this中的数据小于参数中的id

其实就是this对象和参数对象做一个比较，this对象在前，就是升序，参数对象在前就是降序。

以下将Person去实现Comparable接口（只写出重写方法部分代码）：

@Override
public int compareTo(Person o) {
   return (this.age<o.age)?-1:(this.age==o.age)?0:1;
}

这样的话Collections.sort()就可以对List<Person>集合进行排序，具体如下（此处是按年龄排序）

public class ComparableDemo {
    public static void main(String[] args) {
        List<Person> person = new ArrayList<Person>();
        person.add(new Person("zs",26,'男'));
        person.add(new Person("ls",36,'男'));
        person.add(new Person("xh",26,'女'));
        person.add(new Person("mz",16,'女'));
        Collections.sort(person);
        System.out.println(person);
    }
}
// 运行结果：[Person [name=mz, age=16, gender=女], Person [name=zs, age=26, gender=男], Person [name=xh, age=26, gender=女], Person [name=ls, age=36, gender=男]]

若要按姓名来排序，并且降序则compareTo方法如下：

public int compareTo(Person o) {
    return o.name.compareTo(this.name);//  此处的compareTo为字符串内实现的compareTo方法
}

同样是上面的 ComparableDemo测试类，得到的结果为

[Person [name=zs, age=26, gender=男], Person [name=xh, age=26, gender=女], Person [name=mz, age=16, gender=女], Person [name=ls, age=36, gender=男]]

练习：创建一个Student类型的List：姓名，年龄，分数，排序要求：按照年龄做升序，如果年龄相同，则按照分数做降序

public class Student implements Comparable<Student>{
　　String name;
　　int age;
　　double score;
　　public Student() {

　　}
　　public Student(String name, int age, double score) {
　　　　super();
　　　　this.name = name;
　　　　this.age = age;
　　　　this.score = score;
　　}
　　@Override
　　public String toString() {
　　　　return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
　　}
　　//需求: 默认按照年龄的升序,如果年龄相同,按照分数的降序
　　@Override
　　public int compareTo(Student o) {
　　　　if(this.age == o.age) {
　　//return (int)(o.score - this.score);//这么写不好,98.6 98.7得到的结果是0

    //  会认为分数相同,就会按照添加的顺序排序,和预期不符

 　　return o.score - this.score>0?1:-1; } return this.age - o.age; } }

2.2  comparator用法

　　1.  好了，目前我们已经掌握了如何对一个List<Person>做排序，那么我们知道了为什么List<Integer>默认实现的是升序，就是因为Integer在实现Comparable接口的时候用的就是升序的方式，如果我们想要实现降序应该怎么做呢？其实只需要将Integer中的compareTo方法中的两个参数调换一下位置就可以了，但是由于是class文件，我们是不能修改的，所以java为我们提供了一个外部比较器Comparator(java.util)，这是个接口

public class ComparableDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(100);
        list.add(124);
        list.add(99);
        list.add(300);
        Collections.sort(list，new IntegerComparator());//注意此处的sort方法跟升序不是一个方法，这是提供给 comparator的重载方法，接收2个参数
        System.out.println(list);//[99, 100, 124, 300]
    }
}
class IntegerComparator implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2.compareTo(o1);
    }
}
// 运行结果：[300, 124, 100, 99]

2. 为了简便，可进行如下改写：

　　（1）使用匿名函数来实现comparator接口

Collections.sort(list, new Comparator<Integer>() {
    public int compare(Integer o1, Integer o2) {
         return o2-o1;
    }
});

（2）在java1.8后，可以直接调用list.sort()，不需要Collections（更加方便），如下

list.sort(new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });

（3）使用lambda方法

list.sort((a,b)->b-a);

 3. 此处可以不用Collections.sort(),直接使用带参数的构造方法，具体如下

2  总结

　Comparator:用法：

　　　　Collections.sort(List<List>, Comparator<>);　

　由于Comparator是一个接口，需要传入Comparator子类的对象(匿名内部类)，需要重写compare，从而定义新的排序规则

　　　　用前面的和后面的比较：升序

　　　　用后面的和前面的比较：降序

　Comparable  和 Comparator的区别：

　　　　Comparable：内部比较器，位于java.lang，如果一个集合想要使用Collections.sort进行排序，需要里面的元素所在类实现Comparable接口，并且重写compareTo方法实现排序

3.  TreeSet和TreeMap的用法

3.1TreeSet

　　Collections.sort()只能作用于list，并不能作用于Set。Set要排序的话可以通过其子类TreeSet，TreeSet会自动对集合中的元素进行排序，同List一样，其对Person这种类型的元素做排序时，需要在这种类中实现Comparable接口，否则会出现转型异常：com._51doit.javase04.day15.tree.Person cannot be cast to java.lang.Comparable。

案例1

public class TreeSetDemo {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<Integer>();
        set.add(12);
        set.add(15);
        set.add(20);
        set.add(9);
        System.out.println(set);
    }
}
// 运行结果：[9, 12, 15, 20]

由结果可知，TreeSet可实现自动排序

Set实现comparable接口的方式就是直接重载compareTo方法就行了，其内部是自动调用了排序方法的，但comparator则有点不一样，重写完comparator中的compare方法，直接将这个子类对象传进集合构造方法，具体如下：

public class TreeSetDemo1 {
    public static void main(String[] args) {
        //实现TreeSet中Integer降序
        Set<Integer> set3 = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        set3.add(123);
        set3.add(45);
        set3.add(1);
        set3.add(100);
        System.out.println(set3);
   }
}
// 运行结果：[123, 100, 45, 1]

注意  Set里面的元素不能重复，其判断元素是否重复的原理是：根据compareTo（对comparable）/compare（对comparator）方法来验证元素是否重复，compareTo/compare返回结果是0，就认为是相同的元素，否则就不同。我们在重写compareTo/compare方法的时候，尽量不要只比较一个属性

案例2

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

        Set<Teacher> teacher = new TreeSet<Teacher>();
        teacher.add(new Teacher("zs",26));
        teacher.add(new Teacher("ls",36));
        teacher.add(new Teacher("xh",26));
        teacher.add(new Teacher("xf",26));
        teacher.add(new Teacher("mz",16));
        System.out.println(teacher);  //并没有调用排序方法，重写compareTo方法直接打印此set集合，就会按照compareTo定义的规则排序，其内部怎么实现排序的暂不清楚
    }
}
class Teacher implements Comparable<Teacher>{
    String name;
    int age;
    public Teacher(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Teacher o) {
        return o.age - this.age;  //按年龄降序
    }
    @Override
    public String toString() {
        return "Teacher [name=" + name + ", age=" + age + "]";
    }
}
// 运行结果：[Teacher [name=ls, age=36], Teacher [name=zs, age=26], Teacher [name=mz, age=16]]

有结果可知，TreeSet直接按年龄是否相同去重了，若要不被去重，可以在compareTo中多写几个属性，如下

@Override
public int compareTo(Teacher o) {
   if(o.age == this.age) {
       return o.name.compareTo(this.name);//降序
   }
   else {
       return o.age - this.age;// 降序
   }
}
// 运行结果: [Teacher [name=ls, age=36], Teacher [name=zs, age=26], Teacher [name=xh, age=26], Teacher [name=xf, age=26], Teacher [name=mz, age=16]]

3.2 TreeMap

1. 概述：

TreeMap：可以对key这一列实现排序，key不能为nul（key会调用compare/compareTo方法进行排序，若为null，则会出现空指针异常），TreeMap中的key所在的类必须要实现Comparable接口，如果不想实现，则必须在构造方法中传入一个外部比较器。

key：   不能重复，其原理也是由compare/compareTo方法决定的

public class TreeMapDemo {
    public static void main(String[] args) {
        TreeMap<Integer,String> map = new TreeMap<>();
        map.put(1,"热河");
        map.put(2,"你好");
        map.put(3,"再见");
        //map.put(null,"热河"); 报空指针异常
        System.out.println(map);
    }
}
运行结果：{1=热河, 2=你好, 3=再见}

2.TreeMap实现降序

　　使用外部选择器：Comparator（此处能不能通过重写comparable中的compareTo方法来实现降序呢？）

public class TreeMapDemo {
    public static void main(String[] args) {
        TreeMap<Integer,String> map = new TreeMap<>(new Comparator<>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        map.put(1,"热河");
        map.put(2,"你好");
        map.put(3,"再见");
        System.out.println(map);
    }
}

运行结果：{3=再见, 2=你好, 1=热河}

　　

4. 异常

4.0 概述：　　

　　异常就是java程序在运行过程中出现的错误，现实生活中遇到的问题也是一个具体的事务，可以通过java类的形式进行描述，并封装成对象。其实就是java对不正常情况进行描述后的对象体现。前面见过的异常有角标越界异常，空指针异常等。

4.1 异常的层次结构：

Throwable：

　　Error：程序出现的错误，不能使用程序处理，一般无需程序员关注，如内存溢出，网络连接异常

　　Exception（异常）：

　　　　　　　　运行时异常：RuntimeException及其子类，可以对其进行处理，也可以不处理，往往是由于代码书写不正确或不规范造成，程序员自己去检查问题，并修改代码。

　　　　　　　　编译时异常：除了运行时异常以外的所有异常，必须对异常进行处理，否则无法通过编译，程序无法执行往往是由于无法预估的用户操作造成的

产生异常后：代码无法向下执行

我们处理异常的目的是什么？   为了让程序能够执行下去

下面是编译时异常

4.2 异常的处理方式：

JVN处理异常的方式：

　　　　打印异常信息并终止程序，其并不会对异常进行处理

当出现异常时，在eclipse找异常的顺序是由上往下，上面的异常一般为异常产生处，如下（先是test出现异常，再是main，而main方法出现异常是因为调用了test方法）

4.2.1  捕获：

　　1.try...catch( ){  }

　　　　格式：

　　　　　　　try{

　　　　　　　　　//可能出现的异常

　　　　　　    }catch(异常类名   对象名){

　　　　　　　　   //对异常的处理

　　　　　　　}

　　2.try...catch...finally

　　　　格式：　　　

　　　　　　try{

　　　　　　　　　//可能出现的异常

　　　　　　    }catch(异常类名   对象名){

　　　　　　　　   //对异常的处理

　　　　　　　}finally{

　　　　　　　　   //一定会执行的代码

　　　　　　　}

注意事项：

1. catch 块中可以存在多个,并且可以有子父类的关系:
　　　一旦存在子父类的关系,要把子类异常放上面,因为放下面,就再也执行不到了
　　    catch 块中应该写的是一种备选方案
2. jdk7:一个catch 块中可以处理多个异常,多个异常之间使用 | 隔开
3. try 块中的局部变量和catch 块中的局部变量（包括异常变量），以及finally 中的局部变量，他们之间不可共享使用。
4. 每一个catch 块用于处理一个异常。异常匹配是按照catch 块的顺序从上往下寻找的，只有第一个匹配的catch 会得到执行。匹配时，不仅运行精确匹配，也支持父类匹配，因此，如果同一个try 块下的多个catch 异常类型有父子关系，应该将子类异常放在前面，父类异常放在后面，这样保证每个catch 块都有存在的意义。
5. 当一个函数的某条语句发生异常时，这条语句的后面的语句不会再执行，它失去了焦点。执行流跳转到最近的匹配的异常处理catch 代码块去执行，异常被处理完后，执行流会接着在“处理了这个异常的catch 代码块”后面接着执行。
6. finally 块不管异常是否发生，只要对应的try 执行了，则它一定也执行。只有一种方法让finally 块不执行：System.exit()。因此finally 块通常用来做资源释放操作：关闭文件，关闭数据库连接等等

public class ExceptionDemo {
    public static void main(String[] args) {
        Date d = null;
        try {
        System.out.println(1/0); // 运行时异常
        }catch(Exception e1){
            System.out.println("哈哈");
        }
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            d = sdf.parse("1232012-09-18"); // 编译时异常
            String s = null;
            System.out.println(s.length()); // 空指针异常
            System.out.println(1/0);
        }catch(ArithmeticException | NullPointerException e) { // 1个catch块处理多个异常
            System.out.println("1");
        }catch(Exception e) {  //此异常不能放前面，不然前面catch就不能执行了
            d = new Date();
        }
    }
}

面试题：

　　final           finalize            finally:区别:　　

final：     修饰类、方法、变量，被修饰的类不能被继承，被修饰的方法不能重写，被修饰的变量值不变
finalize： 用于垃圾回收

finally：   用于异常处理，代表一定会执行的代码

4.2.2  抛出（throws）

格式：

　在方法头上：throws  异常类名{  // 类名可以有多个，多个类之间使用“,”隔开

　　}　

注意：异常最终被抛给了异常的调用者

public class ExceptionDemo1 {
    public static void main(String[] args) throws ParseException {// 抛给其调用者JVM
        test();
    }
    public static void test() throws ParseException {  // 抛给其调用者main方法
        new SimpleDateFormat().parse("");
    }
}

一般内层抛出，在最外层做统一处理（不然每调用一次出现异常的方法就要处理一次异常）

 4.3  异常中常用的方法

 4.3.1  Trowable中的方法

（1）getMessage()： 获取异常信息，返回字符串。

public class ExceptionDemo2 {
    public static void main(String[] args) {
        try {
            new SimpleDateFormat().parse("");
        }catch(ParseException e){
            System.out.println(e.getMessage());
        }
    }
}
// 运行结果：Unparseable date: ""

（2）toString()：获取异常类名和异常信息，返回字符串

System.out.println(e.toString());  // java.text.ParseException: Unparseable date: ""

（3）printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void（不需要System.out.print（），自身就有打印功能）

e.printStackTrace(); // 打印异常信息，打印到控制台

运行结果：如下图

（4）printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅

public class ExceptionDemo2 {
    public static void main(String[] args) {
        try {
            new SimpleDateFormat().parse("");
        }catch(ParseException e){
        e.printStackTrace();
        try {
            e.printStackTrace(new PrintStream("f:/a/error.txt"));
        }catch(FileNotFoundException e1) {
            e1.printStackTrace();
            }
        }
    }
}

4.4 throw用法

throw 不是用来处理异常的，相反是触发一个异常，或者理解成一个异常

格式：

　　用在方法体中，throw异常的对象，这个对象只能有一个

throw的异常一定会发生

public class ExceptionDemo3 {
    public static void main(String[] args) {
        test();
    }
    public static void test() {
        throw new NullPointerException(""); // 若加参数，在报错异常类后会出现该参数
    }
}

运行结果：

若创建的是编译异常，则要抛出或者处理异常

public class ExceptionDemo3 {
    public static void main(String[] args) {
        try {
            test();
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static void test() throws ParseException {
        throw new ParseException("天空之城",30);  //此处的inr参数表示当编译时，错误会在那个位置发生（不大理解）
    }
}

 4.5 throws和throw区别

throws：

　　用在方法声明后面，跟的是异常类名；可以跟多个异常类名，用逗号隔开，表示抛出异常，由该方法的调用者来处理；throws表示出现异常的一种可能性，并不一定会发生这些异常

throw：

　　用在方法体内，跟的是异常对象名；只能抛出一个异常对象名；表示抛出异常，由方法体内的语句处理；throw则是抛出了异常，执行throw则一定抛出了某种异常

 4.6 自定义异常

　　定义编译时异常：继承Exception

　　定义运行时异常：继承RunException

案例：人的年龄必须在1-260，显然java没有对应的异常，需要我们自己来定义一个异常，如下：

（1）定义运行时异常：　

定义一个继承自RuntimeException的异常，即运行时异常

public class MyException extends RuntimeException {
    public MyException() {};
    public MyException(String desc) {
            super(desc);
    }
}

定义测试类，以及抛出异常

public class AgeTest {
    public static void main(String[] args) {
        AgeException ae = new AgeException();
        ae.setAge(300);
    }
}
class AgeException {
    int age;

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age>=1 && age<=260) {
            this.age = age;
        }else {
            throw new MyException("您的年龄有问题");
        }
    }
}

运行结果

（2）定义编译时异常：

将MyException继承自Exception即可，改完后，测试类中的年龄部分就要抛出异常或者处理异常了

 4.7  异常的注意事项

（1）子类重写父类方法时，子类的方法必须要抛出相同的异常或父类异常的子类

class FatherClass{
    public void test() throws Exception{

    }
}
class SonClass extends FatherClass{
    public void test() throws ParseException{  

    }
}

若将ParseException与Exception调换则会报错：Exception Exception is not compatible with throws clause in FatherClass.test()

（2）如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是它的子集，子类不能抛出父类没有的异常

（3）如果被重写的方法没有异常抛出，那么子类方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try，不能throws

（4）以上异常指的都是编译时异常