Sådan sorteres ArrayList i Java

Samlingen er en Java-ramme, der giver grænseflader (Set, List, Queue og så videre) og klasser (ArrayList, LinkedList og så videre) til lagring af en samling af objekter. Disse klasser holder data i tilfældig rækkefølge. Sortering er et udtryk, der bruges til at beskrive processen med at arrangere data på en overskuelig måde. Du kan sortere på to måder:stigende eller faldende rækkefølge.

Dette afsnit vil undersøge, hvordan man sorterer en ArrayList i stigende og faldende rækkefølge.

ArrayList

ArrayList er en samlingsrammeklasse i Java, defineret i Java.util-pakken. Det er en efterkommer af klassen AbstractList. Desuden holder den styr på elementerne i realtid. ArrayList har den fordel, at den ikke har nogen størrelsesbegrænsning. Det er mere tilpasningsdygtigt end et standardarray. Det kan også indeholde duplikerede elementer. Fordi det implementerer List-grænsefladen, kan vi bruge alle List-grænsefladens metoder. En ArrayList kan sorteres på to måder:stigende og faldende. I Java har Collections-klassen to metoder til at sortere en ArrayList.

• sort()
• reverseOrder()

Collections.sort() som en metode til at sortere data i en samling

Sort()-funktionen i klassen Collections i Java bruges til at sortere en ArrayList. Det tager et ArrayList-objekt som et argument og returnerer en ArrayList, der er blevet sorteret i stigende rækkefølge i henhold til den naturlige rækkefølge af dets elementer.

Syntaksen er som følger:

public static <T extends Comparable<? super T>> void sort(List<T> list)  

Husk at alle elementer i ArrayList skal være sammenlignelige med hinanden. Ellers vil ClassCastException blive kastet. Gensidigt ens betyder, at elementerne i listen skal være af samme type. Tag for eksempel følgende kodestykke:

    //creating an instance of ArrayList that contains String type elements  
    ArrayList<String> list = new ArrayList<String>();   
    list.add("HP");  
    list.add(321);   
    list.add("IBM");  
    list.add("DELL");  

I eksemplet ovenfor består en liste af fire medlemmer, hvoraf tre er af typen String og et af dem er heltalstypen. Stringens tre elementer er udskiftelige, men integerets element er det ikke. Som følge heraf skal elementerne på listen alle være af samme type.

Collections.reverseOrder() som en metode, der vender om rækkefølgen af ​​elementer i en samling

Du kan bruge metoden reverseOrder() i Java Collections-klassen til at sortere en ArrayList i faldende rækkefølge. Det giver os mulighed for at omvendt-leksikografisk sortere ArrayList. Syntaksen for .reverseOrder() er som følger:

 public static <T> Comparator<T> reverseOrder()  

Det returnerer en komparator, der omarrangerer en samling af objekter, der implementerer den sammenlignelige grænseflade i den modsatte retning af deres naturlige rækkefølge. Det er vigtigt at huske, at vi ikke kalder reverseOrder()-metoden direkte. Som vist nedenfor, bruger vi det sammen med metoden collection.sort().

Collections.sort(objectOfArrayList, Collections.reverseOrder());

Som følge heraf udføres sortering af en ArrayList i faldende rækkefølge i to trin:For det første sorterer ArrayList dataene i stigende rækkefølge, og derefter reverseOrder()-metoden vender de sorterede data om. Lad os skrive nogle programmer for at sortere ArrayList i stigende rækkefølge.

ArrayList sorteret i stigende rækkefølge

Vi har genereret en ArrayList af typen String og tilføjet nogle medlemmer til den i følgende eksempel. Derefter videregav vi objektet i ArrayList-klassen, som er en liste, der sorterer elementerne i stigende rækkefølge, til sort()-metoden for klassen Collections.

Eksempel 1:SortArrayList

