Java 中的排序

• Java 中的排序基本上就是按特定順序排列儲存在某處的一組元素；該順序可以是升序或降序；在即時程式設計中，有很多場景需要對元素進行排序，因為這也使得搜尋特定元素變得容易，因為如果排序，可以直接透過陣列索引輕鬆檢索元素。需要排序的元素可以儲存在陣列或集合中。集合有多種類型，如Java 中的Sets、Tree、Map、Heap、List 等，儘管有不同類型的排序演算法用於對類似數組中的元素進行排序，例如冒泡排序、堆排序、插入排序、選擇排序、歸併排序等
• 程式設計師根據自己的特定要求和演算法的複雜程度，使用不同的演算法對元素進行排序。這些排序演算法是透過使用各種循環和變數來迭代它們來實現的。除了使用排序演算法對數組中的元素進行排序之外，Java 還提供了內建的排序功能，這可以幫助實現相同的目的，並且程式設計師不需要陷入大循環並考慮複雜性。是的，你沒聽錯，在 Java 中，sort() 函數用於對儲存在陣列或集合中的元素進行排序，並且其複雜度非常低 o(n(logn))。然而，兩者的方法實現有點不同。

陣列語法：

Arrays.sort(array_name);

收藏

開始您的免費軟體開發課程

網頁開發、程式語言、軟體測試及其他

Collections.sort(array_name_list);

• 這裡的array_name和array_name_list是需要排序的陣列或集合的名稱。
• 陣列是 Java 類別的名稱。
• 集合是Java中的一個框架。
• sort() 是 Java 中使用的內建排序函數。

Java 中排序是如何進行的？

以下幾點：

• 透過使用排序演算法，也可以使用低效到高效的不同演算法進行排序，每種演算法都有自己的時間和空間複雜度。
• 有時這些演算法的複雜度非常高，無法在需要處理大量資料的實際場景中使用。
• 如上所述，在Java內建函數中，sort()用於對陣列和集合的所有元素進行排序。根據Java官方文檔，Array.sort使用的是快速排序，即雙主元快速排序，比單一主元快速排序快得多。
• 這樣做的最大優點之一是它提供了 O(n(logn)) 的複雜度。它使用歸併排序數組物件的非常穩定和迭代的實現。 Java也提供了一種對陣列進行逆序排序的方法，可以依照程式設計師的需求進行升序或降序排序。 Collections.reverseOrder() 方法用於對元素進行反向或降序排序。
• Java 8 還提供了使用並行排序對數組進行並行排序的功能，它使用 Java 的多執行緒概念，將整個數組分成幾部分，並在排序後合併它們。

Java 中的排序類型

下面提到了 Java 排序中執行排序的一些方法：

1.排序（陣列名稱）

這用於對整個數組進行升序排序。預設情況下，此方法會按升序對陣列元素進行排序。

代碼：

import java.util.Arrays;
public class SimpleSort
{
public static void main(String[] args)
{
//Unsorted array of numbers
Integer[] arr = new Integer[] {100, 20, 10, 30, 80, 70, 90, 40, 50, 60};
//Sort function to sort the above array
Arrays.sort(arr);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
}
}

輸出：

2. Collection.reverseOrder()

Java中此方法用於對數組進行倒序或降序排序。有些場景我們需要對元素進行降序排序，Java 是透過內建方法來實現的。

代碼：

import java.util.Arrays;
public class ReverseSort
{
public static void main(String[] args)
{
//Unsorted array of numbers
Integer[] arr = new Integer[] { 100, 20, 10, 30, 80, 70, 90, 40, 50, 60};
//Sort function to sort the above array
Arrays.sort(arr, Collections.reverseOrder());
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
}
}

輸出：

3. sort(int[ ] array_name, int findex, int lindex)

如果需要對數組的某些部分而不是整個數組進行排序，Java 提供了通過指定3 個參數來對此類數組進行排序的工具，即數組名稱、需要開始排序的第一個索引以及最後一個索引，直到需要進行排序為止。

代碼：

import java.util.Arrays;
public class ReverseSort
{
public static void main(String[] args)
{
//Unsorted array of numbers
Integer[] arr = new Integer[] { 100, 20, 10, 30, 80, 70, 90, 40, 50, 60};
//Sort function to sort the above array
Arrays.sort(arr, 1, 5);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
}
}

輸出：

4. Arrays.parllelSort(array_name)

From Java 8, the new API of the parallel sort has been released. Basically, in Parallel sort, the array is divided into 2 sub-arrays, and then the basic Array.sort() function is performed by a separate thread. The sorted arrays are then merged in the end to form the fully sorted array. This is done to leverage the use of multi-threading.

Code:

import java.util.Arrays;
public class ParallelSort
{
public static void main(String[] args)
{
//Unsorted array of numbers
Integer[] arr = new Integer[] { 100, 20, 10, 30, 80, 70, 90, 40, 50, 60};
//parallel Sort function to sort the above array
Arrays.parallelSort(arr);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
}
}

Output:

