1、内置引用数据类型比较（常用）
1.1 Comparable
1、整数、小数Integer Float Double 直接比较基本数据类型的大小
2、字符：比较的Unicode码只差
3、字符串：
1）如果其中一个是另外一个其实开始的子传，返回长度子差
2）否则返回第一个不相等的Unicode码之差
4、java.util.Date:根据日期的长整形数比较
例1：
/**
* 引用数据类型的排序
* @author qjc
*
* 2016-3-10
*/
public class ComparableDemo {
/**
* 数组排序（使用泛型方法）
* @param arr
*/
public static <T extends Comparable<T>> void sort(T[] arr){
boolean sortede = true; //有序标示则不用比较
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1-i; j++) {
sortede = true;
if(((Comparable)arr[j]).compareTo(arr[j+1]) > 0){
T temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
sortede = false;
}
if(sortede){ //减少趟数
break;
}
}
}
}
public static void main(String[] args) {
String[] arr = {"abc","ab","a"};
sort(arr);
for(String s : arr){
System.out.println(s);
}
//结果： a ab abc
}
}
1.2 Comparator
提供排序的比较器，业务比较器
实现java.util.Comparator接口
重写public intcompare(T o1,T o2)
作用：
解耦：独立于实体类
方便：便于应用各种排序规则
例2：
/**
* 排序规则的业务类
* @author qjc
*
* 2016-3-10
*/
public class StringComp implements java.util.Comparator {
/**
* 按长度比较大小
* 正数: >0
* 负数： <0
* 0 ：==
*/
@Override
public int compare(Object o1, Object o2) {
int len1 = ((String) o1).length();
int len2 = ((String) o2).length();
return len1 - len2;
}
} /**
* Comparator排序
* @author qjc
*
* 2016-3-10
*/
public class ComparatorDemo {
/**
* 数组的排序（升序）+Comparator接口
* @param arr
* @param comm
*/
public static <T> void sort(Object[] arr,Comparator<T> comm){
boolean sorted = true;
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1-i; j++) {
if(comm.compare((T)arr[j], (T)arr[j+1]) > 0){
Object temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
sorted = false;
}
if(sorted){
break;
}
}
}
}
@Test
public void testSort(){
String[] arr = {"dss","fdss","fefeef"};
sort(arr, new StringComp());
System.out.println(Arrays.toString(arr));
//输出结果： [dss, fdss, fefeef]
}
}
1.3 Collections之排序
Collections工具类，此类完全由在collection 上进行操作或返回 collection 的静态方法组成。
提供了大量便于处理容器的方法
关于排序：
1、public static <T extends Comparable<?super T>> void sort(List<T> list)
2、public static<T> void sort(List<T> list,Comparator<? super T> c)
2、引用类型（自定义）
2.1 Comparable
按业务规则排序：
1、实体类：java.lang.Comparable + compareTo
例3：
新闻信息排序：按时间（第一排序）、点击量（第二排序）、标题（第三排序）
/**
* 新闻条目实体类
* @author qjc
*
* 2016-3-10
*/
public class NewItem implements java.lang.Comparable<NewItem>{
//标题
private String title;
//点击量
private int hits;
//时间
private Date pubTime;
//时间降序（第一排序） + 点击量升序（第二排序） + 标题降序
@Override
public int compareTo(NewItem ntm) {
int result = 0;
//比较时间
result = - this.pubTime.compareTo(ntm.pubTime); //降序
if(0 == result){
//点击量
result = this.hits - ntm.hits; //升序
//点击量相同
if(0 == result){
//标题
result = - this.title.compareTo(ntm.title); //降序
}
}
return result;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("标题：").append(this.title);
sb.append("时间：").append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.pubTime));
sb.append("点击量：").append(this.hits).append("\n");
return sb.toString();
}
//getter and setter...
} /**
*
* @author qjc
*
* 2016-3-10
*/
public class NewItemApp { @Test
public void test(){
List<NewItem> news = new ArrayList<>();
news.add(new NewItem("袁贵仁：十三五期间9年义务教育不会延长",100,
new Date(System.currentTimeMillis()-1000*60*60)));
news.add(new NewItem("沪指收跌2.02%危及2800点 分析:三因素影响A股",999,
new Date()));
news.add(new NewItem("女足回京球迷献吻 盼奥运进四强拿牌",888,
new Date(System.currentTimeMillis()+1000*60*60)));
System.out.println("排序前："+news);
System.out.println("====================================");
//Collections工具类排序（默认升序）
Collections.sort(news);
System.out.println("排序后："+news);
}
}
输出结果：
排序前：
[标题：袁贵仁：十三五期间9年义务教育不会延长时间：2016-03-10 21:33:28点击量：100
,标题：沪指收跌2.02%危及2800点分析:三因素影响A股时间：2016-03-10 22:33:28点击量：999
,标题：女足回京球迷献吻盼奥运进四强拿牌时间：2016-03-1023:33:28点击量：888
]
====================================
排序后：
[标题：女足回京球迷献吻盼奥运进四强拿牌时间：2016-03-10 23:33:28点击量：888
,标题：沪指收跌2.02%危及2800点分析:三因素影响A股时间：2016-03-10 22:33:28点击量：999
,标题：袁贵仁：十三五期间9年义务教育不会延长时间：2016-03-1021:33:28点击量：100
]
2.2 Comparator
2、业务排序类：java.util.Comparator + compare
优点：
- 解耦：与实体类分类
- 方便：应对多变排序规则
例4：
按商品价格排序
/**
* 商品类
* @author qjc
*
* 2016-3-10
*/
public class Goods {
//商品名
private String name;
//收藏量
private int fav;
//价格
private double price;
@Override
public String toString() {
return "商品名："+this.name+",收藏量"+this.fav+",价格"+this.price+"\n";
}
//getter and setter...
} /**
* 按价格排序的业务类（降序）
* @author qjc
*
* 2016-3-10
*/
public class GoodsPriceComp implements java.util.Comparator<Goods>{ @Override
public int compare(Goods o1, Goods o2) {
return -(o1.getPrice()-o2.getPrice()>0 ? 1 : (o1.getPrice()==o2.getPrice())?0 : -1);
}
} /**
*
* @author qjc
*
* 2016-3-10
*/
public class GoodsApp {
@Test
public void test(){
List<Goods> list = new ArrayList<>();
list.add(new Goods("iphone 5SE",1800,3888));
list.add(new Goods("iphone 7",1998,5888));
list.add(new Goods("Galaxy S7",2000,4888));
System.out.println("排序前："+list);
//排序
Collections.sort(list,new GoodsPriceComp());
System.out.println("排序后："+list);
}
}
输出结果：
排序前：
[商品名：iphone 5SE,收藏量1800,价格3888.0
,商品名：iphone 7,收藏量1998,价格5888.0
,商品名：Galaxy S7,收藏量2000,价格4888.0
]
排序后：
[商品名：iphone 7,收藏量1998,价格5888.0
,商品名：Galaxy S7,收藏量2000,价格4888.0
,商品名：iphone 5SE,收藏量1800,价格3888.0
]
3.3 TreeSet和TreeMap集合排序
3.3.1 TreeSet:
数据元素可以排序且不可以重复
- 确保元素实体可以排序
- 排序比较器
publicTreeSet(Compartor<? super E> comparator)
对比Set接口：HashSet,元素必须重写hashcode和equals方法。
去重:比较等于0即重复
例5：使用TreeSet无参构造实体类实现Comparable
/**
* 实体类实现Comparable
* @author qjc
*
* 2016-3-11
*/
public class Worker implements java.lang.Comparable<Worker>{
//工种
private String type;
//工资
private double salary;
//按工资升序
@Override
public int compareTo(Worker o) {
return this.salary>o.salary?1:this.salary==o.salary?0:-1;
}
//getter and setter..
} /**
* 使用Comparable排序
* @author qjc
*
* 2016-3-11
*/
public class TreeSetDemo2 {
public static void main(String[] args) {
Worker w1 = new Worker("教师",12000);
Worker w2 = new Worker("公务员",8000);
Worker w3 = new Worker("程序猿",6000);
TreeSet<Worker> employeess = new TreeSet<>();
employeess.add(w1);
employeess.add(w2);
employeess.add(w3);
System.out.println(employeess);
}
}
例6：使用TreeSet带参构造使用Comparator比较器
public class Person {
private String name;
//帅气指数
private int handsome;
//geter and setter..
}
/**
* 提供解耦方式排序
* @author qjc
*
* 2016-3-11
*/
public class TreeSetDemo {
public static void main(String[] args) {
Person p1 = new Person("刘德华", 2000);
Person p2 = new Person("梁朝伟", 2200);
Person p3 = new Person("鹿晗", 1500);
//依次放到TreeSet容器中，使用排序的业务类（内部类）
TreeSet<Person> persons = new TreeSet<>(
new java.util.Comparator<Person>(){
@Override
public int compare(Person o1, Person o2) {
//降序
return -(o1.getHandsome() - o2.getHandsome());
}
}
);
//TreeSet 在添加数据时排序
persons.add(p1);
persons.add(p2);
persons.add(p3);
System.err.println(persons);
}
}
注意：
在添加数据时排序，数据更改不会影响原来的顺序，不要修改数据，否则可能重复。 ---可以使用final修饰
3.3.2 TreeMap:
- 确保key可以排序
- 提供比较器
publicTreeMap(Comparator<? super K> comparator)
例：与TreeSet同理
总结：
相同点：
Comparable和Comparator都是用来实现集合、数组中元素的比较、排序的
不同点：
1、Comparable是在集合内部定义的方法实现的排序，而Comparator是在集合外部实现的排序，
所以，如想实现排序，就需要在集合外定义 Comparator接口的方法或在集合内实现 Comparable接口的方法。
Comparator位于包java.util下，而Comparable位于包java.lang下
2、Comparable是一个对象，本身就已经支持自比较所需要实现的接口（如Integer、String、Float、Double、Date等底层都实现了Comparable接口 自己就可以完成比较大小操作）
自定义的类要在加入list容器中后能够排序，可以实现Comparable接口，在用Collections类的sort方法排序时，如果不指定Comparator，那么就以自然顺序排序，这里的自然顺序就是实现Comparable接口设定的排序方式，并且是升序。
3、Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。
Comparator 与实体类分类于系统解耦优点，比如说例4按商品排序，如果需要按名称排序（或改升序、降序），只需要在业务类修改，在应变多变规则时方便程序修改和维护。所以推荐使用Comparator。