Java 按字典顺序对int数组进行排序

我遇到了这样一个问题：

WAP对小于给定N的素数进行数字排序。如果N是40， 输出应该是11、13、17、19、2、23、29、3、31、37、39、5、7。 注意：限制内存使用

获得主要号码很容易。但我无法找到一种有效的整数数组字典排序方法

public static void getPrimeNumbers(int limit) {
        for (int i=2; i<=limit; i++) {
            if(isPrime(i)) {
                System.out.println(i);
            }
        }
    }

    public static boolean isPrime(int number) {
        for(int j=2; j<number; j++) {
            if(number%j==0) {
                return false;
            }
        }
            return true;
    }

    public static void lexographicSorting() {
        int[] input = {2,3,5,7,11,13,17,19};
        int[] output = {};
        for (int i=0; i<input.length; i++) {
            for(int j=0; j<input.length; j++) {
                ////Stuck at this part.
            }
        }
    }

publicstaticvoidgetprimenumbers（int限制）{
对于（int i=2；i而言，唯一可能的方法是实现您自己的
比较器
，其中您将两个可比较的
整数
-s转换为
字符串
对象，并对其进行比较

UPD:下面是一个示例，如何实现它：

    Integer[] input = {2,3,5,7,11,13,17,19};

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

Integer[]输入={2,3,5,7,11,13,17,19}；
sort（输入，新的比较器（）{
@凌驾
公共整数比较（整数o1，整数o2）{
返回o1.toString（）.compareTo（o2.toString（））；
}
});
Java已经实现了这个功能，通过将整数对象转换为字符串对象并调用
compareTo

Arrays.sort(input, new Comparator<Integer>() {
   @Override
   int compareTo( Integer x, Integer y ) {
      return x.toString().compareTo( y.toString() );
   }
};

Arrays.sort（输入，新比较器（）{
@凌驾
整数比较（整数x，整数y）{
返回x.toString（）.compareTo（y.toString（））；
}
};

我可以确切地说这会有多大的内存效率，你必须为数组中的每个基本整数创建一个整数对象，然后你必须为每个整数对象创建一个字符串对象。因此，在对象创建过程中可能会有大量的开销。
如果你不想将整数值转换为字符串（这可能是浪费），你可以这样做

你可以根据最重要的数字对数字进行排序。有关计算数字的最重要数字的信息，请参阅本文：（移植到Java应该很容易）

基本上，您可以将该函数用作比较器的一部分。您需要一种断开连接的方法（例如，具有相同最高有效位的数字）。如果两个数字具有相同的最高有效位，您可以将其拔出，并根据需要多次重新调用该函数（直到您认为一个数字大于另一个数字，或者直到您用完数字，表示它们相等）.
考虑到问题的限制，解决此问题的更有效方法是根本不使用字符串和整数实例。问题的一个指示是限制内存使用。到目前为止，每个答案都对内存产生了重大影响（在
整数
和
字符串
之间进行转换）

这是一个可能更快的解决方案，并且根本不分配堆内存（尽管它有递归，所以可能会有一些堆栈效应-与
Arrays.sort（）差不多
）。这从第一原理解决了问题，它没有为结果分配单独的数组，因此，与其他解决方案相比，它相对较长，但这些其他解决方案隐藏了该解决方案所不具备的大量复杂性

// this compare works by converting both values to be in the same 'power of 10',
// for example, comparing 5 and 20, it will convert 5 to 50, then compare 50 and 20
// numerically.
public static final int compareLexographicallyToLimit(final int limit, int a, int b) {
    if (a == b) {
        return 0;
    }
    if (a > limit || b > limit || a < 0 || b < 0) {
        return a > b ? 1 : -1;
    }

    int max = Math.max(a, b);
    int nextp10 = 1;
    while (max > 10) {
        max /= 10;
        nextp10 *= 10;
    }
    while (a < nextp10) {
        a *= 10;
    }
    while (b < nextp10) {
        b *= 10;
    }
    return a > b ? 1 : -1;
}

private static void sortByRules(final int[] input, final int limit, final int from, final int to) {
    if (from >= to) {
        return;
    }
    int pivot = from;
    int left = from + 1;
    int right = to;
    while (left <= right) {
        while (left <= right && compareLexographicallyToLimit(limit, input[left], input[pivot]) <= 0) {
            left++;
        }
        while (left <= right && compareLexographicallyToLimit(limit, input[pivot], input[right]) <= 0) {
            right--;
        }
        if (left < right) {
            int tmp = input[left];
            input[left] = input[right];
            input[right] = tmp;
            left++;
            right--;
        }
    }
    int tmp = input[pivot];
    input[pivot] = input[right];
    input[right] = tmp;
    sortByRules(input, limit, from, right-1);
    sortByRules(input, limit, right+1, to);

}

public static void main(String[] args) {
    int[] input = {2,3,5,7,11,13,17,19,31,37,41, 43, 100};
    sortByRules(input, 40, 0, input.length - 1);
    System.out.println(Arrays.toString(input));
    sortByRules(input, 15, 0, input.length - 1);
    System.out.println(Arrays.toString(input));
}

//此比较通过将两个值转换为相同的“10次方”来工作，
//例如，比较5和20，它会将5转换为50，然后比较50和20
//数字上。
公共静态最终整数比较XoGraphicalyToLimit（最终整数限制、整数a、整数b）{
如果（a==b）{
返回0；
}
如果（a>极限| | b>极限| | a<0 | | b<0）{
返回a>b？1:-1；
}
int max=数学最大值（a，b）；
int nextp10=1；
同时（最大值>10）{
最大/=10；
nextp10*=10；
}
而（ab？1:-1；
}
私有静态void排序规则（final int[]输入、final int限制、final int from、final int to）{
如果（从>=到）{
返回；
}
int-pivot=从；
int left=from+1；
int right=to；
（左仅添加到Hunter-McMillen答案中，Java 8的语法允许以更干净、更精简的方式定义
ComnPartitor
没有使用
比较器的重载变量，为了使用
比较器
，需要装箱数组。例如：

int[] output =
    Arrays.stream(input)
          .boxed()
          .sorted(Comparator.comparing(String::valueOf))
          .mapToInt(Integer::intValue)
          .toArray();

-“唯一可能的方法”——我可以想出很多很多方法，有些方法比这更有效。@rolfl只是想把我带上来？你可以想你想要的一切。我说了我所说的。如果你知道“更有效”的方法，介绍它并演示。获取Eclipse错误
方法排序（int[]）在类型中，数组不适用于参数（int[]，new Comparator（）{}）
@HimanshuYadav当然，您必须将
int
更改为
Integer
。请更仔细地查看我的代码，它使用
Integer
数组引入了一种更有效的方法…并演示了它。我的eclipse正在抛出
方法排序（int[]）在类型中，数组不适用于参数（int[]，new Comparator（）{}）
error。