import java.util.*;   
public class SortArrayList 
{   
  public static void main(String args[])   
  {   
    // creating object of ArrayList class  
    ArrayList<String> list = new ArrayList<String>();   
    // adding elements to the ArrayList   
    list.add("DELL");   
    list.add("HP");   
    list.add("Microsoft");   
    list.add("Apple");   
    list.add("Google ");   
    list.add("Air BnB");   
    list.add("Uber ");  
    list.add("Gitlab");  
    // printing the unsorted ArrayList   
    System.out.println("Before Sorting: "+ list);   
    // Sorting ArrayList in ascending Order   
    Collections.sort(list);   
    // printing the sorted ArrayList   
    System.out.println("After Sorting: "+ list);   
  }   
}  

Eksempel 2:SortArrayList

import java.util.*;  

public class SortArrayList 
{  
  public static void main(String args[])  
  {  
    //creating an object of ArrayList class  
    ArrayList<Integer> listNumbers = new ArrayList<Integer>();  
    listNumbers.add(75);  
    listNumbers.add(52);  
    listNumbers.add(69);  
    listNumbers.add(85);  
    listNumbers.add(45);  
    listNumbers.add(60);  
    listNumbers.add(80);  
    //printing ArrayList before sorting  
    System.out.println("ArrayList Before Sorting:");  
    for(int marks: listNumbers)  
    {  
      System.out.println(marks);  
    }  
    //sorting ArrayList in ascending order  
    Collections.sort(listNumbers);  
    //printing ArrayList after sorting  
    System.out.println("ArrayList After Sorting:");  
    for(int marks: listNumbers)  
    {  
      System.out.println(marks);  
    }  
  }  
} 

ArrayList sorteret i faldende rækkefølge

Vi har genereret en ArrayList af typen String og tilføjet nogle medlemmer til den i følgende eksempel. Derefter videregav vi objektet i klassen ArrayList, som er en liste, der sorterer elementerne i faldende rækkefølge, til metoderne reverseOrder() og sort() i klassen Collections.

Eksempel:SortArrayList

import java.util.*;   
public class SortArrayListExample3  
{   
  public static void main(String args[])   
  {   
    // creating object of ArrayList class  
    ArrayList<String> languageList = new ArrayList<String>();   
    // adding elements to the ArrayList   
    languageList.add("HTML");   
    languageList.add("DotNet");   
    languageList.add("C");   
    languageList.add("Java");   
    languageList.add("Kotlin");   
    languageList.add("JavaScript ");   
    languageList.add("C++");  
    languageList.add("Python");  
    // printing the unsorted ArrayList   
    System.out.println("Before Sorting: "+ languageList);   
    // Sorting ArrayList in ascending Order   
    // using Collection.sort() method   
    Collections.sort(languageList, Collections.reverseOrder());   
    // Print the sorted ArrayList   
    System.out.println("After Sorting: "+ languageList);   
  }   
}  

Eksempel:SortArrayList

import java.util.*;  
public class SortArrayListExample4   
{  
  public static void main(String args[])  
  {  
    //creating an object of ArrayList class  
    ArrayList<Integer> numList = new ArrayList<Integer>();  
    numList.add(123);  
    numList.add(562);  
    numList.add(251);  
    numList.add(356);  
    numList.add(410);  
    numList.add(124);  
    numList.add(368);  
    //printing ArrayList before sorting  
    System.out.println("ArrayList Before Sorting:");  
    for(int marks: numList)  
    {  
      System.out.println(marks);  
    }  
    //sorting ArrayList in descending order  
    Collections.sort(numList, Collections.reverseOrder());  
    //printing ArrayList after sorting  
    System.out.println("ArrayList After Sorting:");  
    for(int marks: numList)  
    {  
      System.out.println(marks);  
    }  
  }  
}  

Eksempel:Sorter en ArrayList i stigende rækkefølge

Opgaven er at sortere en ArrayList i stigende rækkefølge i Java, givet en usorteret ArrayList. Sort()-funktionen i Collections Class i Java bruges til at sortere en ArrayList. Denne sort()-funktion accepterer en samling som et argument og producerer en samling sorteret som standard i stigende rækkefølge.

// Java program to demonstrate
// How to sort ArrayList in ascending order

import java.util.*;

