Mengisih dalam Jawa

• Isih dalam Java pada asasnya menyusun sekumpulan elemen yang disimpan di suatu tempat dalam susunan tertentu; susunan ini boleh sama ada menaik atau menurun; terdapat banyak senario dalam pengaturcaraan masa nyata di mana terdapat keperluan untuk mengisih elemen kerana ia juga memudahkan pencarian elemen tertentu kerana elemen boleh diperoleh dengan mudah oleh indeks tatasusunan secara langsung jika diisih. Elemen yang perlu diisih boleh disimpan sama ada dalam tatasusunan atau koleksi. Koleksi ini terdiri daripada pelbagai jenis dalam Set seperti Java, Tree, Map, Heap, List, dsb., Walaupun terdapat pelbagai jenis Algoritma Isih yang digunakan untuk mengisih elemen dalam Tatasusunan seperti Bubble Sort Heap Sort, Insertion Sort , Isih Pilihan, Isih Gabung, dsb.
• Pengaturcara menggunakan algoritma yang berbeza untuk mengisih elemen mengikut keperluan khusus mereka dan kerumitan algoritma. Algoritma pengisihan ini dilaksanakan melalui penggunaan pelbagai gelung dan pembolehubah untuk mengulanginya. Selain daripada menggunakan Algoritma Pengisihan untuk mengisih elemen dalam tatasusunan, Java menyediakan fungsi pengisihan terbina, yang boleh membantu dengan perkara yang sama, dan pengaturcara tidak perlu terperangkap dalam gelung besar dan memikirkan tentang kerumitan. Ya, anda dengar betul, dalam Java sort() fungsi digunakan untuk mengisih elemen yang disimpan sama ada dalam tatasusunan atau koleksi dan dengan kerumitan yang sangat kurang o(n(logn)). Walau bagaimanapun, pelaksanaan kaedah dalam kedua-duanya adalah sedikit berbeza.

Sintaks Untuk Tatasusunan:

Arrays.sort(array_name);

Untuk koleksi

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Collections.sort(array_name_list);

• Di sini array_name dan array_name_list ialah nama tatasusunan atau koleksi yang perlu diisih.
• Array ialah nama kelas Java.
• Koleksi ialah rangka kerja di Jawa.
• sort() ialah fungsi pengisihan terbina yang digunakan dalam Java.

Bagaimana Pengisihan Dilakukan dalam Java?

Berikut ialah perkara seperti berikut:

• Melalui penggunaan Algoritma Pengisihan, pengisihan juga boleh dilakukan dengan algoritma yang berbeza-beza daripada tidak cekap kepada cekap, dan setiap algoritma mempunyai kerumitan masa dan ruang tersendiri.
• Kadangkala Algoritma ini mempunyai kerumitan yang sangat tinggi sehingga ia tidak boleh digunakan dalam senario sebenar di mana terdapat keperluan untuk mengendalikan sejumlah besar data.
• Seperti yang dinyatakan di atas, dalam fungsi terbina dalam Java, sort() digunakan untuk mengisih semua elemen Array dan koleksi. Menurut Java DOC rasmi, Array.sort menggunakan quicksort, iaitu double pivot dan secara perbandingan lebih pantas daripada single-pivot Quick Sort.
• Salah satu kelebihan terbesar ini ialah ia memberikan kerumitan O(n(logn)). Ia menggunakan pelaksanaan yang sangat stabil dan berulang bagi objek tatasusunan bagi Merge Sort. Java menyediakan kaedah untuk mengisih tatasusunan dalam susunan terbalik juga mengikut keperluan pengaturcara untuk mengisih sama ada dalam susunan menaik atau menurun. Kaedah Collections.reverseOrder() digunakan untuk mengisih elemen dalam tertib terbalik atau menurun.
• Java 8 juga menyediakan kemudahan untuk mengisih tatasusunan selari menggunakan pengisihan Selari, yang menggunakan konsep multithreading Java dan membahagikan keseluruhan tatasusunan kepada bahagian dan menggabungkannya selepas mengisih.

Jenis Isih dalam Jawa

Di bawah disebutkan beberapa cara pengisihan boleh dilakukan dalam Pengisihan dalam Java:

1. sort(array_name)

Ini digunakan untuk mengisih tatasusunan lengkap dalam menaik. Secara lalai, kaedah ini mengisih elemen tatasusunan dalam tertib menaik.

Kod:

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));
}
}

Output:

2. Collection.reverseOrder()

Kaedah dalam Java ini digunakan untuk mengisih tatasusunan dalam susunan terbalik atau tertib menurun. Terdapat senario di mana kita perlu mengisih elemen dalam tertib menurun dan Java melakukannya melalui kaedah terbina dalam.

Kod:

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));
}
}

Output:

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

Jika terdapat keperluan untuk mengisih beberapa bahagian tatasusunan dan bukannya keseluruhan tatasusunan, Java menyediakan kemudahan untuk mengisih jenis tatasusunan ini dengan menentukan 3 parameter, iaitu nama tatasusunan, indeks pertama dari mana pengisihan perlu dimulakan dan indeks terakhir sehingga bila pengisihan perlu dilakukan.

Kod:

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));
}
}

Output:

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.

Atas ialah kandungan terperinci Mengisih dalam Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!