排序整数的顺序最低到最高的java。

These numbers are stored in the same integer variable. How would I go about sorting the integers in order lowest to highest?

这些数字存储在同一个整型变量中。我该如何对整数进行排序，从最低到最高?

11367
11358
11421
11530
11491
11218
11789

6 个解决方案

#1

There are two options, really:

有两个选择，真的:

1. Use standard collections, as explained by Shakedown
2. 使用标准集合，如Shakedown所述
3. Use Arrays.sort
4. 使用Arrays.sort

E.g.,

例如,

int[] ints = {11367, 11358, 11421, 11530, 11491, 11218, 11789};
Arrays.sort(ints);
System.out.println(Arrays.asList(ints));

That of course assumes that you already have your integers as an array. If you need to parse those first, look for String.split and Integer.parseInt.

当然，这是假设整数已经是数组了。如果需要首先解析它们，请查找字符串。分裂和Integer.parseInt。

#2

You can put them into a list and then sort them using their natural ordering, like so:

你可以把它们放在一个列表中，然后使用它们的自然排序，比如:

final List<Integer> list = Arrays.asList(11367, 11358, 11421, 11530, 11491, 11218, 11789);
Collections.sort( list );
// Use the sorted list

If the numbers are stored in the same variable, then you'll have to somehow put them into a List and then call sort, like so:

如果这些数字存储在同一个变量中，那么你必须将它们放入一个列表，然后调用sort，如下所示:

final List<Integer> list = new ArrayList<Integer>();
list.add( myVariable );
// Change myVariable to another number...
list.add( myVariable );
// etc...

Collections.sort( list );
// Use the sorted list

• Collections.sort( List )
• 集合。sort(列表)

#3

Well, if you want to do it using an algorithm. There are a plethora of sorting algorithms out there. If you aren't concerned too much about efficiency and more about readability and understandability. I recommend Insertion Sort. Here is the psudo code, it is trivial to translate this into java.

如果你想用算法来做。有很多排序算法。如果你不太关心效率，而更关心可读性和可理解性。我建议插入排序。这里是psudo代码，将其转换为java很简单。

begin
    for i := 1 to length(A)-1 do
    begin
        value := A[i];
        j := i - 1;
        done := false;
        repeat
            { To sort in descending order simply reverse
              the operator i.e. A[j] < value }
            if A[j] > value then
            begin
                A[j + 1] := A[j];
                j := j - 1;
                if j < 0 then
                    done := true;
            end
            else
                done := true;
        until done;
        A[j + 1] := value;
    end;
end;

#4

For sorting narrow range of integers try Counting sort, which has a complexity of O(range + n), where n is number of items to be sorted. If you'd like to sort something not discrete use optimal n*log(n) algorithms (quicksort, heapsort, mergesort). Merge sort is also used in a method already mentioned by other responses Arrays.sort. There is no simple way how to recommend some algorithm or function call, because there are dozens of special cases, where you would use some sort, but not the other.

为了对较小的整数范围进行排序，可以尝试计数排序，它的复杂度是O(范围+ n)，其中n是要排序的项的数量。如果你想对某些东西进行排序，不要使用最优的n*log(n)算法(快速排序、堆排序、归并排序)。Merge sort也用于其他响应array .sort已经提到的方法中。没有简单的方法来推荐一些算法或函数调用，因为有许多特殊情况，您可以使用某种类型，而不是另一种。

So please specify the exact purpose of your application (to learn something (well - start with the insertion sort or bubble sort), effectivity for integers (use counting sort), effectivity and reusability for structures (use n*log(n) algorithms), or zou just want it to be somehow sorted - use Arrays.sort :-)). If you'd like to sort string representations of integers, than u might be interrested in radix sort....

因此，请指定您的应用程序的确切用途(以学习一些东西(从插入排序或冒泡排序开始)、整数的有效性(使用计数排序)、有效性和结构的可重用性(使用n*log(n)算法)，或zou只是希望它以某种方式排序——使用数组。:-))。如果你想排序字符串表示的整数,比你可能在基数排序interrested ....

#5

if array.sort doesn't have what your looking for you can try this:

如果数组。排序没有你想要的你可以试试这个:

package drawFramePackage;
import java.awt.geom.AffineTransform;
import java.util.ArrayList;
import java.util.ListIterator;
import java.util.Random;
public class QuicksortAlgorithm {
    ArrayList<AffineTransform> affs;
    ListIterator<AffineTransform> li;
    Integer count, count2;
    /**
     * @param args
     */
    public static void main(String[] args) {
        new QuicksortAlgorithm();
    }
    public QuicksortAlgorithm(){
        count = new Integer(0);
        count2 = new Integer(1);
        affs = new ArrayList<AffineTransform>();
        for (int i = 0; i <= 128; i++){
            affs.add(new AffineTransform(1, 0, 0, 1, new Random().nextInt(1024), 0));
        }
        affs = arrangeNumbers(affs);
        printNumbers();
    }
    public ArrayList<AffineTransform> arrangeNumbers(ArrayList<AffineTransform> list){
        while (list.size() > 1 && count != list.size() - 1){
            if (list.get(count2).getTranslateX() > list.get(count).getTranslateX()){
                list.add(count, list.get(count2));
                list.remove(count2 + 1);
            }
            if (count2 == list.size() - 1){
                count++;
                count2 = count + 1;
            }
            else{
            count2++;
            }
        }
        return list;
    }
    public void printNumbers(){
        li = affs.listIterator();
        while (li.hasNext()){
            System.out.println(li.next());
        }
    }
}

#6

Take Inputs from User and Insertion Sort. Here is how it works:

从用户和插入排序中获取输入。它是这样工作的:

package com.learning.constructor;

import java.util.Scanner;



public class InsertionSortArray {

public static void main(String[] args) {    

Scanner s=new Scanner(System.in);

System.out.println("enter number of elements");

int n=s.nextInt();


int arr[]=new int[n];

System.out.println("enter elements");

for(int i=0;i<n;i++){//for reading array
    arr[i]=s.nextInt();

}

System.out.print("Your Array Is: ");
//for(int i: arr){ //for printing array
for (int i = 0; i < arr.length; i++){
    System.out.print(arr[i] + ",");

}
System.out.println("\n");        

    int[] input = arr;
    insertionSort(input);
}

private static void printNumbers(int[] input) {

    for (int i = 0; i < input.length; i++) {
        System.out.print(input[i] + ", ");
    }
    System.out.println("\n");
}

public static void insertionSort(int array[]) {
    int n = array.length;
    for (int j = 1; j < n; j++) {
        int key = array[j];
        int i = j-1;
        while ( (i > -1) && ( array [i] > key ) ) {
            array [i+1] = array [i];
            i--;
        }
        array[i+1] = key;
        printNumbers(array);
    }
}

}