最大最小值及比较器

一、获取集合中的最大最小值的方法

方法一：对于已经实现了比较器的基础类（如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

首先这是运用了java的泛型
①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; // 编译正确
    }
}

这个可以理解为<GregorianCalendar extends Comparable<Calendar>>是可以运行成功的！因为Calendar为GregorianCalendar 的父类并且GregorianCalendar 实现了Comparable<Calendar>,可查看api！.
如果是如下代码则运行不成功

import java.util.GregorianCalendar;
class Demo<T extends Comparable<T>>{}
//这里把? super去掉了
public class Test
{
	public static void main(String[] args) {
	   Demo<GregorianCalendar> p = null; 
        }
}

编译会报错！因为<T extends Comparable<T>>相当于<GregorianCalendar extends Comparable<GregorianCalendar>>但是GregorianCalendar并没有实现Comparable<GregorianCalendar>而是实现的Comparable<Calendar>，这里不在限制范围之内所以会报错！

 

转载2：来源zhihu

 

Java的泛型写法。泛型在java里有两个作用

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也能用