Programa Java para eliminar un elemento específico de una colección

El método remove() se utiliza para eliminar elementos de una colección. Elimina el elemento en la posición especificada en esta lista. Desplaza cualquier elemento subsiguiente a la izquierda restando uno de sus índices. En palabras más simples, el método remove() se usa para eliminar el elemento de un índice específico de una lista eliminando el valor y devolviendo el mismo.

Enfoques: Hay dos métodos estándar definidos sobre este método que son los siguientes.

1. eliminar (índice int)
2. eliminar (Objeto objeto)

Método 1: El método remove(int index) de la interfaz List en Java se usa para eliminar un elemento del índice especificado de un contenedor List y devuelve el elemento después de eliminarlo. También desplaza los elementos después del elemento eliminado 1 posición hacia la izquierda en la Lista. 

Sintaxis :

remove(int index)

Parámetros: Toma un parámetro de tipo int como atravesar sobre índice donde el valor de índice es el valor que se eliminará de la lista. 

Tipo de valor devuelto: una ArrayList de la que se han eliminado algunos elementos.

Excepciones: al tratar con índices con el tamaño especificado, definitivamente ArrayOutOfBounds se lanza en dos escenarios

• Cualquiera de las menciones del índice es negativa
• El índice mencionado está más allá (mayor) del índice de ArrayList

Ejemplo:

// Java Program to Remove a Specific
// Element from a Collection
 
// Importing Java libraries
import java.util.List;
import java.util.ArrayList;
 
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an ArrayList
        List<Integer> al = new ArrayList<>();
 
        // Inserting % elements to it
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(1);
        al.add(2);
 
        // If elements set is larger use
        // iteration in loops to insert element
 
        // Display ArrayList after insertion
        System.out.println("Original ArrayList : " + al);
 
        // Making 1st remove call
        // which throw 20 out of list
        al.remove(1);
       
        // Here ArrayList: 10 30 1 2
 
        // Making 2nd remove call
        // which throw 30 out of list
        al.remove(1);
        // Here ArrayList: 10 1 2
 
        // Printing modified Arraylist after deleting few
        // elements
        System.out.println("Modified ArrayList : " + al);
    }
}

Original ArrayList : [10, 20, 30, 1, 2]
Modified ArrayList : [10, 1, 2]

Método 2: El método remove(Object obj) de la interfaz List en Java se usa para eliminar la primera aparición del elemento obj especificado de esta Lista si está presente en la Lista.

Sintaxis :

boolean remove(Object obj)

Parámetros : Acepta un solo parámetro obj de tipo Lista que representa el elemento a ser eliminado de la lista dada.

Valor devuelto : devuelve un valor booleano verdadero después de eliminar la primera aparición del elemento especificado de la lista y, de lo contrario, si el elemento no está presente en la lista, este método devolverá falso.

Ejemplo:

// Java program to demonstrate working of remove()
// method on an integer arraylist
 
// Importing specific libraries
import java.util.List;
import java.util.ArrayList;
 
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an ArrayList and
        // storing elements in list
        List<Integer> al = new ArrayList<>();
 
        // Addition of elements to List
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(1);
        al.add(2);
 
        // This makes a call to remove(Object) and
        // removes element 1
        al.remove(new Integer(1));
 
        // This makes a call to remove(Object) and
        // removes element 2
        al.remove(new Integer(2));
 
        // Printing modified ArrayList
        System.out.println("Modified ArrayList : " + al);
    }
}

Producción:

Modified ArrayList : [10, 20, 30]

Nota : A veces arroja una advertencia sobre el uso de una llamada de función u objeto obsoletos. Uno puede recompilar como para averiguar dónde está ocurriendo. En general, es una mala idea usar bibliotecas en desuso que pueden desaparecer en la próxima versión.