Java 排序方法是数组方法之一，用于将用户指定的数组按升序或降序排序。本文将介绍如何按升序和降序对 Byte、Object 数组、Integer、Char、Long、Double、Float 和 Short 数组进行排序。此编程语言中数组排序的基本语法如下所示。
Java 数组排序方法语法
Java 编程语言提供了十八种方法来对原始数组进行排序。以下方法将 Byte 数组作为参数，并将 Byte 数组按升序排序。
public static void sort(byte[] anByteArray); //In order to use in program Arrays.sort(byte[] anByteArray);
下面的排序方法将 Byte 数组作为第一个参数。起始索引位置（fromIndex），排序将从该位置开始，作为第二个参数（整数值），最后一个索引位置（toIndex），排序将在此位置结束，作为第三个参数。Arrays.sort 方法将从 fromIndex 开始对数组元素进行排序，直到 toIndex，但不包含 toIndex。
public static void sort(byte[] anByteArray, int fromIndex, int toIndex); //In order to use in program Arrays.sort(byte[] anByteArray, int fromIndex, int toIndex);
下面的 Java 方法将 Short 数组作为参数，并将 Short 数组按升序排序。
public static void sort(short[] anShortArray); //In order to use in program Arrays.sort(short[] anShortArray);
它将 Short 数组作为第一个参数，起始索引位置（fromIndex）作为第二个参数，最后一个索引位置（toIndex）作为第三个参数。
public static void sort(byte[] anByteArray, int fromIndex, int toIndex); //In order to use in program Arrays.sort(byte[] anByteArray, int fromIndex, int toIndex);
它将 Character 数组作为参数，并将 char 数组按升序排序。
public static void sort(char[] anCharArray); //In order to use in program Arrays.sort(char[] anCharArray);
此排序方法将 Character 数组作为第一个参数，起始索引位置（fromIndex），最后一个索引位置（toIndex）作为第三个参数。
public static void sort(char[] anCharArray, int fromIndex, int toIndex); //In order to use in program Arrays.sort(char[] anCharArray, int fromIndex, int toIndex);
它将 Integer 数组作为参数，并将 Int 数组按升序排序。
public static void sort(int[] anIntArray); //In order to use in program Arrays.sort(int[] anIntArray);
此 Java 方法将 Integer 数组作为第一个参数，排序将开始的起始索引位置（fromIndex）作为第二个参数。排序将结束的最后一个索引位置（toIndex）作为第三个参数。
public static void sort(int[] anIntArray, int fromIndex, int toIndex); //In order to use in program Arrays.sort(int[] anIntArray, int fromIndex, int toIndex);
以下方法将 Long 数组作为参数，并将 Long 数组按升序排序。
public static void sort(long[] anLongArray); //In order to use in program Arrays.sort(long[] anLongArray);
它将 Long 数组作为第一个参数，fromIndex 作为第二个参数，toIndex 作为第三个参数。
public static void sort(long[] anLongArray, int fromIndex, int toIndex); //In order to use in program Arrays.sort(long[] anLongArray, int fromIndex, int toIndex);
该方法将 Double 数组作为参数，并将 Double 数组按升序排序。
public static void sort(double[] anDoubleArray); //In order to use in program Arrays.sort(double[] anDoubleArray);
以下方法将 Double 数组，起始索引位置（fromIndex）作为第二个参数，最后一个索引位置（toIndex）作为第三个参数。
public static void sort(double[] anDoubleArray, int fromIndex, int toIndex); //In order to use in program Arrays.sort(double[] anDoubleArray, int fromIndex, int toIndex);
此 Java 方法将浮点数数组作为参数，并将 Float 数组按升序排序。
public static void sort(float[] anFloatArray); //In order to use in program Arrays.sort(float[] anFloatArray);
它接受浮点数数组，起始索引位置（fromIndex），以及最后一个索引位置（toIndex）。
public static void sort(float[] anFloatArray, int fromIndex, int toIndex); //In order to use in program Arrays.sort(float[] anFloatArray, int fromIndex, int toIndex);
此方法接受 Object 数组作为参数。它根据指定的 Comparator 对 Object 数组进行排序。
public static void sort(T[] Array, Comparator<? super T> cmp); //In order to use in program Arrays.sort(T[] Array, Comparator<? super T> cmp);
排序方法接受 Object 数组，起始索引位置（fromIndex），最后一个索引位置（toIndex），以及 Comparator（指定顺序）作为第四个参数。
public static void sort(T[] Array, int fromIndex, int toIndex, Comparator<? super T> cmp); //In order to use in program Arrays.sort(T[] Array, int fromIndex, int toIndex, Comparator<? super T> cmp);
- fromIndex：请指定起始索引位置。这是排序开始的索引位置。
- toIndex：请指定结束索引位置。此方法将排序到此索引位置。但是，它不包含此位置（toIndex）的元素。
在 Java 中排序 Byte 数组
该方法将从 FromtoIndex 开始对数组元素进行排序，直到 toIndex，但不包含 toIndex。在此程序中，我们使用随机数组元素声明了 byte 数组。然后我们将按升序对元素数组进行排序。
package ArrayMethods;
import java.util.Arrays;
public class ByteSort {
public static void main(String[] args) {
byte[] byteArray = {20, 8, 4, 18, 45};
byte[] bitArray = {10, 25, 8, 19, 16, 5};
//Sorting in Ascending Order
Arrays.sort(byteArray);
//Printing the Output
System.out.println("Sorting Byte Array:");
arrayPrint(byteArray);
//Sorting Array using Indexes
Arrays.sort(bitArray, 1, 5);
//Printing the Output
System.out.println("Sorting Byte Array Using Index:");
arrayPrint(bitArray);
}
public static void arrayPrint(byte[] anByteArray) {
for (byte Number: anByteArray) {
System.out.println("Array Elelment = " + Number);
}
}
}
在此排序示例中，我们声明了两个 byte 数组。接下来，我们使用以下语句为数组元素分配了一些随机值。
byte[] byteArray = {20, 8, 4, 18, 45};
byte[] bitArray = {10, 25, 8, 19, 16, 5};
它将调用 public static void sort(byte[] anByteArray) 方法按升序对 byte 数组进行排序。
Arrays.sort(byteArray);
它将 Byte 数组元素打印到输出。
arrayPrint(byteArray);
我们使用 Java For Loop 迭代 Byte 数组。然后我们使用 System.out.println 语句打印每个数组元素。
public static void arrayPrint(byte[] anByteArray) {
for (byte Number: anByteArray) {
System.out.println("Array Elelment = " + Number);
}
}
它调用 public static void sort(byte[] anByteArray, int fromIndex, int toIndex) 方法按升序对从索引位置 1 到位置 4 的 byte 数组进行排序。
Arrays.sort(bitArray, 1, 5);
Java 排序 Short 数组
我们使用随机数组元素声明了 Short 数组。然后我们将按升序对 short 数组元素进行排序。
package ArrayMethods;
import java.util.Arrays;
public class ShortSort {
public static void main(String[] args) {
short[] shrArray = {9, 6, 2, 7, 5};
short[] ShortArray = {10, 5, 8, 4, 6};
//Sorting Array in Ascending Order
Arrays.sort(shrArray);
System.out.println("Sorting Short Array:");
arrayPrint(shrArray);
//Sorting Array using Indexes
Arrays.sort(ShortArray, 0, 4);
System.out.println("Sorting Short Array Using Index:");
arrayPrint(ShortArray);
}
public static void arrayPrint(short[] anShortArray) {
for (short Number: anShortArray) {
System.out.println("Array Elelment = " + Number);
}
}
}
Sorting Short Array:
Array Elelment = 2
Array Elelment = 5
Array Elelment = 6
Array Elelment = 7
Array Elelment = 9
Sorting Short Array Using Index:
Array Elelment = 4
Array Elelment = 5
Array Elelment = 8
Array Elelment = 10
Array Elelment = 6它将调用 public static void sort(short[] anShortArray) 方法按升序对 Short 数组进行排序。
Arrays.sort(shrArray);
它调用 public static void sort(short[] anShortArray, int fromIndex, int toIndex) 方法按升序对从索引位置 1 到位置 4 的 Short 数组进行排序。
Arrays.sort(ShortArray, 0, 4);
如何在 Java 中排序 Integer 数组？
在此排序方法程序中，我们使用随机元素声明了 Integer 数组。然后我们将按升序对 Int 数组元素进行排序。
package ArrayMethods;
import java.util.Arrays;
public class IntSort {
public static void main(String[] args) {
int[] IntArray = {98, 64, 7, 78, 35};
int[] IntegerArray = {10, 25, 8, 19, 16};
//Sorting Array in Ascending Order
Arrays.sort(IntArray);
System.out.println("Sorting Integer Array:");
arrayPrint(IntArray);
//Sorting Array using Indexes
Arrays.sort(IntegerArray, 0, 3);
System.out.println("Sorting Integer Array Using Index:");
arrayPrint(IntegerArray);
}
public static void arrayPrint(int[] anIntArray) {
for (int Number: anIntArray) {
System.out.println("Array Elelment = " + Number);
}
}
}
Sorting Integer Array:
Array Elelment = 7
Array Elelment = 35
Array Elelment = 64
Array Elelment = 78
Array Elelment = 98
Sorting Integer Array Using Index:
Array Elelment = 8
Array Elelment = 10
Array Elelment = 25
Array Elelment = 19
Array Elelment = 16它将调用 public static void sort(int[] anIntegerArray) 方法按升序对 integer 数组进行排序。
Arrays.sort(IntArray);
它调用 public static void sort(int[] anIntegerArray, int fromIndex, int toIndex) 方法按升序对从索引位置 1 到位置 4 的 integer 数组进行排序。
Arrays.sort(IntegerArray, 0, 3);
如何在 Java 中排序 Long 数组？
在此 Java 程序中，我们使用随机元素声明了 Long 数组。然后我们将按升序对 Long 数组元素进行排序。
package ArrayMethods;
import java.util.Arrays;
public class LongSort {
public static void main(String[] args) {
long[] LngArray = {198, 164, 17, 178, 135};
long[] LongArray = {100, 250, 80, 190, 160};
//Sorting Array in Ascending Order
Arrays.sort(LngArray);
System.out.println("Sorting Long Array:");
arrayPrint(LngArray);
//Sorting Array using Indexes
Arrays.sort(LongArray, 1, 4);
System.out.println("Sorting Long Array Using Index:");
arrayPrint(LongArray);
}
public static void arrayPrint(long[] anLongArray) {
for (long Number: anLongArray) {
System.out.println("Array Elelment = " + Number);
}
}
}
Sorting Long Array:
Array Elelment = 17
Array Elelment = 135
Array Elelment = 164
Array Elelment = 178
Array Elelment = 198
Sorting Long Array Using Index:
Array Elelment = 100
Array Elelment = 80
Array Elelment = 190
Array Elelment = 250
Array Elelment = 160它将调用 public static void sort(long[] anLongArray) 方法按升序对 Long 数组进行排序。
Arrays.sort(LngArray);
它调用 public static void sort(long[] anLongArray, int fromIndex, int toIndex) 方法按升序对从索引位置 1 到位置 3 的 Long 数组进行排序。
Arrays.sort(LongArray, 1, 4);
排序 Double 数组
在此程序中，我们使用随机元素声明了 Double 数组。然后我们将按升序对 Double 数组元素进行排序。
package ArrayMethods;
import java.util.Arrays;
public class DoubleSort {
public static void main(String[] args) {
double[] DoubArray = {98.68, 64.542, 7.98, 78.45, 35.76};
double[] DoubleArray = {10.25, 25.9865, 8.485, 19.356, 16.489};
//Sorting Array in Ascending Order
Arrays.sort(DoubArray);
System.out.println("Sorting Double Array:");
arrayPrint(DoubArray);
//Sorting Array using Indexes
Arrays.sort(DoubleArray, 0, 3);
System.out.println("Sorting Double Array Using Index:");
arrayPrint(DoubleArray);
}
public static void arrayPrint(double[] anDoubleArray) {
for (double Number: anDoubleArray) {
System.out.println(Number);
}
}
}
Sorting Double Array:
7.98
35.76
64.542
78.45
98.68
Sorting Double Array Using Index:
8.485
10.25
25.9865
19.356
16.489以下语句将调用 public static void sort(double[] anDoubleArray) 方法按升序对 Double 数组进行排序。
Arrays.sort(DoubArray);
它调用 public static void sort(double[] anDoubleArray, int fromIndex, int toIndex) 方法按升序对从索引位置 0 到位置 2 的 Double 数组进行排序。
Arrays.sort(DoubleArray, 0, 3);
如何在 Java 中排序 Float 数组？
在此方法程序中，我们使用随机数组元素声明了 Float 数组。然后我们将按升序对 Float 数组元素进行排序。
package ArrayMethods;
import java.util.Arrays;
public class FloatSort {
public static void main(String[] args) {
float[] floArray = {8.68f, 5.54f, 1.98f, 12.45f, 3.76f};
float[] floatArray = {10.25f, 25.98f, 8.4f, 13.3f, 16.48f};
//Sorting Array in Ascending Order
Arrays.sort(floArray);
System.out.println("Sorting Float Array:");
arrayPrint(floArray);
//Sorting Array using Indexes
Arrays.sort(floatArray, 0, 4);
System.out.println("Sorting Float Array Using Index:");
arrayPrint(floatArray);
}
public static void arrayPrint(float[] anfloatArray) {
for (float Number: anfloatArray) {
System.out.println(Number);
}
}
}
Sorting Float Array:
1.98
3.76
5.54
8.68
12.45
Sorting Float Array Using Index:
8.4
10.25
13.3
25.98
16.48以下语句将调用 public static void sort(float[] anFloatArray) 方法按升序对 Float 数组进行排序。
Arrays.sort(floArray);
它调用 public static void sort(float[] anFloatArray, int fromIndex, int toIndex) 方法按升序对从索引位置 0 到位置 3 的 Float 数组进行排序。
Arrays.sort(floatArray, 0, 4);
如何排序 Java 中的 Char 数组？
在此方法程序中，我们使用随机数组元素声明了 Character 数组。然后我们将按升序对 Char 数组元素进行排序。
package ArrayMethods;
import java.util.Arrays;
public class CharSort {
public static void main(String[] args) {
char[] CharArray = {'g', 'a', 't', 'e'};
char[] CharacterArray = {'g', 'a', 't', 'e', 'w', 'a', 'y'};
//Sorting Array in Ascending Order
Arrays.sort(CharArray);
System.out.println("Sorting Character Array:");
arrayPrint(CharArray);
//Sorting Array using Indexes
Arrays.sort(CharacterArray, 2, 6);
System.out.println("Sorting Character Array Using Index:");
arrayPrint(CharacterArray);
}
public static void arrayPrint(char[] anCharacterArray) {
for (char Number: anCharacterArray) {
System.out.println(Number);
}
}
}
Sorting Character Array:
a
e
g
t
Sorting Character Array Using Index:
g
a
a
e
t
w
y它将调用 public static void sort(char [] anCharArray) 方法按升序对 Char 数组进行排序。
Arrays.sort(CharArray);
它调用 public static void sort(char[] anCharArray, int fromIndex, int toIndex) 方法按升序对从索引位置 2 到位置 5 的 Char 数组进行排序。
Arrays.sort(CharacterArray, 2, 6);
Object 数组
在此 Java 数组排序方法程序中，我们使用随机数组元素声明了 String 数组。然后我们将按升序对 string object 数组元素进行排序。
package ArrayMethods;
import java.util.Arrays;
public class ObjectSort {
public static void main(String[] args) {
String[] strArray = {"Apple", "Orange", "Grape", "Banana", "Strawberry","Cherry", "Kiwi"};
String[] stringArray = {"India", "UK", "USA", "Australia", "Japan","China", "Korea"};
//Sorting Array in Ascending Order
Arrays.sort(strArray);
System.out.println("Sorting Object Array:");
arrayPrint(strArray);
//Sorting Array using Indexes
Arrays.sort(stringArray, 2, 6);
System.out.println("Sorting Object Array Using Index:");
arrayPrint(stringArray);
}
public static void arrayPrint(Object[] anObjectArray) {
for (Object Number: anObjectArray) {
System.out.println(Number);
}
}
}
Sorting Object Array:
Apple
Banana
Cherry
Grape
Kiwi
Orange
Strawberry
Sorting Object Array Using Index:
India
UK
Australia
China
Japan
USA
Korea在此程序中，以下语句将调用 public static void sort(Object[] anObjectArray) 方法按升序对 Object 数组进行排序。
Arrays.sort(strArray);
它调用 public static void sort(Object[] anObjectArray, int fromIndex, int toIndex) 方法按升序对从索引位置 2 到位置 5 的 Object 数组进行排序。
Arrays.sort(stringArray, 2, 6);
Java 方法对 Object 数组进行降序排序
在此 Java 程序中，我们使用随机数组元素声明了 String、Object 数组。然后此代码将按降序对 short 数组元素进行排序。
package ArrayMethods;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
public class TestSort {
public static void main(String[] args) {
String[] stringArray = {"India", "UK", "USA", "Australia", "Japan","China", "Korea"};
Object[] elements = {10, 5, 17, 2, 9, 11};
// Ascending Order
Comparator<String> cmp = Collections.reverseOrder();
Arrays.sort(stringArray, cmp);
System.out.println("Sorting Object Array:");
arrayPrint(stringArray);
//Using Indexes
Comparator<Object> cms = Collections.reverseOrder();
Arrays.sort(elements, 1, 5, cms);
System.out.println("Sorting Object Array Using Index:");
arrayPrint(elements);
}
public static void arrayPrint(Object[] anIntArray) {
for (Object Number: anIntArray) {
System.out.println(Number);
}
}
}
Sorting Object Array:
USA
UK
Korea
Japan
India
China
Australia
Sorting Object Array Using Index:
10
17
9
5
2
11它将为 String Object 创建 Comparator。在右侧，我们调用 reverseOrder 方法并将顺序（降序）分配给 Comparator。
Comparator<String> cmp = Collections.reverseOrder();
以下语句将调用 public static void sort(T[] Array, Comparator<? super T> cmp) 方法按降序对 String object 数组进行排序。
Arrays.sort(stringArray, cmp);
它将为 Object 创建 Comparator。在右侧，我们调用 reverseOrder 方法并将顺序（降序）分配给 Comparator。
Comparator<Object> cms = Collections.reverseOrder();
以下语句将调用 public static void sort(T[] Array, int fromIndex, int toIndex, Comparator cmp) 方法按降序对从索引位置 1 到位置 5 的 Object 数组进行排序。
Arrays.sort(elements, 1, 5, cms);