¿Cómo ordenar elementos vectoriales usando una interfaz comparable en Java?

Vector es una interfaz secundaria de colección. Si queremos representar un grupo de objetos individuales como una sola entidad en la que se permiten duplicados y se debe conservar el orden de inserción, entonces debemos optar por el vector. Es una array redimensionable o ampliable. Implementa una interfaz Serializable, Cloneable y RandomAccess. Todos los métodos presentes en el vector están sincronizados y, por lo tanto, el objeto vector es seguro para subprocesos.

La interfaz comparable se utiliza para ordenar los objetos de la clase definida por el usuario. Esta interfaz está presente en el paquete java.lang’ y contiene solo un método compareTo(object). Pero solo proporciona una única secuencia de clasificación, es decir, podemos clasificar elementos sobre la base de miembros de datos individuales.

método compareTo()

Este método se utiliza para comparar el objeto actual con el objeto especificado y devuelve tres valores según la comparación de los dos objetos. Usando la interfaz Comparable, podemos ordenar los elementos de los objetos de clase String, los objetos de clase definidos por el usuario y todos los objetos de clase contenedora.

Sintaxis:

public int compareTo(Object obj); 

Tipo de devolución: valor entero

• Valor negativo si y solo si el primer objeto tiene que venir antes que el segundo objeto.
• Valor positivo si y solo si el primer objeto tiene que venir después del segundo objeto.
• Cero si y solo si el primer objeto es igual al segundo objeto.

Colecciones es una clase de utilidad presente en el paquete java.util ‘ para definir varios métodos de utilidad para objetos de colección como ordenar, buscar e invertir, etc.

Para ordenar los elementos de una lista, la clase Collections define los dos métodos de ordenación de la siguiente manera:

1. Clasificación vacía estática pública (Lista l): para clasificar según el orden de clasificación natural predeterminado. En este caso, una lista debe contener un objeto homogéneo o un objeto comparable; de ​​lo contrario, obtendremos una excepción de tiempo de ejecución. Además, la lista no debe contener un valor nulo; de lo contrario, obtendremos NullPointerException .
2. Clasificación vacía estática pública (Lista l, Comparador c): para clasificar en función de órdenes de clasificación personalizadas.

Implementación:

Considere crear un nombre de clase personalizado Estudiantes que implemente la interfaz comparable en la que obtenemos la identificación de cada estudiante. Dentro de la clase de controlador, creamos un vector de tipo clase de estudiante, y luego podemos ordenar los elementos del vector usando la interfaz comparable comparando la identificación de los estudiantes. 

Ejemplo 1:

// Java Program to Sort Vector Elements
// using Comparable Interface
 
// Importing Collections and Vector classes from
// java.util package
import java.util.*;
import java.util.Collections;
import java.util.Vector;
 
// Class 1
// Helper class
// Class implementing comparable interface
class Student implements Comparable<Student> {
 
    // Declaring a variable
    private int id;
   
    // Initializing the above variable through
    // self constructor of this class
    public Student(int id)
    {
 
        // 'this' keyword refers to current object itself
        this.id = id;
    }
 
    // Converting the above Integer variable to String
    public String toString()
    {
        return "Student[" + this.id + "]";
    }
 
    // Getting the 'id'
    public int getId() { return this.id; }
 
    // Comparing the ids of two student
    // using the compareTo() method
    public int compareTo(Student otherStudent)
    {
        return this.getId() - otherStudent.getId();
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of Vector type
        // Declaring object of Student(user-defined type)
        Vector<Student> student = new Vector<>();
 
        // Adding student id to vector
        // Custom input elements
        student.add(new Student(1));
        student.add(new Student(2));
        student.add(new Student(9));
        student.add(new Student(4));
        student.add(new Student(34));
 
        // Print all the elements
        // before sorting
        System.out.println(student);
 
        // Calling sort() method of collections
        Collections.sort(student);
 
        // Print all the elements
        // after sorting
        System.out.println(student);
    }
}

[Student[1], Student[2], Student[9], Student[4], Student[34]]
[Student[1], Student[2], Student[4], Student[9], Student[34]]

Ejemplo 2: nombre del estudiante, calificaciones e identificación en el que vamos a ordenar el vector en función de las calificaciones de los estudiantes 

// Java Program to Sort Vector Elements
// using Comparable Interface
 
// Importing Collection an Vector classes from
// java.util package
import java.util.Collections;
import java.util.Vector;
import java.util.*;
 
// Class 1
// Helper class
// Class implementing comparable interface
class Student implements Comparable<Student> {
 
// // Declaring a variables- student name , marks and id
String name;
int marks;
int id;
 
// Initializing the above variable through
// self constructor of this class
public Student(String name,int marks,int id) {
 
  // 'this' keyword refers to current object itself 
  this.name=name;
  this.marks=marks;
  this.id=id;
  }
 
// Getting the 'id'
public int getMarks(){
 return this.marks;
 }
 
// Comparing the ids of two student
// using the compareTo() method
public int compareTo(Student otherStudent) {
 
  return this.getMarks()-otherStudent.getMarks();
  }
 
}
 
// Class 2
// Main class
class GFG {
 
// Main driver method
public static void main(String[] args) {
 
// Creating an object of Vector type
// Declaring object of Student(user-defined type)
Vector<Student> student= new Vector<>();
 
// Adding student id to vector
// Custom input elements
student.add(new Student("Roshan",86,1));
student.add(new Student("Ritik",96,2));
student.add(new Student("Ashish",99,4));
student.add(new Student("Sandeep",100,9));
student.add(new Student("Piyush",88,34));
 
// Iterate over the sorted vector
// using for each loop
// before calling sort() method
for(Student s : student)
 
// Print and display the sorted vector
System.out.println("Name:"+s.name +"->"+"Marks:"+s.marks+"->"+"ID:"+s.id);
 
// New line
System.out.println() ;
 
// Calling sort() method of collections
Collections.sort(student);
 
// Iterate over the sorted vector
// using for each loop
// after calling sort() method
for(Student s : student)
 
// Print and display the sorted vector
System.out.println("Name:"+s.name +"->"+"Marks:"+s.marks+"->"+"ID:"+s.id);
 
}
 
}

Name:Roshan->Marks:86->ID:1
Name:Ritik->Marks:96->ID:2
Name:Ashish->Marks:99->ID:4
Name:Sandeep->Marks:100->ID:9
Name:Piyush->Marks:88->ID:34

Name:Roshan->Marks:86->ID:1
Name:Piyush->Marks:88->ID:34
Name:Ritik->Marks:96->ID:2
Name:Ashish->Marks:99->ID:4
Name:Sandeep->Marks:100->ID:9