我正在尝试创建一个由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] );
}
Pet*_*rey 198
循环也非常有用,尤其是在使用数组时,
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();
rau*_*hen 189
在println之前添加Line,您的数组将被排序
Arrays.sort( array );
isa*_*sah 40
它可以帮助您通过实现自己来理解循环.请参阅冒泡排序很容易理解:
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)
sta*_*ker 20
我很懒,并添加了循环
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 );
是一种对数组进行排序的库方法.
见下文,它将为您提供升序和降序
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而不是添加手动编号.如果我需要更改代码,请告诉我...
祝你好运...干杯!!!
以下是如何在您的程序中使用它:
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] );
}
仅供参考,您现在可以使用Java 8新API对任何类型的数组进行排序 parallelSort
parallelSort 使用Java 7中引入的Fork/Join框架将排序任务分配给线程池中可用的多个线程.
可用于排序int数组的两种方法,
parallelSort(int[] a)
parallelSort(int[] a,int fromIndex,int toIndex)
小智 6
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;
}
}
}
小智 6
对于自然顺序: Arrays.sort(array)
对于反向顺序:Arrays.sort(array, Collections.reverseOrder());- >它是Collections类中的静态方法,它将进一步调用自身的内部类以返回反向比较器.
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 无法使用自定义比较器对原语进行排序，因此我们必须使用中间装箱或其他一些实现此类原语排序的第三方库。