public class Codeunderscored {
	public static void main(String args[])
	{

		// Get the ArrayList
		ArrayList<String> carsList = new ArrayList<String>();

		// Populate the ArrayList
		carsList.add("Toyota");
		carsList.add("BMW");
		carsList.add("Merceds-Benz");
		carsList.add("Suzuki");
		carsList.add("Tesla");

		// Print the unsorted ArrayList
		System.out.println("Unsorted ArrayList: "+ carsList);

		// Sorting ArrayList in ascending Order
		// using Collection.sort() method
		Collections.sort(carsList);

		// Print the sorted ArrayList
		System.out.println("Sorted ArrayList "
						+ "in Ascending order : "
						+ carsList);
	}
}

Eksempel:ArrayList-sortering i naturlig rækkefølge

import java.util.ArrayList;
import java.util.Comparator;

class Main {
  public static void main(String[] args) {

    // create an ArrayList
    ArrayList<String> compList = new ArrayList<>();

    // add elements to ArrayList
    compList.add("Software Engineer");
    compList.add("Backend Developer");
    compList.add("System Architect");
    compList.add("Mobile Engineer");
    System.out.println("Unsorted ArrayList: " + compList);

    // sort the ArrayList in ascending order
    compList.sort(Comparator.naturalOrder());

    System.out.println("Sorted ArrayList: " + compList);
  }
}

I det foregående eksempel brugte vi sort()-metoden til at sortere ArrayList-navngivne sprog. Bemærk linjen,

compList.sort(Comparator.naturalOrder());

Java Comparator Interfaces naturalOrder() funktion indikerer, at elementer er sorteret i naturlig rækkefølge (dvs. stigende rækkefølge). Derudover har Comparator-grænsefladen en metode til at sortere komponenter i faldende rækkefølge. Som et eksempel,

import java.util.ArrayList;
import java.util.Comparator;

class Main {
  public static void main(String[] args) {

    // create an ArrayList
    ArrayList<String> compList = new ArrayList<>();

    // add elements to ArrayList
   compList.add("Software Engineer");
    compList.add("Backend Developer");
    compList.add("System Architect");
    compList.add("Mobile Engineer");
    System.out.println("Unsorted ArrayList: " + compList);

    // sort the ArrayList in ascending order
    compList.sort(Comparator.reverseOrder());

    System.out.println("Sorted ArrayList: " + compList);
  }
}

Komparator-grænsefladens reverseOrder()-funktion angiver, at elementer er sorteret i omvendt rækkefølge (dvs. faldende rækkefølge). Collections.sort()-metoden er den mere bekvemme mulighed for at sortere en ArrayList.

Brug af Comparables til at sortere en ArrayList

Den enkelte vigtige metode i Comparable-grænsefladen er compareTo()-metoden. Et Comparable-implementeret objekt kan sammenligne sig selv med et andet Comparable-implementeret objekt af samme type. CompareTo()-metoden i klassen Ccmparable skal tilsidesættes.

Denne metode tager et objekt af samme type som compareTo() og implementerer logikken til at sammenligne det med det, der sendes ind. CompareTo()-metoden returnerer sammenligningsresultatet som et heltal. Dette objekt er større end det objekt, der leveres til compareTo(), hvis værdien er positiv. Dette objekt er mindre end det objekt, der leveres til compareTo() med en negativ værdi. Tallet nul angiver lighed mellem de to ting.

Lad os se på en CodingStudent-klasse med objekter, som vi vil gemme i en ArrayList og derefter sortere. CodingStudent-klassen omfatter tre felter:et strengnavn og køn og en heltalsalder. Vi ønsker at bruge aldersattributten til at sortere CodingStudent-objekterne i ArrayList. Vi bliver nødt til at implementere Comparable i CodingStudent-klassen og tilsidesætte compareTo()-metoden.

Dette er CodingStudent-klassens kode.

// CodingStudent.java

package guru.springframework.blog.sortarraylist.comparable;     
public class CodingStudent implements Comparable<CodingStudent> {     
  private String name;     
  private String gender;     
  private int age;       
  public CodingStudent(String name, String gender, int age) {         
    this.name = name;         
    this.gender = gender;         
    this.age = age;     
 }       

  public String getName() {         
    return name;     
  }       

  public String getGender() {         
    return gender;     
  }                      

  public int getAge() {         
    return age;     
  }       

