java中 Arrays.sort()这个函数 我想用它API中提供的sort(T[] a, Comparator<? super T> c)

Posted 2023-03-31

import java.util.Arrays;
import java.util.Comparator;
public class array

/**
* @param args
*/
public static void main(String[] args)
// TODO Auto-generated method stub
int [] arr=new int[10];
com c=new com<Integer>();
//Integer a=new Integer(5);

int len=arr.length;
for(int i=0;i<len;i++)

arr[i]=5-i;

// Arrays.sort(ArrayList<in>(arr),new com());
arr=Arrays.sort(arr,c);

for(int a : arr)

System.out.println(a);




import java.util.Comparator;

public class com<T> implements Comparator<T>

public int compare(T o1, T o2)
int i = Integer.parseInt(String.valueOf(o1));
int j = Integer.parseInt(String.valueOf(o2));
if (i > j)
return -1;
if (i < j)
return 1;
return 0;

楼主，你的程序思想没有错，只是在细节问题上出错了，
在使用泛型时注意：任何基本类都不能作为类型参数。虽然从Java SE 5.0开始使用了自动包装机制，包装机制解决了一些问题，但不是所有问题都能解决。
自动包装机制不能用于数组，因此无法工作。
至于Comparator和Comparable接口，给你一个简单的区分 ，Comparator接口是比较器，comparable 接口（能比较的，也就是默认的比较器比较，自然顺序）。
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。 参考技术A import java.util.Arrays;
import java.util.Comparator;

public class ArraySort
public static void main(String[] args)
Integer[] arr=new Integer[10];
Comp<Integer> c=new Comp<Integer>();

int len=arr.length;
for(int i=0;i<len;i++)
arr[i]=5-i;

Arrays.sort(arr,c);

for(Integer a : arr)
System.out.println(a);




class Comp<T> implements Comparator<T>
public int compare(T o1, T o2)
return ((Integer)o1).compareTo( (Integer)o2 );

追问

我想知道为什么我的方法不行呢？

追答

是同样的方法。

关于Java中Collections.sort和Arrays.sort的稳定性问题

一 问题的提出

??关于Java中Collections.sort和Arrays.sort的使用,需要注意的是,在本文中,比较的只有Collections.sort(List<T> elements)和Arrays.sort(int[] var0).
??对这个问题产生兴趣是因为这两者使用的时候稳定性是有差异的,那么稳定性究竟为什么有差异呢?刚开始令我好奇的是Collections.sort的源码中竟然也使用到了Arrays.sort.

二 代码分析

??Arrays.sort的源代码如下

public static void sort(int[] var0) {
        DualPivotQuicksort.sort(var0, 0, var0.length - 1, (int[])null, 0, 0);

这里的DualPivotQuicksort其实就是对传统的快排算法进行改进的快排,区别就是将数组切成了三段.
??Collections.sort的源代码如下

    default void sort(Comparator<? super E> var1) {
        Object[] var2 = this.toArray();
        Arrays.sort(var2, var1);
        ListIterator var3 = this.listIterator();
        Object[] var4 = var2;
        int var5 = var2.length;

        for(int var6 = 0; var6 < var5; ++var6) {
            Object var7 = var4[var6];
            var3.next();
            var3.set(var7);
        }
    }

这里会明显看见调用了Arrays.sort,但是只要到Arrays中去仔细看,会发现其实是不同的.

    public static <T> void sort(T[] var0, Comparator<? super T> var1) {
        if (var1 == null) {
            sort(var0);
        } else if (Arrays.LegacyMergeSort.userRequested) {
            legacyMergeSort(var0, var1);
        } else {
            TimSort.sort(var0, 0, var0.length, var1, (Object[])null, 0, 0);
        }
    }

到了这里,其实大致也就清楚了,对于TimSort.sort其实就是一个相对于legacyMergeSort性能更加好的归并排序.

三 总结

对于Arrays.sort(int[] var0)使用的是快排,所以是不稳定的.
对于Collections.sort(List<T> elements)使用的是归并排序,是稳定的.