Like a normal Array.sort(), Arrays.parallelSort() also provides the facility to sort a particular range of array or sorting an array in reverse order.

Syntax:

// to Sort a range of array by parallelsort
Arrays.parallelSort(array_name, findex, lindex);
// to sort an array in reverse order using parallelSort
Arrays.parallelSort(array_name, Collections.reverseOder());

5. Collection.sort()

This method is used to sort the collections like list, map, Set, etc. It uses the merge sort and gives the same complexity as Array.sort(), i.e. O(n(logn)).

1. Sorting a List in ascending order

Code:

import java.util.Arrays;
import java.util.Collections;
public class ListSort
{
public static void main(String[] args)
{
//Unsorted list
Integer[] arr = new Integer[] { 100, 20, 10, 30, 80, 70, 90, 40, 50, 60 };
List<Integer> arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
}
}

Output:

2. Sorting an Array List in descending order

Code:

import java.util.Arrays;
import java.util.Collections;
public class ListSortRev
{
public static void main(String[] args)
{
//Unsorted array list of Integers
Integer[] arr = new Integer[] {100, 20, 10, 30, 80, 70, 90, 40, 50, 60 };
List<Integer> arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
}
}

Output:

3. Sorting of Set

There are 3 basic rules while sorting a collection ‘Set’ using the above method sort(array_name):

1. 1. Convert the Set into the list.
   2. Sort the list using the method sort(array_name).
   3. Convert the resulting sorted List back to Set.

Code:

List<Integer> numList = new ArrayList<Integer>(num) ;
//Sorting the list retrieved above
Collections.sort(numList);
// Converting sorted List into Set
num = new LinkedHashSet<>(numList);
//Printing the Resulting Set on console
System.out.println(num);
}
}

Output:

4. Sort a Map

Collection Map in Java is a combination of key and value So sorting can be done both ways, either through key or by value.

• Sort a Map by Key: Let’s see the below example of Sorting a Map by Key.

Code:

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
public class SortHashKey
{
public static void main(String[] args)
{
HashMap<Integer, String> map = new HashMap<>();
map.put(80, "Akshay");
map.put(20, "Akash");
map.put(10, "Bob");
map.put(30, "Nitika");
map.put(90, "Yashi");
map.put(100, "Dragisa");
TreeMap<Integer, String> treeMap = new TreeMap<>(map);
System.out.println(treeMap);
}
}

Output:

One of the easiest ways to sort the elements of the Map by Keys is by adding the unsorted map elements in the TreeMap. TreeMap automatically sorts the elements in the ascending order of Hash Keys. Though collection.sort() can also be used to do the same, it is somewhat complex and needs to be coded well.

• Sort a Map by Value: Below mentioned is an example of how the sorting can be done in a Map using value.

Code: 

import java.util.HashMap;
import java.util.Map;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
public class SortHashValue
{
public static void main(String[] args)
{
HashMap<Integer, String> map = new HashMap<>(); map.put(80, "Akshay");
map.put(20, "Akash");
map.put(10, "Bob");
map.put(30, “Nitika");
map.put(90, "Yashi");
map.put(100, "Dragisa");
LinkedHashMap<Integer, String> sorted = new LinkedHashMap<>(); map.entrySet()
.stream()
.sorted(Map.Entry.comparingByValue())
.forEachOrdered(x -> sorted.put(x.getKey(), x.getValue()));

Output:

In the above example of sorting of Map by value, firstly we set the entries using the map.entrySet() and then stream of those entries using stream() method, call the sorted array using sorted() method by comparing by value in the pair. for each ordered() is used to traverse the stream to produce the result.

5. Comparable

Comparable is an Interface, and it makes the classes comparable to its instances.

To compare the two instances of the same class, Comparable interface needs to be implemented, and the method compareTo() needs to be overridden. The classes that implement this interface, its list of objects are sorted automatically using the method Collections.sort() and Arrays.sort().

Code:

ArrayList<Employee> list = new ArrayList<>();
// Adding the instance objects of class Employee in list
list.add(new   Employee(10,   "Akshay")));
list.add(new      Employee(40,      "Bob")));
list.add(new  Employee(20,  "Priyansh")));
list.add(new  Employee(50,   "Chandni")));
list.add(new Employee(70, "Yashi")));
Collections.sort(list);
// Printing the sorted list on Console
System.out.println(list);

Output:

Conclusion

The Sorting in Java methods used in Java for multiple scenarios of Arrays and Collections are explained above. A programmer needs to keep in mind how the sort() method should be used for different Collection types. With Java 8, sorting can also be done through Lambdas to implement the Comparator interface, which makes the sorting easier. Though it is a bit difficult to learn all of them, it can be easy working with them if all the basic concepts of Java, especially data streaming, Arrays, and Collections, are clear. Though sorting Algorithms are evergreen and can be easily implemented in Java-like other programming languages, they have varying complexity, and the in-built function sort() of Java makes things easier if the basic concepts are learned by heart.

以上是Java 中的排序的詳細內容。更多資訊請關注PHP中文網其他相關文章！