java 数组怎么排序_Java如何对数组进行排序

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的数组。

语法:

publicstaticvoidsort(int[] a)

其中

a是短数组。

注意:类似于Arrays类，Collections类还提供了sort()方法来对数组进行排序。但是它们之间是有区别的。 Arrays类的sort()方法适用于原始类型，而Collections类的sort()方法适用于对象Collection，例如LinkedList，ArrayList等。

让我们使用Arrays类的sort()方法对数组进行排序。

在下面的程序中，我们定义了一个整数类型的数组。之后，我们调用了Arrays类的sort()方法并解析要排序的数组。为了打印排序后的数组，我们使用了for循环。

SortArrayExample1.java

import java.util.Arrays;

publicclassSortArrayExample1{

publicstaticvoidmain(String[] args) {

//defining an array of integer type

int [] array =newint [] {

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 forloop

for(int i = 0;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

publicclassSortArrayExample2 {

publicstaticvoidmain(String[] args) {

//creating an instance of an array

int[] arr =newint[] {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

for(int j = i + 1;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

publicclassSortArrayExample3 {

publicstaticvoidmain(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

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

System.out.println(array[i]);

}

}

//user defined method to sort an array in ascending order

privatestaticvoidsortArray(int array[], int n) {

for(int i = 1;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()方法将反转自然顺序，然后我们以降序获得排序后的数组。

语法:

publicstatic Comparator reverseOrder()

假设a []是要按降序排序的数组。我们将通过以下方式使用reverseOrder()方法:

Arrays.sort(a, Collections.reverseOrder());

让我们按降序对数组进行排序。

在下面的程序中，要注意的一点是，我们已将数组定义为

Integer。因为reverseOrder()方法不适用于原始数据类型。

SortArrayExample4.java

import java.util.Arrays;

import java.util.Collections;

publicclassSortArrayExample4 {

publicstaticvoidmain(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;

publicclassSortArrayExample5 {

publicstaticvoidmain(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

publicclassSortArrayExample6 {

publicstaticvoidmain(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

for(int j = i + 1;j

if(a[i]

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;

publicclassSortArrayExample7 {

publicstaticvoidmain(String[] args) {

int n, temp;

Scanner s =newScanner(System.in);

System.out.print("Enter the number of elements: ");

n = s.nextInt();

int a[] =newint[n];

System.out.println("Enter the elements of the array: ");

for(int i = 0; i

a[i] = s.nextInt();

}

for(int i = 0; i

for(int j = i + 1;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，等的数组进行排序。

语法:

publicstaticvoidsort(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;

publicclassSortSubarrayExample {

publicstaticvoidmain(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 forloop

for(int i = 0;i

System.out.println(a[i]);

}

}

}

输出:

Sorted Subarray:

12

90

2

3

22

34

45

18

5

78