用Java对数组排序_编程黑洞网

我正在尝试制作一个由10个整数组成的程序，到目前为止，它们都具有随机值。

但是，现在我需要按从低到高的顺序对它们进行排序值，然后将其打印到屏幕上，我该怎么做呢？

（很抱歉，对于这么小的程序，我的代码太少了，我对循环不好，所以才开始工作） Java）

public static void main(String args[])
{
    int [] array = new int[10];

    array[0] = ((int)(Math.random()*100+1));
    array[1] = ((int)(Math.random()*100+1));
    array[2] = ((int)(Math.random()*100+1));
    array[3] = ((int)(Math.random()*100+1));
    array[4] = ((int)(Math.random()*100+1));
    array[5] = ((int)(Math.random()*100+1));
    array[6] = ((int)(Math.random()*100+1));
    array[7] = ((int)(Math.random()*100+1));
    array[8] = ((int)(Math.random()*100+1));
    array[9] = ((int)(Math.random()*100+1));

    System.out.println(array[0] +" " + array[1] +" " + array[2] +" " + array[3]
    +" " + array[4] +" " + array[5]+" " + array[6]+" " + array[7]+" " 
    + array[8]+" " + array[9] );        

}

Java 8：stackoverflow.com/a/47811965/1216775

#1 楼

循环对于学习也是非常有用的，尤其是在使用数组时，

int[] array = new int[10];
Random rand = new Random();
for (int i = 0; i < array.length; i++)
    array[i] = rand.nextInt(100) + 1;
Arrays.sort(array);
System.out.println(Arrays.toString(array));
// in reverse order
for (int i = array.length - 1; i >= 0; i--)
    System.out.print(array[i] + " ");
System.out.println();

#2 楼

在println之前添加一行，然后对数组进行排序

Arrays.sort( array );

我可以举个例子说明如何在程序中使用它吗？

–卢卡斯
2012年1月20日7:55

#3 楼

它可以通过实现自己来帮助您理解循环。请参阅气泡排序易于理解：

public void bubbleSort(int[] array) {
    boolean swapped = true;
    int j = 0;
    int tmp;
    while (swapped) {
        swapped = false;
        j++;
        for (int i = 0; i < array.length - j; i++) {
            if (array[i] > array[i + 1]) {
                tmp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = tmp;
                swapped = true;
            }
        }
    }
}

当然，您不应该在生产中使用它，因为对于大型列表（例如QuickSort或MergeSort），有更好的性能算法，由Arrays.sort(array)实现

BubbleSort绝对是适合初学者学习的好算法，但是正如您提到的，QuickSort或MergeSort在较大的数据集上的性能要好得多，因此，Arrays.sort（array）方法使用的算法就是这个原因。感谢您为可能尚未意识到的任何人提及此问题。

– h0r53
18年6月11日在13:47

我赞成这个答案，因为初学者很可能会搜索它，并且初学者应该知道如何自己实现排序功能。

–卡尔姆
19年1月14日在10:25

由于最初的问题是对10个整数数组进行排序，因此冒泡排序是完全可以接受的。如果不期望有更大的投入，则是否进行生产。

–安德鲁（Andrew）
19年5月18日在21:06

#4 楼

看看Arrays.sort（）

我可以举个例子说明如何在程序中使用它吗？

–卢卡斯
2012年1月20日7:55

#5 楼

我很懒，并添加了循环

import java.util.Arrays;


public class Sort {
    public static void main(String args[])
    {
        int [] array = new int[10];
        for ( int i = 0 ; i < array.length ; i++ ) {
            array[i] = ((int)(Math.random()*100+1));
        }
        Arrays.sort( array );
        for ( int i = 0 ; i < array.length ; i++ ) {
            System.out.println(array[i]);
        }
    }
}

您的数组的长度为10。您需要一个变量（i），该变量需要从0到9取值。 />