  @Override     
  public int compareTo( CodingStudent cStudent) {          
    return (this.getAge() < cStudent.getAge() ? -1 : 
            (this.getAge() == cStudent.getAge() ? 0 : 1));     
  }       

  @Override     
  public String toString() {         
    return " Name: " + this.name + ", Gender: " + this.gender + ", age:" + this.age;     
  } 
}

Vi byggede sammenligningslogikken baseret på aldersfeltet i override compareTo()-metoden i CodingStudent-klassen ovenfor. Mange programmører er efter vores erfaring vendt tilbage til den gamle metode til at returnere sammenligningsresultatet som:

 return (this.getAge() - cStudent.getAge());

Selvom brugen af ​​denne returerklæring kan virke fristende og ikke har nogen effekt på vores eksempel, anbefaler vi, at du undgår det. Overvej resultatet af at sammenligne heltalsværdier, hvor den ene eller begge er negative.

Det kan forårsage fejl i din applikation, der får den til at opføre sig uforudsigeligt, og fordi sådanne fejl er subtile, er de svære at få øje på, især i store forretningssystemer. Derefter udvikler vi en hjælpeklasse, der sorterer ArrayList-objekter indeholdende CodingStudent-elementer for klienter.

// CodingStudentSorter.java

package guru.springframework.blog.sortarraylist.comparable;     

import java.util.ArrayList; 
import java.util.Collections;   

public class CodingStudentSorter {     
  ArrayList<CodingStudent> codingStudent = new ArrayList<>();       

  public CodingStudentSorter(ArrayList<CodingStudent> codingStudent) {         
    this.codingStudent = codingStudent;     
  }       

  public ArrayList<CodingStudent> getSortedCodingStudentByAge() {         
    Collections.sort(codingStudent);         
    return codingStudent;     
  } 
}

Vi initialiserede et ArrayList-objekt i CodingStudentSorter-klassen, som klienten vil give gennem konstruktøren ved instansiering af CodingStudentSorter. Metoden getSortedCodingStudentByAge() blev derefter oprettet. Vi sendte den initialiserede ArrayList til Collections.sort() i denne metode. Til sidst returnerer den den sorterede ArrayList. Derefter opretter vi en testklasse for at prøve vores kode.

CodingStudentSorterTest.java

package guru.springframework.blog.sortarraylist.comparable;   

import org.junit.Test;   
import java.lang.reflect.Array; 
import java.util.ArrayList;   
import static org.junit.Assert.*;     

public class CodingStudentSorterTest {       

