Colecciones en Java

Cualquier grupo de objetos individuales que se representan como una sola unidad se conoce como la colección de los objetos. En Java, se ha definido  un marco separado llamado «Marco de colección» en JDK 1.2 que contiene todas las clases de colección y la interfaz.

La interfaz de colección ( java.util.Collection ) y la interfaz de mapa ( java.util.Map ) son las dos interfaces «raíz» principales de las clases de colección de Java.

// Java program to demonstrate
// why collection framework was needed
import java.io.*;
import java.util.*;
  
class CollectionDemo {
  
    public static void main(String[] args)
    {
        // Creating instances of the array,
        // vector and hashtable
        int arr[] = new int[] { 1, 2, 3, 4 };
        Vector<Integer> v = new Vector();
        Hashtable<Integer, String> h = new Hashtable();
  
        // Adding the elements into the
        // vector
        v.addElement(1);
        v.addElement(2);
  
        // Adding the element into the
        // hashtable
        h.put(1, "geeks");
        h.put(2, "4geeks");
  
        // Array instance creation requires [],
        // while Vector and hastable require ()
        // Vector element insertion requires addElement(),
        // but hashtable element insertion requires put()
  
        // Accessing the first element of the
        // array, vector and hashtable
        System.out.println(arr[0]);
        System.out.println(v.elementAt(0));
        System.out.println(h.get(1));
  
        // Array elements are accessed using [],
        // vector elements using elementAt()
        // and hashtable elements using get()
    }
}

El paquete de utilidades (java.util) contiene todas las clases e interfaces que requiere el marco de la colección. El marco de la colección contiene una interfaz llamada interfaz iterable que proporciona al iterador para iterar a través de todas las colecciones. Esta interfaz se amplía con la interfaz de la colección principal, que actúa como raíz para el marco de la colección. Todas las colecciones amplían esta interfaz de colección, extendiendo así las propiedades del iterador y los métodos de esta interfaz. La figura siguiente ilustra la jerarquía del marco de recopilación. 

Antes de comprender los diferentes componentes en el marco anterior, primero comprendamos una clase y una interfaz. 

• Clase : una clase es un plano o prototipo definido por el usuario a partir del cual se crean objetos. Representa el conjunto de propiedades o métodos que son comunes a todos los objetos de un tipo.
   
• Interfaz : como una clase, una interfaz puede tener métodos y variables, pero los métodos declarados en una interfaz son abstractos por defecto (solo la firma del método, sin cuerpo). Las interfaces especifican qué debe hacer una clase y no cómo. Es el modelo de la clase.

Métodos de la interfaz de colección

Esta interfaz contiene varios métodos que pueden ser utilizados directamente por todas las colecciones que implementan esta interfaz. Están:

Interfaces que amplían la interfaz de colecciones

El marco de la colección contiene múltiples interfaces donde cada interfaz se usa para almacenar un tipo específico de datos. Las siguientes son las interfaces presentes en el marco. 

1. Interfaz iterable: esta es la interfaz raíz para todo el marco de la colección. La interfaz de colección amplía la interfaz iterable. Por lo tanto, inherentemente, todas las interfaces y clases implementan esta interfaz. La funcionalidad principal de esta interfaz es proporcionar un iterador para las colecciones. Por lo tanto, esta interfaz contiene solo un método abstracto que es el iterador. devuelve el 
 

Iterador iterador(); 

2. Interfaz de colección: esta interfaz amplía la interfaz iterable y es implementada por todas las clases en el marco de la colección. Esta interfaz contiene todos los métodos básicos que tiene cada colección, como agregar datos a la colección, eliminar datos, borrar datos, etc. Todos estos métodos se implementan en esta interfaz porque estos métodos se implementan en todas las clases, independientemente de su estilo. de implementación. Y también, tener estos métodos en esta interfaz asegura que los nombres de los métodos sean universales para todas las colecciones. Por lo tanto, en resumen, podemos decir que esta interfaz construye una base sobre la cual se implementan las clases de colección.

3. Interfaz de 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 

Las clases que implementan la interfaz List son las siguientes:

A. ArrayList: ArrayList nos proporciona arreglos dinámicos en Java. Sin embargo, puede ser más lento que las arrays estándar, pero puede ser útil en programas donde se necesita mucha manipulación en la array. El tamaño de una ArrayList aumenta automáticamente si la colección crece o se reduce si los objetos se eliminan de la colección. Java ArrayList nos permite acceder aleatoriamente a la lista. ArrayList no se puede usar para tipos primitivos , como int, char, etc. Necesitaremos una clase contenedora para tales casos. Entendamos el ArrayList con el siguiente ejemplo:

// Java program to demonstrate the
// working of ArrayList
import java.io.*;
import java.util.*;
  
class GFG {
    
      // Main Method
    public static void main(String[] args)
    {
  
        // Declaring the ArrayList with
        // initial size n
        ArrayList<Integer> al = new ArrayList<Integer>();
  
        // Appending new elements at
        // the end of the list
        for (int i = 1; i <= 5; i++)
            al.add(i);
  
        // Printing elements
        System.out.println(al);
  
        // Remove element at index 3
        al.remove(3);
  
        // Displaying the ArrayList
        // after deletion
        System.out.println(al);
  
        // Printing elements one by one
        for (int i = 0; i < al.size(); i++)
            System.out.print(al.get(i) + " ");
    }
}

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5

B. LinkedList: la clase LinkedList es una implementación de la estructura de datos LinkedList, que es una estructura de datos lineal donde los elementos no se almacenan en ubicaciones contiguas y cada elemento es un objeto separado con una parte de datos y una parte de dirección. Los elementos se vinculan mediante punteros y direcciones. Cada elemento se conoce como un Node. Entendamos la LinkedList con el siguiente ejemplo:

// Java program to demonstrate the
// working of LinkedList
import java.io.*;
import java.util.*;
  
class GFG {
    
      // Main Method
    public static void main(String[] args)
    {
  
        // Declaring the LinkedList
        LinkedList<Integer> ll = new LinkedList<Integer>();
  
        // Appending new elements at
        // the end of the list
        for (int i = 1; i <= 5; i++)
            ll.add(i);
  
        // Printing elements
        System.out.println(ll);
  
        // Remove element at index 3
        ll.remove(3);
  
        // Displaying the List
        // after deletion
        System.out.println(ll);
  
        // Printing elements one by one
        for (int i = 0; i < ll.size(); i++)
            System.out.print(ll.get(i) + " ");
    }
}

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5

C. Vector: Un vector nos proporciona arrays dinámicas en Java. Sin embargo, puede ser más lento que las arrays estándar, pero puede ser útil en programas donde se necesita mucha manipulación en la array. Esto es idéntico a ArrayList en términos de implementación. Sin embargo, la principal diferencia entre un vector y un ArrayList es que un Vector está sincronizado y un ArrayList no está sincronizado. Entendamos el Vector con un ejemplo:

// Java program to demonstrate the
// working of Vector
import java.io.*;
import java.util.*;
  
class GFG {
    
      // Main Method
    public static void main(String[] args)
    {
  
        // Declaring the Vector
        Vector<Integer> v = new Vector<Integer>();
  
        // Appending new elements at
        // the end of the list
        for (int i = 1; i <= 5; i++)
            v.add(i);
  
        // Printing elements
        System.out.println(v);
  
        // Remove element at index 3
        v.remove(3);
  
        // Displaying the Vector
        // after deletion
        System.out.println(v);
  
        // Printing elements one by one
        for (int i = 0; i < v.size(); i++)
            System.out.print(v.get(i) + " ");
    }
}

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5

D. Stack : la clase Stack modela e implementa la estructura de datos Stack . La clase se basa en el principio básico de último en entrar, primero en salir . Además de las operaciones básicas de inserción y extracción, la clase proporciona tres funciones más de vaciar, buscar y mirar. La clase también puede denominarse subclase de Vector. Entendamos la pila con un ejemplo:

// Java program to demonstrate the
// working of a stack
import java.util.*;
public class GFG {
    
      // Main Method
    public static void main(String args[])
    {
        Stack<String> stack = new Stack<String>();
        stack.push("Geeks");
        stack.push("For");
        stack.push("Geeks");
        stack.push("Geeks");
  
        // Iterator for the stack
        Iterator<String> itr = stack.iterator();
  
        // Printing the stack
        while (itr.hasNext()) {
            System.out.print(itr.next() + " ");
        }
  
        System.out.println();
  
        stack.pop();
  
        // Iterator for the stack
        itr = stack.iterator();
  
        // Printing the stack
        while (itr.hasNext()) {
            System.out.print(itr.next() + " ");
        }
    }
}