for ( int i = 0  ; i < array.length ;   i++ ) 
       ^               ^                   ^
       |               |                   ------  increment ( i = i + 1 )
       |               |
       |               +-------------------------- repeat as long i < 10
       +------------------------------------------ start value of i


Arrays.sort( array );

是对数组进行排序的库方法。

#6 楼

Arrays.sort(yourArray)

将完美地完成工作

#7 楼

参见下文，它将为您提供升序和降序的排序方式

import java.util.Arrays;
import java.util.Collections;

public class SortTestArray {

/**
 * Example method for sorting an Integer array
 * in reverse & normal order.
 */
public void sortIntArrayReverseOrder() {

    Integer[] arrayToSort = new Integer[] {
        new Integer(48),
        new Integer(5),
        new Integer(89),
        new Integer(80),
        new Integer(81),
        new Integer(23),
        new Integer(45),
        new Integer(16),
        new Integer(2)
    };

    System.out.print("General Order is    : ");

    for (Integer i : arrayToSort) {
        System.out.print(i.intValue() + " ");
    }


    Arrays.sort(arrayToSort);

    System.out.print("\n\nAscending Order is  : ");

    for (Integer i : arrayToSort) {
        System.out.print(i.intValue() + " ");
    }


    Arrays.sort(arrayToSort, Collections.reverseOrder());
    System.out.print("\n\nDescinding Order is : ");
    for (Integer i : arrayToSort) {
        System.out.print(i.intValue() + " ");
    }

}


/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    SortTestArray SortTestArray = new SortTestArray();
    SortTestArray.sortIntArrayReverseOrder();
}}

输出将为

General Order is    : 48 5 89 80 81 23 45 16 2 

Ascending Order is  : 2 5 16 23 45 48 80 81 89 

Descinding Order is : 89 81 80 48 45 23 16 5 2

注意：您可以使用Math.ranodm代替添加手册号。让我知道是否需要更改代码...

祝你好运...干杯！!!!

可以使用int时，请勿使用Integer，因为这样做会导致速度变慢。

– JonasCz-恢复莫妮卡
2015年4月27日7:07

#8 楼

