最大最小值及比较器
一、获取集合中的最大最小值的方法
方法一：对于已经实现了比较器的基础类（如Integer/Date）可以用集合自带的比较方法Collections.max(list)或者Collections.min(list)
方法二：主要应用于自定义类
代码如下：
List<Interger> list = new ArrayList<Interger>();
int max = list.get(0);
int min = list.get(0);
for(int i=0;i<list.size();i++){
if(min>list.get(i)){
min=list.get(i);
}
if(max<list.get(i)){
max=list.get(i);
}
}
二、比较器（comparator和comparable）
1）Compartor接口是java.util包中的接口(工具包，包含集合类)，而Comparable是java.lang包中的接口（核心基础类）
在Compartor接口中包含两个抽象方法，两个方法分别是
1.1 compare(T o1, T o2)
1.2 equals(Object obj)
compare方法返回的是-1,0,1；分别对应于对象O1小于，等于，大于对象O2
equals方法返回的是一个布尔类型的
Comparator实例：获取文件列表并按文件名排序（文件放前面）
Collections.sort(fileList, new Comparator<File>() {
@Override
public int compare(File o1, File o2) {
if (o1.isDirectory() && o2.isFile())
return -1;
if (o1.isFile() && o2.isDirectory())
return 1;
return o2.getName().compareTo(o1.getName());
}
});
2）Comparable 接口中只有一个方法：compareTo(T o);
基本类型内部实现了compareTo方法，代码如下:
public int compareTo(Integer anotherInteger) {
int thisVal = this.value;
int anotherVal = anotherInteger.value;
return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
}
小于、等于和大于分别对应的返回值为-1,0，和1
ps:（当正序排列时小于返回-1，放在左边。如需进行倒序排列则重写compareTo设定小于返回1，大于返回-1）
3）什么时候用Comparable，什么时候用Compartor是通过继承了该接口的实例对象对该方法进行调用
例如我们向容器中存放数据时，放java封装好的对象，这时候的对象大多数都实现了comparable接口，而如果存放的是我们自己写的类，我们需要对其进行封装，并实现Comparable接口，这样我们就可以使用容器的SORT方法。我们也可以不用实现Comparable接口，通过实现Compartor的类，然后再排序的时候调用即可
三、泛型（例:<T extends Comparable<? super T>>）
转载1：来源zhihu
①extends后面跟的类型如<任意字符 extends 类/接口>表示泛型的上限
import java.util.*;
class Demo<T extends AbstractList>{}
public class Test
{
public static void main(String[] args) {
Demo<ArrayList> p = null; // 编译正确
//这里因为ArrayList是AbstractList的子类所以通过
//如果改为Demo<AbstractCollection> p = null;就会报错这样就限制了上限
}
}
②同样的super表示泛型的下限
③<T extends Comparable<? super T>>这里来分析T表示任意字符名，extends对泛型上限进行了限制即T必须是Comparable<? super T>的子类，然后<? super T>表示Comparable<>中的类型下限为T！这样来看一段代码辅助理解
import java.util.GregorianCalendar;
class Demo<T extends Comparable<? super T>>{}
public class Test1
{
public static void main(String[] args) {
Demo<GregorianCalendar> p = null; // 编译正确
}
}
如果是如下代码则运行不成功
import java.util.GregorianCalendar;
class Demo<T extends Comparable<T>>{}
//这里把? super去掉了
public class Test
{
public static void main(String[] args) {
Demo<GregorianCalendar> p = null;
}
}
a. type cheking at complie time
b. auto cast
所以根据a，他规定了T的类型。
第二、那么T是什么类型呢？
我们先简化一下，看看下面这种写法
<T extends Comparable<T>>
这个应该是比较常见的写法，T 必须实现Comparable接口，而比较的类型T。
这很容易明白，因为T和T才能进行比较嘛。
问题来了，为什么要使用以下写法。
<T extends Comparable<? super T>>
但是 如果T的父类实现了 Comparable接口，而我们也想这个接口怎么办呢？看下面这个例子
class Dog implements Comparable<Dog>{
int weight;
public Dog(int weight) {
this.weight = weight;
}
@Override
public int compareTo(Dog o) {
return this.weight - o.weight;
}
}
class Labrador extends Dog{
public Labrador(int weight) {
super(weight);
}
}
在这里Labrador 继承了Dog 和他的Comparable方法。
但如果泛型是<T extends Comparable <T>>
显然 Labarador 是不符合的，因为他并没有实现 Comprable<Labrador>。
如果改成<T extends Comparable<? super T>>，那么只要Dog实现了Comparabl接口。Labrador也能用