  @Test     
  public void testGetSortedJobCandidateByAge() throws Exception {         
    CodingStudent codingStudent1 = new CodingStudent("Jane Smith", "Male", 46);         
    CodingStudent codingStudent2 = new CodingStudent("Ann Hunt", "Female", 53);         
    CodingStudent codingStudent3 = new CodingStudent("Mac Clark", "Female", 10);         
    CodingStudent codingStudent4 = new CodingStudent("Saint Styne", "Male", 74);         
    ArrayList<CodingStudent> codingStudentList = new ArrayList<>();       
  
    codingStudentList.add(codingStudent1);         
    codingStudentList.add(codingStudent2);         
    codingStudentList.add(codingStudent3);         
    codingStudentList.add(codingStudent4);       
  
    CodingStudentSorter codingStudentSorter = new CodingStudentSorter(codingStudentList);         
    ArrayList<CodingStudent> sortedCodingStudent = codingStudentSorter.getSortedCodingStudentByAge();         
    System.out.println("-----Sorted CodingStudent by age: Ascending-----");         
    for ( CodingStudent codingStudent : sortedCodingStudent ) {             
      System.out.println(codingStudent);    

Vi oprettede fire CodingStudent-objekter og føjede dem til en ArrayList i testklassen ovenfor. Vi videregav derefter vores ArrayList til konstruktøren af ​​CodingStudentSorter-klassen. Til sidst påkaldte vi CodingStudentSorters getSortedJobCandidateByAge()-metode og udskrev den sorterede ArrayList, som metoden returnerede.

Sammenlignelig er en typisk metode til at sortere en ArrayList. Du skal dog være opmærksom på nogle begrænsninger. Du skal implementere Comparable og tilsidesætte funktionen compareTo() i den klasse, hvis objekt du vil sortere. Det betyder effektivt, at du kun kan sammenligne varer baseret på ét felt (alder i vores eksempel). Hvad hvis dine krav specificerer, at du skal kunne sortere CodingStudent-objekter efter både navn og alder? Sammenlignelig er ikke svaret.

Desuden, fordi sammenligningslogikken er en del af klassen, hvis objekter skal sammenlignes, er der ingen måde, hvorpå sammenligningslogikken kan genbruges. Java leverer Comparator-grænsefladen i Java.util-pakken for at opfylde sådanne sorteringssammenligningskrav.

Brug af en komparator til at sortere en ArrayList

Komparator-grænsefladen har kun én sammenligningsmetode kaldet compare() ligesom Comparable-grænsefladen. Compare()-metoden sammenligner i modsætning til compareTo()-metoden i Comparable to separate objekter af samme type.

Komparatoren vil blive brugt til at rangordne elementer af samme CodingStudent-klasse som før, men med nogle få variationer. Ved at oprette Comparatoras anonyme indre klasser, vil vi være i stand til at sortere CodingStudent-objekter efter navn og alder.

Koden for CodingStudent-klassen ved hjælp af komparator er vist nedenfor.

CodingStudent.java
package guru.springframework.blog.sortarraylist.comparator;     

import java.util.Comparator;   

public class CodingStudent {     
  private String name;     
  private String gender;     
  private int age;       

  public CodingStudent(String name, String gender, int age) {         
    this.name = name;         
    this.gender = gender;         
    this.age = age;     
  }       

  public String getName() {         
    return name;     
  }       

  public String getGender() {         
    return gender;     
  }       

  public int getAge() {         
    return age;     
  }       

  public static Comparator<CodingStudent> ageComparator = new Comparator<CodingStudent>() {         
    @Override         
    public int compare( CodingStudent cs1, CodingStudent cs2) {             
      return (cs2.getAge() < cs1.getAge() ? -1 :                     
              (cs2.getAge() == cs1.getAge() ? 0 : 1));           
    }     
  };       

  public static Comparator<CodingStudent> nameComparator = new Comparator<CodingStudent>() {         
    @Override         
    public int compare( CodingStudent cs1, CodingStudent cs2) {             
      return (int) (cs1.getName().compareTo(cs2.getName()));         
    }     
  };         

  @Override     
  public String toString() {         
    return " Name: " + this.name + ", Gender: " + this.gender + ", age:" + this.age;     
  } 
}

Fra linje 29 til linje 35 i ovenstående klasse oprettede vi en anonym klasse og implementerede compare()-metoden, som giver os mulighed for at rangere CodingStudent-objekterne efter alder i faldende rækkefølge.

Vi oprettede en anden anonym klasse og implementerede compare()-metoden fra linje 37 til linje 42, som giver os mulighed for at rangere CodingStudent-objekter efter navn i stigende rækkefølge. Vi vil nu oprette en klasse, der sorterer ArrayLists elementer for klienter.

// CodingStudentSorter.java

package guru.springframework.blog.sortarraylist.comparator;     

import java.util.ArrayList; 
import java.util.Collections;                  

public class CodingStudentSorter {     
  ArrayList<CodingStudent> codingStudent = new ArrayList<>();       

  public CodingStudentSorter(ArrayList<CodingStudent> codingStudent) {         
    this.codingStudent = codingStudent;     
  }       

  public ArrayList<CodingStudent> getSortedCodingStudentByAge() {         
    Collections.sort(codingStudent, CodingStudent.ageComparator);         
    return codingStudent;     
  }       

  public ArrayList<JobCandidate> getSortedCodingStudentByName() {         
    Collections.sort(codingStudent, CodingStudent.nameComparator);         
    return codingStudent;     
  } 
}

GetSortedCodingStudentByAge() metoden blev skrevet i den forrige klasse. Vi brugte den overbelastede form for samlinger i denne metode. sort() tager to argumenter:et ArrayList-objekt til at sortere og et Comparator-objekt til at sammenligne alder. Vi brugte den overbelastede version af Collections igen i getSortedCodingStudentByName() metoden. sort() returnerer et ArrayList-objekt sorteret og et Comparator-objekt, der bruges til at sammenligne navne. Lad os oprette en testklasse for at prøve vores kode.

CodingStudentSorterTest.java

package guru.springframework.blog.sortarraylist.comparator;     

import guru.springframework.blog.sortarraylist.comparator.CodingStudent ; 
import guru.springframework.blog.sortarraylist.comparator.CodingStudentSorter; 

import org.junit.Before; 
import org.junit.Test;   
import java.util.ArrayList;   
import static org.junit.Assert.*;   

public class CodingStudentSorterTest {     
  CodingStudentSorter codingStudentSorter;       

  @Before     
  public void setUp() throws Exception {         
    CodingStudent codingStudent1 = new CodingStudent("Mark Smith", "Male", 26);         
    CodingStudent codingStudent2 = new CodingStudent("Sandy Hunt", "Female", 23);         
    CodingStudent codingStudent3 = new CodingStudent("Betty Clark", "Female", 20);         
    CodingStudent codingStudent4 = new CodingStudent("Andrew Styne", "Male", 24);         
    ArrayList<CodingStudent> codingStudentList = new ArrayList<>();         
    codingStudentList.add(codingStudent1);         
    codingStudentList.add(codingStudent2);         
    codingStudentList.add(codingStudent3);         
    codingStudentList.add(codingStudent4);         
    codingStudentSorter = new CodingStudentSorter(codingStudentList);     
  }       

  @Test     
  public void testGetSortedCodingStudentByAge() throws Exception {         
    System.out.println("-----Sorted CodingStudent by age: Descending-----");         
    ArrayList<CodingStudent> sortedCodingStudent = codingStudent Sorter.getSortedCodingStudentByAge();         
    for ( CodingStudent codingStudent : sortedCodingStudent ) {             
      System.out.println(codingStudent);         
    }     
  }       

  @Test     
  public void testGetSortedCodingStudentByName() throws Exception {         
    System.out.println("-----Sorted CodingStudent by name: Ascending-----");         
    ArrayList<CodingStudent> sortedCodingStudent = codingStudentSorter.getSortedCodingStudentByName();         
    for ( CodingStudent codingStudent : sortedCodingStudent) {             
      System.out.println(codingStudent);         
    }       
  } 
}

I JUnit setup()-metoden, der er kommenteret med @Before, udfyldte vi CodingStudent-objekter i en ArrayList og genererede et CodingStudentSorter-objekt i testklassen.

Vi påberåbte getSortedCodingStudentByAge()-metoden i testGetSortedCodingStudentByAge()-metoden og skrev den sorterede ArrayList, som funktionen returnerer i thetestGetSortedCodingStudentByAge()-metoden. GetSortedCodingStudentByName()-funktionen blev kaldt i testGetSortedCodingStudentByName()-testmetoden, og den sorterede ArrayList returneret af metoden blev skrevet ud.

Konklusion

På grund af sin funktionalitet og alsidighed er ArrayList en af ​​de mest brugte samlingsklasser i Java Collection Framework. ArrayList er en listeimplementering, der bruger et dynamisk array til at gemme elementer internt. Som et resultat, når du tilføjer og sletter elementer fra en ArrayList, kan den dynamisk vokse og falde.

Vi har gennemgået en af ​​de væsentlige ArrayList-operationer, som du næsten helt sikkert skal bruge under udvikling af virksomhedens applikationer. Det sorterer en ArrayLists elementer.

Vi så på forskellige metoder til sortering af ArrayList-medlemmer. Den ene anvender Comparable, mens den anden anvender komparator. For programmører har tilgangen til at vælge altid været en kilde til bestyrtelse. I det væsentlige kan et sammenligneligt objekt sige:"Jeg kan sammenligne mig selv med et andet objekt", mens et sammenligningsobjekt kan sige:"Jeg kan sammenligne to forskellige objekter." Det er umuligt at sige, at den ene grænseflade er den anden overlegen. Den grænseflade, du vælger, bestemmes af de muligheder, du har brug for.