Interfaz de colección en Java con ejemplos

La interfaz Collection es miembro de Java Collections Framework . Es una parte del paquete java.util . Es una de las interfaces raíz de la jerarquía de colecciones. La interfaz Collection no está implementada directamente por ninguna clase. Sin embargo, se implementa indirectamente a través de sus subtipos o subinterfaces como List , Queue y Set . 

Por ejemplo, la clase HashSet implementa la interfaz Set, que es una subinterfaz de la interfaz Collection. Si una implementación de colección no implementa una operación en particular, debe definir el método correspondiente para lanzar UnsupportedOperationException .

La jerarquía de la colección

Implementa la interfaz Iterable<E> . Las subinterfaces de Collection son BeanContext , BeanContextServices , BlockingDeque<E> , BlockingQueue<E> , Deque<E> , EventSet , List<E> , NavigableSet<E> , Queue<E> , Set<E> , SortedSet< E> , TransferQueue<E> .

Subinterfaces de la interfaz de colección

Todas las Clases del Marco de Colección implementan las subInterfaces de la Interfaz de Colección. Todos los métodos de las interfaces de colección también están contenidos en sus subinterfaces. Estas subinterfaces a veces se denominan tipos de colección o subtipos de colección. Estos incluyen lo siguiente:

Lista : esta es una interfaz secundaria de la interfaz de colección. Esta interfaz está dedicada a los datos de tipo lista en la que podemos almacenar toda la colección ordenada de los objetos. Esto también permite que haya datos duplicados en él. Esta interfaz de lista está implementada por varias clases como ArrayList , Vector , Stack , etc. Dado que todas las subclases implementan la lista, podemos crear una instancia de un objeto de lista con cualquiera de estas clases. Por ejemplo,

Lista <T> al = new ArrayList<>();

Lista <T> ll = new LinkedList<>();

Lista <T> v = nuevo Vector<>();

Donde T es el tipo del objeto

Conjunto : un conjunto es una colección desordenada de objetos en los que no se pueden almacenar valores duplicados. Esta colección se utiliza cuando deseamos evitar la duplicación de los objetos y deseamos almacenar solo los objetos únicos. Esta interfaz de conjunto es implementada por varias clases como HashSet , TreeSet , LinkedHashSet , etc. Dado que todas las subclases implementan el conjunto, podemos instanciar un objeto de conjunto con cualquiera de estas clases. Por ejemplo,

Set<T> hs = nuevo HashSet<>();

Set<T> lhs = nuevo LinkedHashSet<>();

Set<T> ts = nuevo TreeSet<>();

Donde T es el tipo del objeto.

SortedSet : esta interfaz es muy similar a la interfaz del conjunto. La única diferencia es que esta interfaz tiene métodos extra que mantienen el orden de los elementos. La interfaz de conjuntos ordenados amplía la interfaz de conjuntos y se utiliza para manejar los datos que deben clasificarse. La clase que implementa esta interfaz es TreeSet . Dado que esta clase implementa SortedSet, podemos instanciar un objeto SortedSet con esta clase. Por ejemplo,

SortedSet<T> ts = nuevo TreeSet<>();

Donde T es el tipo del objeto.

Cola : como sugiere el nombre, una interfaz de cola mantiene el orden FIFO (primero en entrar, primero en salir) similar a una línea de cola del mundo real. Esta interfaz está dedicada a almacenar todos los elementos donde importa el orden de los elementos. Por ejemplo, cada vez que tratamos de reservar un boleto, los boletos se venden por orden de llegada. Por lo tanto, la persona cuya solicitud llega primero a la cola obtiene el boleto. Hay varias clases como PriorityQueue , Deque , ArrayDeque , etc. Dado que todas estas subclases implementan la cola, podemos instanciar un objeto de cola con cualquiera de estas clases. Por ejemplo,

Cola <T> pq = new PriorityQueue<>();

Cola <T> ad = new ArrayDeque<>();

Donde T es el tipo del objeto.

Deque : Esta es una variación muy leve de la estructura de datos de la cola . Deque , también conocida como cola de dos extremos, es una estructura de datos en la que podemos agregar y eliminar los elementos de ambos extremos de la cola. Esta interfaz amplía la interfaz de cola. La clase que implementa esta interfaz es ArrayDeque . Dado que esta clase implementa el deque, podemos instanciar un objeto deque con esta clase. Por ejemplo,

Deque<T> anuncio = new ArrayDeque<>();

Donde T es el tipo del objeto.

Declaración:

public interface Collection<E> extends Iterable<E>

Aquí, E es el tipo de elementos almacenados en la colección.

Ejemplo:

// Java program to illustrate Collection interface
 
import java.io.*;
import java.util.*;
 
public class CollectionDemo {
    public static void main(String args[])
    {
 
        // creating an empty LinkedList
        Collection<String> list = new LinkedList<String>();
 
        // use add() method to add elements in the list
        list.add("Geeks");
        list.add("for");
        list.add("Geeks");
 
        // Output the present list
        System.out.println("The list is: " + list);
 
        // Adding new elements to the end
        list.add("Last");
        list.add("Element");
 
        // printing the new list
        System.out.println("The new List is: " + list);
    }
}

