Metoden Arrays.sort() i Java används för att sortera elementen i en array.

• Det ger flexibla alternativ för att sortera hela arrays subarrayer eller till och med anpassade objekt med hjälp av komparatorer.
• Kan sortera både primitiva arrayer (int char etc.) och objekt arrays (Integer String etc.).

Exempel: Sortering av heltals- och teckenmatriser i stigande ordning

import java.util.Arrays; class Geeks{    public static void main(String[] args) {  // Integer array  int[] arr1 = {2 -1 3 4};  // Character array  char[] arr2 = {'b' 'a' 'c' 'b'};  // Sorting arrays in ascending order  Arrays.sort(arr1);   Arrays.sort(arr2);  // Print sorted arrays  System.out.println(Arrays.toString(arr1));   System.out.println(Arrays.toString(arr2));  } } 

[-1 2 3 4] [a b b c] 

Förklaring:

• Arrays.sort() ordnar om element i stigande ordning.
• Dubletter tas inte bort.
• Primitiva arrayer kan inte använda anpassade komparatorer.

Syntax för Arrays.sort()-metoden

1. För att sortera hela arrayen

Arrays.sort(); 

2. För att sortera en undergrupp

public static void sort(int[] arr int from_Index int to_Index) ;

Parametrar:

• arr : Matrisen som ska sorteras.
• from_Index: Indexet för det första elementet (inklusive) som ska sorteras.
• to_Index : Indexet för det sista elementet (exklusivt) som ska sorteras.
• Returtyp: void (denna metod returnerar inget).

Notera:

• Arrays.sort() tar inte bort dubbletter; det ordnar bara om element.
• Primitiva typer kan inte använda anpassade komparatorer; sorteringen sker i naturlig (stigande) ordning.

Exempel: Sortering av subarray

Du kan sortera en del av en array genom att ange start- (inklusive) och slut (exklusiva) index.

import java.util.Arrays; public class Geeks{    public static void main(String[] args){  int[] arr = {2 -1 4 3};  // Sort elements from index 1 to 3  Arrays.sort(arr 1 4);  // Print array after sorting subarray  System.out.println(Arrays.toString(arr));  } } 

[2 -1 3 4] 

Förklaring: Endast elementen vid index 1 2 och 3 sorteras; elementet vid index 0 förblir oförändrat.

Sortering i fallande ordning

För att sortera en array i fallande ordning kan vi använda metoden Arrays.sort() med Collections.reverseOrder() som en komparator.

import java.util.Arrays; import java.util.Collections; public class Geeks{  public static void main(String[] args) {  // Integer array  Integer[] arr = {2 -1 3 4};  Arrays.sort(arr Collections.reverseOrder());   System.out.println(Arrays.toString(arr));   // String array  String[] str = {'Hii' 'Vishnu' 'chauhan'};  Arrays.sort(str Collections.reverseOrder());   System.out.println(Arrays.toString(str));  } } 

[4 3 2 -1] [chauhan Vishnu Hii] 

Förklaring:

• Fungerar endast på objektmatriser; primitiva typer (int) kan inte använda komparatorer.
• For Strings sorterar lexikografiskt från Z -> A.

Anpassad sortering med komparator

Vi kan sortera en rad objekt genom att definiera anpassad sorteringslogik med hjälp av  Jämförelsegränssnitt .

import java.util.*; // Custom class class Student{    int roll;  String name;  String address;  Student(int roll String name String address){    this.roll = roll;  this.name = name;  this.address = address;  }  // Print student details  public String toString() {  return roll + ' ' + name + ' ' + address;  } } // Comparator to sort by roll number class SortByRoll implements Comparator<Student>{    public int compare(Student s1 Student s2){    return s1.roll - s2.roll;  } } class Geeks {  public static void main(String[] args){  Student[] students = {  new Student(1 'Ram' 'MP')  new Student(2 'Shyam' 'UP')  new Student(3 'Hari' 'Delhi')  };  // Sort using custom comparator  Arrays.sort(students new SortByRoll());  // Print sorted students  for (Student s : students)  System.out.println(s);  } } 

1 Ram MP 2 Shyam UP 3 Hari Delhi 

Förklaring:

• Comparator tillåter anpassad sorteringslogik utan att ändra klassen.
• Här sorteras eleverna efter rullnummer.

Naturlig sortering med jämförbart gränssnitt

I exemplet nedan sorterar vi en array av studentobjekt baserat på deras namn alfabetiskt.

import java.util.Arrays; class Student implements Comparable<Student>{    int r;  String n;  String a;  // Constructor  public Student(int r String n String a){    this.r = r;  this.n = n;  this.a = a;  }  // compareTo method to sort by name  public int compareTo(Student o){    return this.n.compareTo(o.n);  }  // toString() method to print Student details  public String toString() {  return this.r + ' ' + this.n + ' ' + this.a;  } } public class Geeks{    public static void main(String[] args){    Student[] s = {  new Student(1 'Ram' 'UP')  new Student(2 'Shyam' 'MP')  new Student(3 'Hari' 'Bihar')  };  // Sorting students by name in alphabetical order  Arrays.sort(s);  for (Student student : s)  System.out.println(student);  } } 

3 Hari Bihar 1 Ram UP 2 Shyam MP 

Förklaring:

• I det här exemplet använder vi Jämförbart gränssnitt att definiera en naturlig ordning för Studentobjekten.
• Genom att implementera metoden specificerar vi hur två Studentobjekt ska jämföras genom att möjliggöra sortering utifrån elevens namn.

Detta tillåter oss att använda metoden Arrays.sort() direkt på en array av Student-objekt för att sortera dem i en ordning och här behöver vi inte en separat komparator.