Java、检查顺序

package sort;
 
import java.util.Arrays;
import java.util.Comparator;
 
/**
 * @author: xyz
 * @create: 2022/8/15
 * @Description:
 * @FileName: Exercise23_05
 * @History:
 * @自定义内容：
 */
public class Exercise23_05 {
    public static void main(String[] args) {
        int[] list1 = new int[10];
        for (int i = list1.length - 1, j = 0; i >= 0; i--)
            list1[j++] = i;
        System.out.println(Arrays.toString(list1));
        System.out.println(ordered(list1));
 
        double[] list2 = new double[10];
        for (int i = 0; i < list2.length; i++)
            list2[i] = i;
        System.out.println(Arrays.toString(list2));
        System.out.println(ordered(list2));
 
        Integer[] list3 = new Integer[10];
        for (int i = 0; i < list3.length; i++)
            list3[i] = i;
        System.out.println(Arrays.toString(list3));
        System.out.println(ordered(list3, false));
 
        Double[] list4 = new Double[10];
        for (int i = 0; i < list4.length; i++)
            list4[i] = i * 1.0;
        System.out.println(Arrays.toString(list4));
        System.out.println(ordered(list4, new SortComparator<>()));
    }
 
    public static boolean ordered(int[] list) {
        return ordered(list, true);
    }
 
    public static boolean ordered(int[] list, boolean ascending) {
        double[] temp = new double[list.length];
 
        for (int i = 0; i < list.length; i++)
            temp[i] = list[i];
 
        return ordered(temp, ascending);
    }
 
    public static boolean ordered(double[] list) {
        return ordered(list, true);
    }
 
    public static boolean ordered(double[] list, boolean ascending) {
        for (int i = 0; i < list.length - 1; i++) {
            if (ascending) {
                if (list[i] > list[i + 1])
                    return false;
            } else {
                if (list[i] < list[i + 1])
                    return false;
            }
        }
 
        return true;
    }
 
    public static extends Comparable> boolean ordered(E[] list) {
        return ordered(list, true);
    }
 
    public static extends Comparable> boolean ordered(E[] list, boolean ascending) {
        for (int i = 0; i < list.length - 1; i++) {
            if (ascending) {
                if (list[i].compareTo(list[i + 1]) > 0)
                    return false;
            } else {
                if (list[i].compareTo(list[i + 1]) < 0)
                    return false;
            }
        }
 
        return true;
    }
 
    public static  boolean ordered(E[] list, Comparatorsuper E> comparator) {
        return ordered(list, comparator, true);
    }
 
    public static  boolean ordered(E[] list, Comparatorsuper E> comparator, boolean ascending) {
        for (int i = 0; i < list.length - 1; i++) {
            if (ascending) {
                if (comparator.compare(list[i], list[i + 1]) > 0)
                    return false;
            } else {
                if (comparator.compare(list[i], list[i + 1]) < 0)
                    return false;
            }
        }
 
        return true;
    }
 
    /** 静态内部类-泛型比较器类 */
    static class SortComparator implements Comparator {
        @Override
        public int compare(E o1, E o2) {
            if (o1 instanceof Comparable) {
                if (((Comparable) o1).compareTo(o2) > 0) return 1;
                else if (((Comparable) o1).compareTo(o2) < 0) return -1;
                else return 0;
            }
 
            //按哈希码排序
            if (o1.hashCode() > o2.hashCode())
                return 1;
            else if (o1.hashCode() < o2.hashCode())
                return -1;
            else
                return 0;
        }
    }
}