The list is: [Geeks, for, Geeks]
The new List is: [Geeks, for, Geeks, Last, Element]

Implementando Clases

La interfaz de colección está implementada por AbstractCollection , AbstractList , AbstractQueue , AbstractSequentialList , AbstractSet , ArrayBlockingQueue , ArrayDeque , ArrayList , AttributeList , BeanContextServicesSupport , BeanContextSupport , ConcurrentHashMap.KeySetView , ConcurrentLinkedDeque , ConcurrentLinkedQueue , ConcurrentSkipListSet , CopyOnWrite OnrayWlayListAr , CopyEnumSet , HashSet , JobStateReasons , LinkedBlockingDeque , LinkedBlockingQueue , LinkedHashSet , LinkedList , LinkedTransferQueue , PriorityBlockingQueue , PriorityQueue , RoleList , RoleUnresolvedList , Stack , SynchronousQueue , TreeSet , Vector .

Sintaxis: 

Collection<E> objectName = new ArrayList<E>();

Aquí, E es el tipo de elementos almacenados en la colección.

Nota: en la sintaxis anterior, podemos reemplazar cualquier clase con ArrayList si esa clase implementa la interfaz Collection. 

Operaciones básicas

1. Agregar elementos 

Los métodos add(E e) y addAll(Collection c) proporcionados por Collection se pueden usar para agregar elementos. 

// Java code to illustrate adding
// elements to the Collection
 
import java.io.*;
import java.util.*;
 
public class AddingElementsExample {
    public static void main(String[] args)
    {
 
        // create an empty array list with an initial
        // capacity
        Collection<Integer> list1 = new ArrayList<Integer>(5);
 
        // use add() method to add elements in the list
        list1.add(15);
        list1.add(20);
        list1.add(25);
 
        // prints all the elements available in list
        for (Integer number : list1) {
            System.out.println("Number = " + number);
        }
 
        // Creating an empty ArrayList
        Collection<Integer> list2 = new ArrayList<Integer>();
 
        // Appending the collection to the list
        list2.addAll(list1);
 
        // displaying the modified ArrayList
        System.out.println("The new ArrayList is: " + list2);
    }
}

Number = 15
Number = 20
Number = 25
The new ArrayList is: [15, 20, 25]

2. Eliminación de elementos

Los métodos remove(E e) y removeAll(Collection c) se pueden usar para eliminar un elemento en particular o una colección de elementos de una colección. 

// Java program to demonstrate removing
// elements from a Collection
 
import java.util.*;
 
public class RemoveElementsExample {
    public static void main(String[] argv) throws Exception
    {
 
        // Creating object of HashSet<Integer>
        Collection<Integer> set1 = new HashSet<Integer>();
 
        // Populating arrset1
        set1.add(1);
        set1.add(2);
        set1.add(3);
        set1.add(4);
        set1.add(5);
 
        // print set1
        System.out.println("Initial set1 : " + set1);
         
          // remove a particular element
          set1.remove(4);
       
          // print modified set1
        System.out.println("set1 after removing 4 : " + set1);
       
        // Creating another object of HashSet<Integer>
        Collection<Integer> set2 = new HashSet<Integer>();
        set2.add(1);
        set2.add(2);
        set2.add(3);
 
        // print set2
        System.out.println("Collection Elements to be removed : " + set2);
 
        // Removing elements from set1
        // specified in set2
        // using removeAll() method
        set1.removeAll(set2);
 
        // print arrset1
        System.out.println("set 1 after removeAll() operation : " + set1);
    }
}

Initial set1 : [1, 2, 3, 4, 5]
set1 after removing 4 : [1, 2, 3, 5]
Collection Elements to be removed : [1, 2, 3]
set 1 after removeAll() operation : [5]

3. Iterando 

Para iterar sobre los elementos de la Colección podemos usar el método iterator() . 

// Java code to illustrate iterating
// over a Collection
 
import java.util.*;
 
public class IteratingExample {
 
    public static void main(String[] args)
    {
        // Create and populate the list
        Collection<String> list = new LinkedList<>();
 
        list.add("Geeks");
        list.add("for");
        list.add("Geeks");
        list.add("is");
        list.add("a");
        list.add("CS");
        list.add("Students");
        list.add("Portal");
 
        // Displaying the list
        System.out.println("The list is: " + list);
 
        // Create an iterator for the list
        // using iterator() method
        Iterator<String> iter = list.iterator();
 
        // Displaying the values after iterating
        // through the list
        System.out.println("\nThe iterator values" + " of list are: ");
        while (iter.hasNext()) {
            System.out.print(iter.next() + " ");
        }
    }
}

The list is: [Geeks, for, Geeks, is, a, CS, Students, Portal]

The iterator values of list are: 
Geeks for Geeks is a CS Students Portal

Métodos de recolección

Métodos declarados en la interfaz java.lang.Iterable

Referencia: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html