一、參考
二、知識點
1、使用場景：排序、分組
2、使用方法：
2.1 、Arrays.sort(T[],Comparator<? super T> c);
2.2、 Collections.sort(List<T> list,Comparator<? super T> c);
3、區別：
3.1 、Comparator相當於給一個數組或列表新增一種比較方式
3.2 、Comparable是接口需要被類繼承的，相當於本身這個數組或者列表及類就有這種比較方式。後面有詳細是有案例
三、案例
1、OrderBean訂單類
1.1、繼承了Comparable這個藉口，有個簡單的比較，升序的
//訂單
public class OrderBean implements Comparable<OrderBean>{
private int id; //id
private String cdate; //創建時間
private String product; //產品名稱
private int weight; //重量
private long price; //價格
public OrderBean(int id, String cdate, String product, int weight, long price) {
this.id = id;
this.cdate = cdate;
this.product = product;
this.weight = weight;
this.price = price;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCdate() {
return cdate;
}
public void setCdate(String cdate) {
this.cdate = cdate;
}
public String getProduct() {
return product;
}
public void setProduct(String product) {
this.product = product;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
public long getPrice() {
return price;
}
public void setPrice(long price) {
this.price = price;
}
@Override
public String toString() {
return "\nOrder_"+id+": ["
+ "cdate="+cdate+", "
+ "product="+product+", "
+ "weight="+weight+" KG, "
+ "price="+price+" RMB, "
+ "]";
}
/**
* 按照weight升序
* sort的話默認調用
* */
public int compareTo(OrderBean o) {
return weight - o.getWeight();
}
}
2、Comparable接口使用
2.1、如果bean類繼承Comparable接口，那麼它的集合使用Collections.sort(list);可以默認調用bean類中複寫的compareTo這個方法，進行排序
2.2、也可以使用compareTo單獨比較兩個類
private void testComparable() {
System.out.println("\n\n testComparable()>>>");
OrderBean order1 = new OrderBean(1,"2018-01-01","牛肉",10,300);
OrderBean order2 = new OrderBean(5,"2018-01-01","怪獸肉",80,400);
OrderBean order3 = new OrderBean(2,"2018-02-01","牛肉",100,300);
OrderBean order4 = new OrderBean(9,"2018-03-01","唐僧肉",2,600);
List<OrderBean> list = new ArrayList<OrderBean>();
list.add(order1);
list.add(order2);
list.add(order3);
list.add(order4);
// weight升序排列
Collections.sort(list);
System.out.println("按照訂單的weight升序排列：" + list);
System.out.println("比較1和3："+order1.compareTo(order3));
}
testComparable()>>>
按照訂單的weight升序排列：[
Order_9: [cdate=2018-03-01, product=唐僧肉, weight=2 KG, price=600 RMB, ],
Order_1: [cdate=2018-01-01, product=牛肉, weight=10 KG, price=300 RMB, ],
Order_5: [cdate=2018-01-01, product=怪獸肉, weight=80 KG, price=400 RMB, ],
Order_2: [cdate=2018-02-01, product=牛肉, weight=100 KG, price=300 RMB, ]]
比較1和3：-90
3、Comparator比較器的使用
3.1、排序：大於、小於、等於
3.2、分組：等於、不等於
private void testComparator() {
System.out.println("\n\n testComparator()>>>");
OrderBean order1 = new OrderBean(1,"2018-01-01","牛肉",10,300);
OrderBean order2 = new OrderBean(5,"2018-01-01","怪獸肉",80,400);
OrderBean order3 = new OrderBean(2,"2018-02-01","牛肉",100,300);
OrderBean order4 = new OrderBean(9,"2018-03-01","唐僧肉",2,600);
List<OrderBean> list = new ArrayList<OrderBean>();
list.add(order1);
list.add(order2);
list.add(order3);
list.add(order4);
/**
* ----------------排列-----------------
* 大於、小於、等於
* */
//id降序排列
Collections.sort(list, new Comparator<OrderBean>() {
public int compare(OrderBean o1, OrderBean o2) {
return o2.getId() - o1.getId();
}
});
System.out.println("按照訂單的id降序排列："+list);
//單價升序排列
Collections.sort(list, new Comparator<OrderBean>() {
public int compare(OrderBean o1, OrderBean o2) {
return (int)(o1.getPrice()/o1.getWeight() - o2.getPrice()/o2.getWeight());
}
});
System.out.println("按照訂單的單價升序排列："+list);
System.out.println("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\");
/**
* ----------------分組-----------------
* 等於、不等於
* */
List<List<OrderBean>> byDate = divider(list,new Comparator<OrderBean>() {
public int compare(OrderBean o1, OrderBean o2) {
return o1.getCdate().equals(o2.getCdate()) ? 0:1;
}
});
for(int i=0;i<byDate.size();i++) {
System.out.println("按照訂單的cdate分組【"+i+"】："+byDate.get(i));
}
}
testComparator()>>>
按照訂單的id降序排列：[
Order_9: [cdate=2018-03-01, product=唐僧肉, weight=2 KG, price=600 RMB, ],
Order_5: [cdate=2018-01-01, product=怪獸肉, weight=80 KG, price=400 RMB, ],
Order_2: [cdate=2018-02-01, product=牛肉, weight=100 KG, price=300 RMB, ],
Order_1: [cdate=2018-01-01, product=牛肉, weight=10 KG, price=300 RMB, ]]
按照訂單的單價升序排列：[
Order_2: [cdate=2018-02-01, product=牛肉, weight=100 KG, price=300 RMB, ],
Order_5: [cdate=2018-01-01, product=怪獸肉, weight=80 KG, price=400 RMB, ],
Order_1: [cdate=2018-01-01, product=牛肉, weight=10 KG, price=300 RMB, ],
Order_9: [cdate=2018-03-01, product=唐僧肉, weight=2 KG, price=600 RMB, ]]
\\\\\\\\\\\\\\\\\\
按照訂單的cdate分組【0】：[
Order_2: [cdate=2018-02-01, product=牛肉, weight=100 KG, price=300 RMB, ]]
按照訂單的cdate分組【1】：[
Order_5: [cdate=2018-01-01, product=怪獸肉, weight=80 KG, price=400 RMB, ],
Order_1: [cdate=2018-01-01, product=牛肉, weight=10 KG, price=300 RMB, ]]
按照訂單的cdate分組【2】：[
Order_9: [cdate=2018-03-01, product=唐僧肉, weight=2 KG, price=600 RMB, ]]
分組工具方法
/**
* @author wujn
* @Description:按條件分組
* @param datas
* @param c
* 是否爲同一組的判斷標準 0 爲同一組，1爲不同組
* @return
*/
public static <T> List<List<T>> divider(Collection<T> datas, Comparator<? super T> c) {
List<List<T>> result = new ArrayList<List<T>>();
for (T t : datas) {
boolean isSameGroup = false;
for (int j = 0; j < result.size(); j++) {
if (c.compare(t, result.get(j).get(0)) == 0) {
isSameGroup = true;
result.get(j).add(t);
break;
}
}
if (!isSameGroup) {
// 創建
List<T> innerList = new ArrayList<T>();
result.add(innerList);
innerList.add(t);
}
}
return result;
}