JAVA学习日记----------排序篇02

JAVA学习日记----------排序篇02

“排序”的实体类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法

public int compareTo(Object obj);

返回0表示 this==obj

返回正数表示 this>obj

返回负数表示 this<obj

1.对于Integer类中的compare方法：

public static int compare(int x,int y){

return (x<y)?-1:((x==y)?0:1);

}根据基本数据类型大小比较

2.对于Character类中compare方法：

public static int compare(char x, char y) {

        return x - y;

    }根据Unicode编码顺序

3.对于String类中compare方法：

public int compareTo(String anotherString) {

        int len1 = value.length;

        int len2 = anotherString.value.length;

        int lim = Math.min(len1, len2);

        char v1[] = value;

        char v2[] = anotherString.value;

        int k = 0;

        while (k < lim) {

            char c1 = v1[k];

            char c2 = v2[k];

            if (c1 != c2) {

                return c1 - c2;

            }

            k++;

        }

        return len1 - len2;

    }先比较两个字符串的长度，取小的，然后将要比较的字符串分别放在两个数组中

遍历数组，如果有一个字符不相等，就返回这两个字符的Unicode编码之差，如果比

较的字符都相等，就返回两个字符串长度之差

4.对于Date类中compare方法：

public int compareTo(Date anotherDate) {

        long thisTime = getMillisOf(this);

        long anotherTime = getMillisOf(anotherDate);

        return (thisTime<anotherTime ? -1 : (thisTime==anotherTime ? 0 : 1));

    }获取时间的长整形数来比较

实际应用：

import java.util.Arrays;

import java.util.List;

public class Utils {

/**
* 用于数组排序(降序)
* 使用泛型方法
*/

public static <T extends Comparable<T>>void sort(T[] arr){
boolean sorted = true;
int len = arr.length;
for(int i = 0;i<len-1;i++){
sorted = true;
for(int j = 0;j<len-1-i;j++){
if(((Comparable)arr[j]).compareTo(arr[j+1])>0){
T temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
sorted = false;
}
}
if(sorted){
break;
}
}
System.out.println(Arrays.toString(arr));
}

/**
* 用于数组排序(降序)
*/

private static void sort(Object[] obj){
boolean sorted = true;
int len = obj.length;
for(int i = 0;i<len-1;i++){
sorted = true;
for(int j = 0;j<len-1-i;j++){
if(((Comparable)obj[j]).compareTo(obj[j+1])>0){
Object temp = obj[j];
obj[j] = obj[j+1];
obj[j+1] = temp;
sorted = false;
}
}
if(sorted){
break;
}
}
System.out.println(Arrays.toString(obj));
}

/**
* 用于容器排序(降序)
*/

public static <T extends Comparable<T>>void sort(List<T> list){
Object[] arr = list.toArray();
sort(arr);
for(int i = 0;i<arr.length;i++){
list.set(i,(T)arr[i]);
}
}

}