1

Consider I have this:

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) {
            /// ??????
        }        

    }

How can I sort my Integer array values using compareTo()?

4

3 回答 3

2

这将做：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};

于 2013-11-04T20:30:31.970 回答
2

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

但是，您不应该使用泛型类型，因为您知道您正在使用Integer. 你知道你有Integer，所以使用它。 Integerimplements 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;
}
于 2013-11-04T20:48:45.180 回答
1

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

对于泛型类型，在每次排序时Comparable重写类的compare()方法，提供对数组组件方法的访问。这是一个使用继承的快速实现和一个按升序或降序进行排序的选项：ComparatorcompareTo()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)。

于 2013-11-04T20:25:38.557 回答