Comparable_Comparator_排序工具类JAVA124-125

来源：http://www.bjsxt.com/
1、S02E124_01内置引用类型比较Comparable排序工具类实现
“排序”的实体类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法
——public int comparaTo(Object obj);
该方法：
——返回0： 表示this == obj
——返回正数：表示this > obj
——返回负数：表示this < obj
实现了Comparable接口的类通过实现compareTo方法从而确定该类对象的排序方式。
（1）Integer、Long、Float、Double：直接比较基本数据类型的大小
（2）Character：比较unicode码之差
（3）String：如果其中一个是另外一个起始位置开始的子串，返回长度之差；否则返回第一个不相等的unicode码之差
（4）java.util.Date：根据日期的长整型数比较

package com.test.sort.comparable;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
 * Comparable接口compareTo方法
 */
public class Sort {

    /**
     * 数组排序(使用泛型方法)
     */
    public static <E extends Comparable<E>> void arraySort(E[] arr){
        System.out.println("*************数组排序*************");
        int len = arr.length;
        boolean issort = true;
        for (int i = 0; i < len - 1; i++) {//趟数
            issort = true;//假定有序
            for (int j = 0; j < len - 1 - i; j++) {//次数,-i减少每趟次数
                if(((E)arr[j]).compareTo(arr[j+1]) > 0){//从小到大排序
                    E temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                    issort = false;//有交换，假定失败
                }
            }
            if(issort){
                break;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    /**
     * 数组排序(Object数组)
     */
    public static void arraySort(Object[] arr){
        int len = arr.length;
        boolean issort = true;
        for (int i = 0; i < len - 1; i++) {//趟数
            issort = true;//假定有序
            for (int j = 0; j < len - 1 - i; j++) {//次数,-i减少每趟次数
                if(((Comparable)arr[j]).compareTo(arr[j+1]) > 0){//从小到大排序
                    Object temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                    issort = false;//有交换，假定失败
                }
            }
            if(issort){
                break;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    /**
     * 容器排序(使用泛型方法)
     */
    public static <T extends Comparable<T>> void collectionSort(List<T> list){
        System.out.println("+++++++++++++++++++容器排序+++++++++++++++++++++++");
        //第一步：转为数组
        Object[] arr = list.toArray();
        arraySort(arr);
        //第二步：改变容器中对应的值
        for (int i = 0; i < arr.length; i++) {
            list.set(i, (T)arr[i]);
        }
    }

    public static void main(String[] args) {
        String[] arr = {"a","abcd","abc","def"};
        Sort.arraySort(arr);

        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("abcd");
        list.add("abc");
        list.add("def");
        Sort.collectionSort(list);
    }
}

2、S02E125_01内置引用类型比较Comparator排序工具类实现
思考：很多排序规则
——淘宝商品：价格、点击量、名称等
——只有字节码没有源码
提供排序的比较器、业务比较器
——实现java.util.Comparator接口
——重写public int compare(T o1, T o2);
————返回0： 表示this == obj
————返回正数：表示this > obj
————返回负数：表示this < obj
作用：
——解耦：独立于实体类
——方便：便于应对各种排序规则

package com.test.sort.comparable;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
/**
 * Comparator接口
 */
public class ComparatorSort {

    /**
     * 数组排序(Object数组)升序 + Comparator接口
     */
    public static <T> void arraySort(Object[] arr,Comparator<T> com){
        int len = arr.length;
        boolean issort = true;
        for (int i = 0; i < len - 1; i++) {//趟数
            issort = true;//假定有序
            for (int j = 0; j < len - 1 - i; j++) {//次数,-i减少每趟次数
                if(com.compare((T)arr[j],(T)arr[j+1]) > 0){//从小到大排序
                    Object temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                    issort = false;//有交换，假定失败
                }
            }
            if(issort){
                break;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    /**
     * 容器排序(使用泛型方法)升序 + Comparator接口
     */
    public static <T> void collectionSort(List<T> list,Comparator<T> com){
        //第一步：转为数组
        Object[] arr = list.toArray();
        arraySort(arr,com);
        //第二步：改变容器中对应的值
        for (int i = 0; i < arr.length; i++) {
            list.set(i, (T)arr[i]);
        }
    }

    public static void main(String[] args) {
        String[] arr = {"a","abcd","abc","def"};
        System.out.println("+++++++++++++++++++数组排序 + Comparator接口+++++++++++++++++++++++");
        arraySort(arr,new StringComparator());

        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("abcd");
        list.add("abc");
        list.add("def");
        System.out.println("+++++++++++++++++++容器排序 + Comparator接口+++++++++++++++++++++++");
        ComparatorSort.collectionSort(list,new StringComparator());
    }
}
/**
 * 排序规则的业务类，按长度比较大小
 */
class StringComparator implements Comparator<String>{

    public int compare(String o1, String o2) {
        int len1 = o1.length();
        int len2 = o2.length();
        return len1 - len2;
    }
}

JAVA内部的Collections工具类提供了大量便于处理容器的方法

package com.test.sort.comparable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 使用JAVA内部的Collections工具类对容器的比较
 * <br>关于排序的方法：
 * <br>1、public static <T extends Comparable<? super T>> void sort(List<T> list)
 * <br>2、public static <T> void sort(List<T> list, Comparator<? super T> c)
 */
public class CollectionsSort {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("abcd");
        list.add("abc");
        list.add("def");
        List<String> list2 = new ArrayList<String>();
        list2 = list;
        Collections.sort(list);
        System.out.println("sort(list)" + list.toString());

        Collections.sort(list2, new StringComparator());
        System.out.println("sort(list2, new StringComparator())" + list2.toString());
    }
}
/**
 * 排序规则的业务类，按长度比较大小
 */
class StringComparator2 implements Comparator<String>{

    public int compare(String o1, String o2) {
        int len1 = o1.length();
        int len2 = o2.length();
        return -(len1 - len2);
    }
}