La clase Vector en Java implementa una array dinámica, es decir, puede crecer y reducirse según los elementos que insertemos o eliminemos de ella. Implementa la interfaz List por lo que admite todos los métodos proporcionados por la interfaz List.
En este artículo, vamos a discutir cómo podemos encontrar los elementos mínimos y máximos de un Vector usando la interfaz Comparable en Java.
Podemos usar los métodos Collections.min() y Collections.max() para encontrar los elementos mínimos y máximos dentro de nuestro Vector. Pero cuando estamos usando nuestra clase personalizada y queremos usar el método Collections.min() y Collections.max(), primero debemos anular el método compareTo() de la interfaz Comparable para que Java pueda comparar las instancias de nuestra clase personalizada. Además, como queremos comparar el objeto, no los tipos de datos primitivos, tenemos que usar el método compareTo() personalizado de la interfaz Comparable.
Sintaxis para implementar la interfaz Comparable<T>:
class Account implements Comparable<Account>
Usando la sintaxis anterior, podemos implementar la interfaz Comparable para nuestra clase personalizada, es decir, la clase Cuenta.
Sintaxis para anular el método CompareTo():
@Override
public int compareTo(Account o) {
// this refers to the current object(child object)
// and o is the parent object.
return this.balance - o.balance;
}
El compareTo() anterior compara los objetos Cuenta en función de su atributo de saldo. Nuestro método compareTo() debe devolver:
- Cero: cuando ambos Objetos son iguales.
- Valor negativo: cuando el objeto actual es menor que el objeto pasado, es decir, ‘o’.
- Valor positivo: cuando el objeto actual es mayor que el objeto pasado.
A continuación se muestra la implementación del código para encontrar un elemento mínimo y máximo del vector utilizando la interfaz comparable.
Java
// Java Program to find Minimum And Maximum Element of
// Vector using Comparable Interface in Java?
import java.util.Collections;
import java.util.Vector;
// The class Account implements the Comparable<T>
// interface
class Account implements Comparable<Account> {
private String name;
private int balance;
// Creating parameterized constructor for
// Account class
public Account(String name, int balance)
{
this.name = name;
this.balance = balance;
}
// Creating getters for Account class
public String getName() { return name; }
public int getBalance() { return balance; }
// We are overriding the CompareTo method of the
// Comparable interface to be able to compare the
// objects of the Account class CompareTo method should
// returns 0 when two Objects are equal, negative value
// when current object is less than 'o' otherwise
// returns positive value
@Override public int compareTo(Account o)
{
return this.balance - o.balance;
}
}
public class GFG {
public static void main(String[] args)
{
// Creating a Vector of Account type
Vector<Account> accountVector = new Vector<>();
// Inserting some Objects inside the accountVector
accountVector.add(new Account("Rahul", 10000));
accountVector.add(new Account("Anjali", 2000));
accountVector.add(new Account("Rohan", 5000));
accountVector.add(new Account("Pooja", 50000));
accountVector.add(new Account("Nandini", 50));
// Finding the Accounts with minimum and maximum
// balance using the Collections.min() and
// Collections.max() method
Account minAccount = Collections.min(accountVector);
Account maxAccount = Collections.max(accountVector);
// Displaying the account details of the the
// Accounts having minimum and maximum balance
System.out.println(
minAccount.getName()
+ " has the minimum balance of Rs "
+ minAccount.getBalance());
System.out.println(
maxAccount.getName()
+ " has the maximum balance of Rs "
+ maxAccount.getBalance());
}
}
Nandini has the minimum balance of Rs 50 Pooja has the maximum balance of Rs 50000
Publicación traducida automáticamente
Artículo escrito por shivamsingh00141 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA