java进阶--Java中comparator及comparable完全解析

comparator具体用法

class Weapon {
int len;
int pow;
public Weapon(int len, int pow) {
this.len = len;
this.pow = pow;
}
//weapon 两个值，一个len，一个pow
}

class WeaponComparator implements Comparator<Weapon>
{
@Override
public int compare(Weapon o1, Weapon o2) {
if(o1.pow<o2.pow)
return 1;
//返回1表示当    o1.pow<o2.pow时，o1会在o2的后面，o2会排在前面。后面会详细解析为什么。

if(o1.pow==o2.pow)
{
//在pow相同的情况下，按len的大小从小到大排序
if(o1.len>o2.len)
{
return 1;

}
if(o1.len==o2.len) {
return 0;
}
return -1;
}
return -1;
}
}

public class ComparatorTest {

public static void main(String[] args) {

int arr[][]={{1,2},{2,3},{1,3},{2,2},{3,4},{2,4}};
Weapon weapons[]=new Weapon[arr.length];
for(int i=0;i<arr.length;i++)
{
weapons[i]=new Weapon(arr[i][0], arr[i][1]);
}
//生成一个weapon数组
WeaponComparator wComparator=new WeaponComparator();
//定义一个比较器
Arrays.sort(weapons,wComparator );
//Arrays.sort(weapons,wComparator );对weapons进行排序
for(int i=0;i<arr.length;i++)
{
System.out.println(weapons[i].pow+"    "+weapons[i].len);
}
}
}

//输出
/*
weapon  len
4       2
4       3
3       1
3       2
2       1
2       2
*/

深入理解comparator

public interface Comparator<T> {

int compare(T o1, T o2);

boolean equals(Object obj);

}

public static <T> void sort(T[] a, Comparator<? super T> c) {
T[] aux = a.clone();
mergeSort(aux, a, 0, a.length, c);
}

private static void mergeSort(Object[] src,
Object[] dest,
int low, int high, int off,
Comparator c) {
int length = high - low;

// 如果数组的长度小于7时就使用插入排序
if (length < 7) {
for (int i=low; i<high; i++)
for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
swap(dest, j, j-1);
return;
//在插入排序中的判断大小的方法原来就是自定义的comparator中的compare方法
//c.compare(dest[j-1], dest[j])>0
}

//如果长度大于7就递归的对其左右进行排序
int destLow  = low;
int destHigh = high;
low  += off;
high += off;
int mid = (low + high) >>> 1;
mergeSort(dest, src, low, mid, -off, c);
mergeSort(dest, src, mid, high, -off, c);

// 如果排好序的左边的最大元素小于排好序的右边的最小元素则可以知道从low到high都已经排好序了
//直接复制到src数组中就行了
if (c.compare(src[mid-1], src[mid]) <= 0) {
System.arraycopy(src, low, dest, destLow, length);
return;
}

//否则还是利用自定义的comparator中的compare方法来比较大小，对将左右两边的数组进行合并排序
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}
}

private static void swap(Object[] x, int a, int b) {
Object t = x[a];
x[a] = x;
x[b] = t;
}

if (c.compare(src[mid-1], src[mid]) <= 0)

[b]Comparable

//weapon直接实现了Comparable接口并且重写了compareTo方法，比较逻辑在compareTo方法里。
class Weapon implements Comparable<Weapon>
{
int len;
int pow;
public Weapon(int len, int pow) {
this.len = len;
this.pow = pow;
}
@Override
public int compareTo(Weapon o) {
if(this.pow<o.pow)
return 1;
if(this.pow==o.pow)
{
if(this.len>o.len)
{
return 1;
}
if(this.len==o.len) {
return 0;
}
return -1;
}
return -1;

}

//直接调用Arrays.sort(weapons);就可以完成对weapon排序。
public class ComparableTest {

public static void main(String[] args) {
int arr[][]={{1,2},{2,3},{1,3},{2,2},{3,4},{2,4}};
Weapon weapons[]=new Weapon[arr.length];
for(int i=0;i<arr.length;i++)
{
weapons[i]=new Weapon(arr[i][0], arr[i][1]);
}
Arrays.sort(weapons);
for(int i=0;i<arr.length;i++)
{
System.out.println(weapons[i].pow+"    "+weapons[i].len);
}
}

}