int[] array = {2, 3, 4, 5, 3, 4, 2, 34, 2, 56, 98, 32, 54};

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array.length; j++) {
        if (array[i] < array[j]) {
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
}

#9 楼

对于自然顺序：Arrays.sort(array)

对于反向顺序：Arrays.sort(array, Collections.reverseOrder());->这是Collections类中的静态方法，它将进一步调用自身的内部类以返回反向比较器。

不幸的是，反向解决方案不适用于原语。 IntStream.range（0，size）.map（i-> array [size-i-1]）。toArray（）;做。大小= array.length;

– Andrei Konstantinov
18年1月15日在7:50

#10 楼

这是在程序中使用此方法的方法：

public static void main(String args[])
{
    int [] array = new int[10];

    array[0] = ((int)(Math.random()*100+1));
    array[1] = ((int)(Math.random()*100+1));
    array[2] = ((int)(Math.random()*100+1));
    array[3] = ((int)(Math.random()*100+1));
    array[4] = ((int)(Math.random()*100+1));
    array[5] = ((int)(Math.random()*100+1));
    array[6] = ((int)(Math.random()*100+1));
    array[7] = ((int)(Math.random()*100+1));
    array[8] = ((int)(Math.random()*100+1));
    array[9] = ((int)(Math.random()*100+1));

    Arrays.sort(array); 

    System.out.println(array[0] +" " + array[1] +" " + array[2] +" " + array[3]
    +" " + array[4] +" " + array[5]+" " + array[6]+" " + array[7]+" " 
    + array[8]+" " + array[9] );        

}

#11 楼

只是供您参考，您现在可以使用Java 8新API通过parallelSort对任何类型的数组进行排序

parallelSort使用Java 7中引入的Fork / Join框架将排序任务分配给线程池中可用的多个线程。

可用于对int数组进行排序的两种方法，

parallelSort(int[] a)
parallelSort(int[] a,int fromIndex,int toIndex)

#12 楼

您可以使用Arrays.sort( array )对int数组进行排序。

我可以举个例子说明如何在程序中使用它吗？

–卢卡斯
2012年1月20日7:55

#13 楼

Java 8提供了使用流的选项，该流可用于对int[] array进行排序，如下所示：

int[] sorted = Arrays.stream(array).sorted().toArray(); // option 1
Arrays.parallelSort(array); //option 2

文档中提到的parallelSort：

排序算法是一个并行的排序合并，它将数组
分解为子数组，这些子数组本身先进行排序然后合并。当子数组的长度达到最小粒度时，将使用适当的Arrays.sort方法对子数组进行排序。如果
指定数组的长度小于最小粒度，则使用适当的Arrays.sort方法对其进行排序。算法
需要的工作空间不大于原始
数组的大小。 ForkJoin公共池用于执行任何并行任务。

因此，如果输入数组小于粒度（我相信Java 9中的8192个元素和Java 8中的4096个元素），则parallelSort只需调用顺序排序算法即可。

如果要对整数数组进行反向排序，我们可以使用比较器，例如：

int[] reverseSorted = IntStream.of(array).boxed()
                        .sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray();

由于Java无法使用自定义比较器对原语进行排序，因此，我们必须使用中间装箱或实现此原语排序的其他第三方库。

为什么不使用这样的简单方法（来自Java 1.2）：Arrays.sort（myArray）; ？不需要Java Stream。

– a_subscriber
19-09-29在12:31

#14 楼

您可以使用Arrays.sort（）函数。

sort() method is a java.util.Arrays class method.          
Declaration : Arrays.sort(arrName)

#15 楼

最有效的方法！

public static void main(String args[])
{
    int [] array = new int[10];//creates an array named array to hold 10 int's
    for(int x: array)//for-each loop!
      x = ((int)(Math.random()*100+1));
    Array.sort(array);
    for(int x: array)
      System.out.println(x+" ");
}

这行不通！第一个循环仅使循环变量（x）突变，而数组元素未设置。因此，您最终将对零数组进行排序。

– rrufai
19年1月6日在1:04

#16 楼

如果您想自己构建快速排序算法并且对它的工作原理有更多的了解，请检查以下代码：

1-创建排序类

class QuickSort {
    private int input[];
    private int length;

    public void sort(int[] numbers) {
        if (numbers == null || numbers.length == 0) {
            return;
        }
        this.input = numbers;
        length = numbers.length;
        quickSort(0, length - 1);
    }
    /*
     * This method implements in-place quicksort algorithm recursively.
     */

    private void quickSort(int low, int high) {
        int i = low;
        int j = high;

        // pivot is middle index
        int pivot = input[low + (high - low) / 2];

        // Divide into two arrays
        while (i <= j) {
            /**
             * As shown in above image, In each iteration, we will identify a
             * number from left side which is greater then the pivot value, and
             * a number from right side which is less then the pivot value. Once
             * search is complete, we can swap both numbers.
             */
            while (input[i] < pivot) {
                i++;
            }
            while (input[j] > pivot) {
                j--;
            }
            if (i <= j) {
                swap(i, j);
                // move index to next position on both sides
                i++;
                j--;
            }
        }

        // calls quickSort() method recursively
        if (low < j) {
            quickSort(low, j);
        }

        if (i < high) {
            quickSort(i, high);
        }
    }

    private void swap(int i, int j) {
        int temp = input[i];
        input[i] = input[j];
        input[j] = temp;
    }
}

2-将未排序的数组发送到Quicksort类

import java.util.Arrays;


public class QuickSortDemo {

    public static void main(String args[]) {
        // unsorted integer array
        int[] unsorted = {6, 5, 3, 1, 8, 7, 2, 4};
        System.out.println("Unsorted array :" + Arrays.toString(unsorted));
        QuickSort algorithm = new QuickSort();
        // sorting integer array using quicksort algorithm
        algorithm.sort(unsorted);
        // printing sorted array
        System.out.println("Sorted array :" + Arrays.toString(unsorted));
    }
}

3-输出

Unsorted array :[6, 5, 3, 1, 8, 7, 2, 4] 
Sorted array :[1, 2, 3, 4, 5, 6, 7, 8]

#17 楼

我们还可以使用二进制搜索树通过有序遍历方法来获取排序数组。该代码还具有下面的基本二进制搜索树的实现。

class Util {
    public static void printInorder(Node node) 
    { 
        if (node == null) {
            return;
        } 

        /* traverse left child */
        printInorder(node.left); 

        System.out.print(node.data + " "); 

        /* traverse right child */
        printInorder(node.right); 
     } 

    public static void sort(ArrayList<Integer> al, Node node) {
        if (node == null) {
            return;
        } 

        /* sort left child */
        sort(al, node.left); 

        al.add(node.data);

        /* sort right child */
        sort(al, node.right); 

    }
}

class Node {
    Node left;
    Integer data;
    Node right;

    public Node(Integer data) {
        this.data = data;
    }

    public void insert(Integer element) {
        if(element.equals(data)) {
            return;
        }

        // if element is less than current then we know we will insert element to left-sub-tree
        if(element < data) {
            // if this node does not have a sub tree then this is the place we insert the element.
            if(this.left == null) {
                this.left = new Node(element);  
            } else { // if it has left subtree then we should iterate again.
                this.left.insert(element);
            }
        } else {
            if(this.right == null) {
                this.right = new Node(element);
            } else {
                this.right.insert(element);
            }
        }
    }
}

class Tree {
    Node root;

    public void insert(Integer element) {
        if(root == null) {
            root = new Node(element);
        } else {
            root.insert(element);
        }       
    }

    public void print() {
        Util.printInorder(root);
    }

    public ArrayList<Integer> sort() {
        ArrayList<Integer> al = new ArrayList<Integer>();
        Util.sort(al, root);
        return al;
    }
}

public class Test {

    public static void main(String[] args) {

        int [] array = new int[10];

        array[0] = ((int)(Math.random()*100+1));
        array[1] = ((int)(Math.random()*100+1));
        array[2] = ((int)(Math.random()*100+1));
        array[3] = ((int)(Math.random()*100+1));
        array[4] = ((int)(Math.random()*100+1));
        array[5] = ((int)(Math.random()*100+1));
        array[6] = ((int)(Math.random()*100+1));
        array[7] = ((int)(Math.random()*100+1));
        array[8] = ((int)(Math.random()*100+1));
        array[9] = ((int)(Math.random()*100+1));

        Tree tree = new Tree();

        for (int i = 0; i < array.length; i++) {
            tree.insert(array[i]);
        }

        tree.print();

        ArrayList<Integer> al = tree.sort();    

        System.out.println("sorted array : ");
        al.forEach(item -> System.out.print(item + " "));
}

}

#18 楼

请注意，Arrays.sort（）方法不是线程安全的：如果您的数组是单例的属性，并且在多线程环境中使用，则应将排序代码放在同步块中，或创建该数组的副本。数组及其复制顺序（仅使用内部的相同对象复制数组结构）。
例如：

 int[] array = new int[10];
 ...
 int[] arrayCopy = Arrays.copyOf(array , array .length);
 Arrays.sort(arrayCopy);
 // use the arrayCopy;

#19 楼

只需在打印数组之前执行以下操作即可：-
Arrays.sort(array);
注意：-
您必须通过输入以下内容来导入数组类：-
import java.util.Arrays;

编程黑洞网

用Java对数组排序

评论

#1 楼

#2 楼

评论

#3 楼

评论

#4 楼

评论

#5 楼

#6 楼

#7 楼

评论

#8 楼

#9 楼

评论

#10 楼

#11 楼

#12 楼

评论

#13 楼

评论

#14 楼

#15 楼

评论

#16 楼

#17 楼

#18 楼

#19 楼