Geeks For Geeks Geeks 
Geeks For Geeks

Nota: Stack es una subclase de Vector y una clase heredada. Es seguro para subprocesos, lo que podría ser una sobrecarga en un entorno donde no se necesita la seguridad de subprocesos. Una alternativa a Stack es usar ArrayDequeue, que no es seguro para subprocesos y tiene una implementación de array más rápida.

4. Interfaz de 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 , 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.  

La implementación más utilizada de la interfaz de cola es PriorityQueue. 
 
Priority Queue: PriorityQueue se utiliza cuando se supone que los objetos se procesarán en función de la prioridad. Se sabe que una cola sigue el algoritmo First-In-First-Out, pero a veces se necesita procesar los elementos de la cola de acuerdo con la prioridad y esta clase se utiliza en estos casos. PriorityQueue se basa en el montón de prioridad. Los elementos de la cola de prioridad se ordenan según el ordenamiento natural o mediante un comparador proporcionado en el momento de la construcción de la cola, según el constructor que se utilice. Entendamos la cola de prioridad con un ejemplo:

// Java program to demonstrate the working of
// priority queue in Java
import java.util.*;
  
class GfG {
    
      // Main Method
    public static void main(String args[])
    {
        // Creating empty priority queue
        PriorityQueue<Integer> pQueue = new PriorityQueue<Integer>();
  
        // Adding items to the pQueue using add()
        pQueue.add(10);
        pQueue.add(20);
        pQueue.add(15);
  
        // Printing the top element of PriorityQueue
        System.out.println(pQueue.peek());
  
        // Printing the top element and removing it
        // from the PriorityQueue container
        System.out.println(pQueue.poll());
  
        // Printing the top element again
        System.out.println(pQueue.peek());
    }
}

10
10
15

5. Interfaz 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 donde 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 la clase ArrayDeque implementa la interfaz Deque, podemos instanciar un objeto deque con esta clase. Por ejemplo, 
 

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

Donde T es el tipo del objeto.  

La clase que implementa la interfaz deque es ArrayDeque. 

ArrayDeque: la clase ArrayDeque que se implementa en el marco de la colección nos proporciona una forma de aplicar la array de tamaño variable. Este es un tipo especial de array que crece y permite a los usuarios agregar o eliminar un elemento de ambos lados de la cola. Los arreglos deques no tienen restricciones de capacidad y crecen según sea necesario para admitir el uso. Entendamos ArrayDeque con un ejemplo:
 

// Java program to demonstrate the
// ArrayDeque class in Java
  
import java.util.*;
public class ArrayDequeDemo {
    public static void main(String[] args)
    {
        // Initializing an deque
        ArrayDeque<Integer> de_que = new ArrayDeque<Integer>(10);
  
        // add() method to insert
        de_que.add(10);
        de_que.add(20);
        de_que.add(30);
        de_que.add(40);
        de_que.add(50);
  
        System.out.println(de_que);
  
        // clear() method
        de_que.clear();
  
        // addFirst() method to insert the
        // elements at the head
        de_que.addFirst(564);
        de_que.addFirst(291);
  
        // addLast() method to insert the
        // elements at the tail
        de_que.addLast(24);
        de_que.addLast(14);
  
        System.out.println(de_que);
    }
}

[10, 20, 30, 40, 50]
[291, 564, 24, 14]

6. Interfaz de 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.  

Las siguientes son las clases que implementan la interfaz Set:

A. HashSet: la clase HashSet es una implementación inherente de la estructura de datos de la tabla hash. Los objetos que insertamos en el HashSet no garantizan que se inserten en el mismo orden. Los objetos se insertan en función de su código hash. Esta clase también permite la inserción de elementos NULL. Entendamos HashSet con un ejemplo:

// Java program to demonstrate the
// working of a HashSet
import java.util.*;
  
public class HashSetDemo {
    
      // Main Method
    public static void main(String args[])
    {
        // Creating HashSet and
        // adding elements
        HashSet<String> hs = new HashSet<String>();
  
        hs.add("Geeks");
        hs.add("For");
        hs.add("Geeks");
        hs.add("Is");
        hs.add("Very helpful");
  
        // Traversing elements
        Iterator<String> itr = hs.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }
    }
}

