Question

考虑一下我有这个：

class Sort {

private Integer[] intArray = {30,20,50,100,1,2,6,1,3,5};

Sort() {

    sortObject(intArray);
}

 public <T extends Comparable<T>> void sortObject(T[] array) {

    T el = array[0];

    for(T elements : array) {
        if(el.compareTo(elements)<0) {
            /// ??????
        }        

    }

如何使用compareTo（）？

对Integer数组值进行排序

Answer 1

这样做：Arrays.sort(intArray).

如果你想做反向排序，即按降序排序，而不是如下：

Arrays.sort(a, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2-o1;
        }
    });

其中a为Integer[] a = {1, 3, 2, 7, 9, 11};

Answer 2

您是否正在尝试Arrays.sort(Object[])做什么？然后，你真正需要的是一本关于算法的书，然后你应该看看各种实现：冒泡，插入，快速，Shell，堆等.Java有自己的算法，它在某处记录。

但是，您不应该使用泛型类型，因为您知道自己正在使用Integer。你知道你有Integer，所以要使用它。 Integer实现了Comparable，因此不需要额外的声明。

class SortExample {

    private Integer[] intArray = {30,20,50,100,1,2,6,1,3,5};

    SortExample() {
        System.out.println("Before sort " + Arrays.toString(intArray));
        sortObject(intArray);
        System.out.println("After  sort " + Arrays.toString(intArray));
    }

    public void sortObject(Integer[] array) {
        Arrays.sort(intArray);
    }

}

如果要测试使用的算法，请替换sortObject方法。对于冒泡排序，请使用：

// Figure out how efficient your algorithm is.
private int numberSwaps = 0;

public void sortObject(Integer[] array) {
    final int last = array.length - 1;
    for (int end = last; end > 0; end--) {
        for (int i = 1; i <= end; i++) {
            // No need for compareTo here; it does exactly the same thing.
            if (array[i] < array[i-1]) {
                swap(array, i, i-1);
                numberSwaps++;
            }
        }
    }
    System.out.println("Needed " + numberSwaps + " swaps.");
}

private void swap(Integer[] array], int from, int to) {
    int temp = array[from];
    array[from] = array[to];
    array[to] = temp;
}

Answer 3

compareTo()元素的单个Comparable方法不能被覆盖，除非定义一个单独的子类到Comparable并且仅将排序应用于该子类的实例。

对于通用Comparable类型，在每次排序时覆盖compare()类的Comparator方法，可以访问数组组件的compareTo()方法。以下是使用Java继承的快速实现，以及按升序或降序排序的选项：

import java.util.Arrays;
import java.util.Comparator;

public class ArraySorter
{
    private ArraySorter()
    {
    }

    public static <T extends Comparable<T>> void sort(
        final T[] array, final boolean ascending)
    {
        Arrays.sort(array, new Comparator<T>()
        {
            @Override
            public int compare(T o1, T o2)
            {
                return (ascending?o1.compareTo(o2):o2.compareTo(o1));
            }
        });
    }

    public static void main(String[] args)
    {
        Integer[] intArray = {30,20,50,100,1,2,6,1,3,5};

        System.out.println("UNSORTED:   " + Arrays.asList(intArray));

        ArraySorter.sort(intArray, true);

        System.out.println("ASCENDING:  " + Arrays.asList(intArray));

        ArraySorter.sort(intArray, false);

        System.out.println("DESCENDING: " + Arrays.asList(intArray));
    }
}

使用sort()值运行上面的静态intArray方法，作为main()类的ArraySorter方法，生成以下输出：

UNSORTED:   [30, 20, 50, 100, 1, 2, 6, 1, 3, 5]
ASCENDING:  [1, 1, 2, 3, 5, 6, 20, 30, 50, 100]
DESCENDING: [100, 50, 30, 20, 6, 5, 3, 2, 1, 1]

当然，对于升序，上述结果与仅调用Arrays.sort(intArray)相同。

如何使用可比较的数组排序？

3 个答案: