Java如何对数组进行排序
排序是一种以一定顺序排列列表或数组元素的方法。该顺序可以是升序或降序。
数字和
词典顺序(字母顺序)是一种广泛使用的顺序。
在本节中，我们将学习
如何对数组进行排序在Java中使用
升序和
降序使用
sort()方法，而
sort()方法。除此之外，我们还将在
Java 中学习
如何对子数组进行排序
按升序排列数组
升序将元素从低到高排列。也称为
自然顺序或
数字顺序。我们可以通过以下方式执行排序:
使用sort()方法
不使用方法
使用for循环
使用用户定义的方法
使用sort()方法
在Java中，
数组是
提供 sort()方法以按升序对数组进行排序的java.util 包。它使用
Dual-Pivot快速排序算法进行排序。它的复杂度为
O(n log(n))。这是一个
static 方法，该方法将
数组解析为参数，并且不返回任何内容。我们可以使用类名直接调用它。它接受类型为int，float，double，long，char，byte的数组。
语法:
public static void sort(int[] a)
其中
a 是短数组。
注意: 类似于Arrays类，Collections类还提供了sort()方法来对数组进行排序。但是它们之间是有区别的。 Arrays类的sort()方法适用于原始类型，而Collections类的sort()方法适用于对象Collection，例如LinkedList，ArrayList等。
让我们使用Arrays类的sort()方法对数组进行排序。
在下面的程序中，我们定义了一个整数类型的数组。之后，我们调用了Arrays类的sort()方法并解析要排序的数组。为了打印排序后的数组，我们使用了for循环。
SortArrayExample1.java
import java.util.Arrays;
public class SortArrayExample1{
public static void main(String[] args) {
//defining an array of integer type
int [] array = new int [] {
90, 23, 5, 109, 12, 22, 67, 34}
;
//invoking sort() method of the Arrays class
Arrays.sort(array);
System.out.println("Elements of array sorted in ascending order: ");
//prints array using the for loop
for (int i = 0;i <array.length;i++) {
System.out.println(array[i]);
}
}
}
输出:
Array elements in ascending order:
5
12
22
23
34
67
90
109
在上面的程序中，我们还可以使用
Arrays class的toSting()方法进行打印数组，如以下语句所示。它返回指定数组的字符串表示形式。
System.out.printf(Arrays.toString(array));
使用for循环
在下面的示例中，我们初始化了一个整数类型的数组，并且
SortArrayExample2.java
public class SortArrayExample2 {
public static void main(String[] args) {
//creating an instance of an array
int[] arr = new int[] {78, 34, 1, 3, 90, 34, -1, -4, 6, 55, 20, -65};
System.out.println("Array elements after sorting:");
//sorting logic
for (int i = 0;i <arr.length;i++) {
for (int j = i + 1;j <arr.length;j++) {
int tmp = 0;
if (arr[i] >arr[j]) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
//prints the sorted element of the array
System.out.println(arr[i]);
}
}
}
输出:
Array elements after sorting:
-65
-4
-1
1
3
6
20
34
34
55
78
90
使用用户定义的方法
在下面的示例中，我们定义了一个名为
sortArray()的方法，该方法包含对数组进行排序的逻辑
SortArrayExample3.java
public class SortArrayExample3 {
public static void main(String[] args) {
int i;
//initializing an array
int array[] = {12, 45, 1, -1, 0, 4, 56, 23, 89, -21, 56, 27};
System.out.print("Array elements before sorting: \n");
for(i = 0;i <array.length;i++)
System.out.println(array[i]);
//invoking user defined method
sortArray(array, array.length);
System.out.print("Array elements after sorting: \n");
//accessing elements of the sorted array
for(i = 0;i <array.length;i++) {
System.out.println(array[i]);
}
}
//user defined method to sort an array in ascending order
private static void sortArray(int array[], int n) {
for (int i = 1;i <n;i++) {
int j = i;
int a = array[i];
while ((j >0) &&(array[j-1] >a)) {
array[j] = array[j-1];
j--;
}
array[j] = a;
}
}
}
输出:
Array elements before sorting:
12
45
1
-1
0
4
56
23
89
-21
56
27
Array elements after sorting:
-21
-1
0
1
4
12
23
27
45
56
56
89
按降序排列数组
降序将元素从高到低排列。我们可以通过以下方式执行排序:
使用 reverseOrder()方法
不使用方法
使用 for 循环
使用用户定义的方法
使用reverseOrder()方法
Java Collections 类提供了
reverseOrder()方法，以反向字典顺序对数组进行排序。这是一个静态方法，因此我们可以使用类名直接调用它。它不解析任何参数。它返回一个
比较器，强加自然顺序(升序)的相反。
这意味着数组通过使用sort()方法以升序对元素进行排序，之后，reverseOrder()方法将反转自然顺序，然后我们以降序获得排序后的数组。
语法:
public static <T> Comparator<T> reverseOrder()
假设a []是要按降序排序的数组。我们将通过以下方式使用reverseOrder()方法:
Arrays.sort(a, Collections.reverseOrder());
让我们按降序对数组进行排序。
在下面的程序中，要注意的一点是，我们已将数组定义为
Integer 。因为reverseOrder()方法不适用于原始数据类型。
SortArrayExample4.java
import java.util.Arrays;
import java.util.Collections;
public class SortArrayExample4 {
public static void main(String[] args) {
Integer [] array = {23, -9, 78, 102, 4, 0, -1, 11, 6, 110, 205};
// sorts array[] in descending order
Arrays.sort(array, Collections.reverseOrder());
System.out.println("Array elements in descending order: " +Arrays.toString(array));
}
}
输出:
Array elements in descending order: [205, 110, 102, 78, 23, 11, 6, 4, 0, -1, -9]
让我们看看另一个按字母顺序对数组元素进行排序的程序。
SortArrayExample5.java
import java.util.Arrays;
import java.util.Collections;
public class SortArrayExample5 {
public static void main(String[] args) {
String [] strarray = {"Mango", "Apple", "Grapes", "Papaya", "Pineapple", "Banana", "Orange"};
// sorts array[] in descending order
Arrays.sort(strarray, Collections.reverseOrder());
System.out.println("Array elements in descending order: " +Arrays.toString(strarray));
}
}
输出:
Array elements in descending order: [Papaya, Pineapple, Orange, Mango, Grapes, Banana, Apple]
使用for循环
在下面的示例中，我们初始化了一个整数数组并执行排序
SortArrayExample6.java
public class SortArrayExample6 {
public static void main(String[] args) {
int temp;
//initializing an array
int a[]={12,5,56,-2,32,2,-26,9,43,94,-78};
for (int i = 0;i <a.length;i++) {
for (int j = i + 1;j <a.length;j++) {
if (a[i] <a[j]) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
System.out.println("Array elements in descending order:");
//accessing element of the array
for (int i = 0;i <=a.length - 1;i++) {
System.out.println(a[i]);
}
}
}
输出:
Array elements in descending order:
94
56
43
32
12
9
5
2
-2
-26
-78
使用用户定义的方法
SortArrayExample7.java
import java.util.Scanner;
public class SortArrayExample7 {
public static void main(String[] args) {
int n, temp;
Scanner s = new Scanner(System.in);
System.out.print("Enter the number of elements: ");
n = s.nextInt();
int a[] = new int[n];
System.out.println("Enter the elements of the array: ");
for (int i = 0; i <n;i++) {
a[i] = s.nextInt();
}
for (int i = 0; i <n;i++) {
for (int j = i + 1;j <n;j++) {
if (a[i] < a[j]) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
System.out.println("Array elements in descending order:");
for (int i = 0; i < n - 1; i++) {
System.out.println(a[i]);
}
System.out.print(a[n - 1]);
}
}
输出:
Enter the number of elements: 7
Enter the elements of the array:
12
5
56
-2
32
2
-26
Array elements in descending order:
56
32
12
5
2
-2
-26
如何对子数组进行排序
从该数组派生的数组称为
subarray 。假设
a[] 是一个包含元素[12、90、34、2、45、3、22、18、5、78]的数组，并且我们想对数组元素从34到18进行排序它将对子数组
[34、2、45、3、22、18] 进行排序，并保持其他元素不变。
要对子数组进行排序，请使用Arrays类提供名为
sort()的静态方法。它将指定范围的数组按升序排序。我们还可以对类型为
long，double，float，char，byte，等的数组进行排序。
语法:
public static void sort(int[] a, int fromIndex, int toIndex)
该方法解析以下三个参数:
a 要排序的数组。
fromIndex 子数组的第一个元素的索引。它参与排序。
toIndex: 子数组的最后一个元素的索引。它不参与排序。
如果formIndex等于toIndex，则要排序的范围为空。如果
fomIndex大于toIndex ，则抛出IllegalArgumentException。如果
fromIndex <0或toIndex> a.length ，也会引发ArrayIndexOutOfBoundsException。
让我们通过Java程序对子数组进行排序。
SortSubarrayExample。 Java
import java.util.Arrays;
public class SortSubarrayExample {
public static void main(String[] args) {
//defining an array
int[] a = {12, 90, 34, 2, 45, 3, 22, 18, 5, 78};
// sorts subarray form index 2 to 7
Arrays.sort(a, 2, 7);
//prints array using the for loop
for (int i = 0;i <a.length;i++) {
System.out.println(a[i]);
}
}
}
输出:
Sorted Subarray:
12
90
2
3
22
34
45
18
5
78