Very helpful
Geeks
For
Is

B. LinkedHashSet : un LinkedHashSet es muy similar a un HashSet. La diferencia es que utiliza una lista doblemente enlazada para almacenar los datos y conserva el orden de los elementos. Entendamos el LinkedHashSet con un ejemplo: 

// Java program to demonstrate the
// working of a LinkedHashSet
import java.util.*;
  
public class LinkedHashSetDemo {
    
      // Main Method
    public static void main(String args[])
    {
        // Creating LinkedHashSet and
        // adding elements
        LinkedHashSet<String> lhs = new LinkedHashSet<String>();
  
        lhs.add("Geeks");
        lhs.add("For");
        lhs.add("Geeks");
        lhs.add("Is");
        lhs.add("Very helpful");
  
        // Traversing elements
        Iterator<String> itr = lhs.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }
    }
}

Geeks
For
Is
Very helpful

7. Interfaz de conjuntos ordenados : esta interfaz es muy similar a la interfaz de conjuntos. 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.  

La clase que implementa la interfaz de conjuntos ordenados es TreeSet. 
 
TreeSet: la clase TreeSet utiliza un árbol para el almacenamiento. El orden de los elementos se mantiene mediante un conjunto utilizando su orden natural, se proporcione o no un comparador explícito. Esto debe ser consistente con equals para implementar correctamente la interfaz Set. También se puede ordenar mediante un comparador proporcionado en el momento de la creación del conjunto, según el constructor que se utilice. Entendamos TreeSet con un ejemplo:

// Java program to demonstrate the
// working of a TreeSet
import java.util.*;
  
public class TreeSetDemo {
    
      // Main Method
    public static void main(String args[])
    {
        // Creating TreeSet and
        // adding elements
        TreeSet<String> ts = new TreeSet<String>();
  
        ts.add("Geeks");
        ts.add("For");
        ts.add("Geeks");
        ts.add("Is");
        ts.add("Very helpful");
  
        // Traversing elements
        Iterator<String> itr = ts.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }
    }
}

For
Geeks
Is
Very helpful

8. Interfaz de mapa : un mapa es una estructura de datos que admite el mapeo de pares clave-valor para los datos. Esta interfaz no admite claves duplicadas porque la misma clave no puede tener varias asignaciones. Un mapa es útil si hay datos y queremos realizar operaciones en base a la clave. Esta interfaz de mapa es implementada por varias clases como HashMap , TreeMap , etc. Dado que todas las subclases implementan el mapa, podemos instanciar un objeto de mapa con cualquiera de estas clases. Por ejemplo,
 

Mapa<T> hm = nuevo HashMap<>(); 
Mapa<T> tm = new TreeMap<>();
 
Donde T es el tipo del objeto. 

La implementación de una interfaz de mapa que se usa con frecuencia es un HashMap. 
 
HashMap : HashMap proporciona la implementación básica de la interfaz Map de Java. Almacena los datos en pares (Clave, Valor). Para acceder a un valor en un HashMap, debemos conocer su clave. HashMap utiliza una técnica llamada Hashing. Hashing es una técnica de convertir una string grande en una string pequeña que representa la misma string para que las operaciones de indexación y búsqueda sean más rápidas. HashSet también usa HashMap internamente. Entendamos el HashMap con un ejemplo:

// Java program to demonstrate the
// working of a HashMap
import java.util.*;
  
public class HashMapDemo {
    
      // Main Method
    public static void main(String args[])
    {
        // Creating HashMap and
        // adding elements
        HashMap<Integer, String> hm = new HashMap<Integer, String>();
  
        hm.put(1, "Geeks");
        hm.put(2, "For");
        hm.put(3, "Geeks");
  
        // Finding the value for a key
        System.out.println("Value for 1 is " + hm.get(1));
  
        // Traversing through the HashMap
        for (Map.Entry<Integer, String> e : hm.entrySet())
            System.out.println(e.getKey() + " " + e.getValue());
    }
}

Value for 1 is Geeks
1 Geeks
2 For
3 Geeks

¿Qué debe aprender en las colecciones de Java?