Cómo aprender colecciones de Java: una guía completa

En el mundo real, una colección por definición es un grupo de artículos que tienen propiedades y atributos similares. Dado que Java es un lenguaje orientado a objetos, imita el mundo real. En Java, una colección es un grupo de múltiples objetos reunidos en una sola unidad. Las colecciones de Java son un tema muy amplio y, como principiante, puede ser difícil navegar mientras se aprende. Aquí tenemos todo lo que necesita saber para comenzar con las colecciones de Java.

¿Qué es un marco de colección?

Tenemos nuestra colección de objetos, ahora necesitamos una forma organizada de usar estas colecciones, por lo tanto, necesitamos un marco. Java Collection Framework, introducido por primera vez en JDK 1.2 (Java Development Kit 1.2), es una arquitectura compuesta por interfaces y clases. En palabras simples, es como una estructura esquelética para componentes que está lista para usar para diversas necesidades de programación. También ofrece diferentes operaciones de datos como búsqueda, clasificación, inserción, eliminación y manipulación. Todas las clases e interfaces del marco de la colección están incluidas en el paquete java.util .

La jerarquía del marco de la colección

Interfaz Clase Vs

Ahora que tenemos los conceptos básicos de qué están hechas las colecciones de Java, entenderemos cada uno de sus componentes en detalle. ¿Cuáles son sus propiedades y algunos ejemplos de las colecciones más utilizadas?

1. Iterable

La interfaz Iterable es la raíz de toda la jerarquía de la colección, lo que significa que cada clase e interfaz la implementa. La función principal de un iterador es permitir que el usuario recorra todos los objetos de la clase de colección como si fueran simples secuencias de elementos de datos.

2. Colección

La interfaz Collection amplía la interfaz Iterable. Tiene los métodos básicos necesarios para usar todas las demás colecciones en el marco para agregar, eliminar y manipular datos. Dado que es una interfaz, solo tiene una firma de método (es decir, <tipo de retorno> methodName (ArgumentList);) y ninguna definición porque cada interfaz o clase que implementa esta interfaz tendrá diferentes tipos de elementos para manejar. Pero dado que implementan esta interfaz, existe uniformidad y estructura para el resto de la colección. Los métodos de la interfaz de colección se dan a continuación, todas las interfaces y clases que amplían o implementan la interfaz de colección utilizan estos métodos junto con sus propios métodos agregados específicos para ellos.

3. Lista

La interfaz de Lista se extiende desde la interfaz de Colección. Los elementos de una lista se ordenan como una secuencia. El usuario puede utilizar el número de índice para acceder a un elemento particular de la lista, es decir, el usuario tiene control total sobre qué elemento se inserta en la lista.

3. a) Lista de arrays

La clase ArrayList implementa la interfaz List. Los objetos de esta clase son arrays dinámicas. ArrayList es esencialmente una implementación redimensionable de List. Implementa todos los métodos List y permite todos los elementos, incluso los elementos nulos. Los objetos ArrayList tienen una capacidad, que inicialmente es igual al tamaño pero aumenta dinámicamente a medida que se agregan nuevos elementos. Una ArrayList no está sincronizada, lo que significa que varios subprocesos pueden acceder a ella al mismo tiempo. Un hilo es una unidad de control de flujo secuencial que se puede procesar en el Sistema Operativo.

Sintaxis:

ArrayList<?> arrayListName = new ArrayList<?>();

Ejemplo: Ahora tomaremos un ejemplo y realizaremos algunas operaciones básicas en un ArrayList. Aquí instanciamos una ArrayList llamada intArr. Usamos el método add() para agregar enteros a intArr. La clase Integer utilizada para declarar intArr es una clase contenedora para ese tipo de datos básico int. Las clases contenedoras se extienden desde la clase Object y se utilizan para que los tipos de datos básicos sean compatibles con otras clases. A continuación, imprimimos ArrayList en la consola. Usamos el método remove() para eliminar elementos de los índices especificados. Verificamos si un elemento, 25 aquí, existe en intArr e imprimimos el mensaje apropiado. Luego recuperamos el elemento en el índice 1 usando el método get(). Como puede observar cuando se elimina un elemento usando el método remove(), el resto de los elementos cambian en secuencia.

// An example for ArrayList
// All of the classes and
// interfaces of the collection
// framework are bundled into
// the java.util package
import java.util.*;
 
public class BasicArrayList {
 
    // main method
    public static void main(String[] args) {
         
        // Instantiate an ArrayList Object
        // Integer is a wrapper class for
        // the basic datatype int
        ArrayList<Integer> intArr = new ArrayList<Integer>();
         
        // Add elements using add() method
        intArr.add(10);
        intArr.add(12);
        intArr.add(25);
        intArr.add(19);
        intArr.add(11);
        intArr.add(3);
         
        // Print the ArrayList on the console
        System.out.println(intArr);
         
        // Remove elements at index 1 and 4
        intArr.remove(1);
        intArr.remove(4);
         
        // Print the ArrayList on the console
        System.out.println(intArr);
         
        // Check if intArr contains the element 25
        if(intArr.contains(25))
        {
            System.out.println("The ArrayList contains 25");
        }
        else
        {
            System.out.println("No such element exists");
        }
         
        // Use get method to get the element at index 1
        int elementAt1 = intArr.get(1);
        System.out.println("The Element at index 1 now is " + elementAt1);
         
    }
 
}

[10, 12, 25, 19, 11, 3]
[10, 25, 19, 11]
The ArrayList contains 25
The Element at index 1 now is 25

3. b) Vectores

La clase vector implementa el iterador List. Una instancia de Vector es una array dinámica, en la que se puede acceder a los elementos con índices. La diferencia entre Vector y ArrayList es que los vectores están sincronizados.

Sintaxis:

Vector<?> vectorName = new Vector<?>();

Entendamos mejor Vector con un ejemplo. En el código que se muestra a continuación, hemos declarado un Vector llamado intVector, usamos add() para agregar elementos al Vector. El método size() proporciona el número actual de elementos almacenados en el Vector. El método remove() se usa para eliminar un elemento en el índice especificado.

// An example for Vector
import java.util.*;
 
public class VectorExample {
 
    public static void main(String[] args) {
         
        // Instantiate Vector object
        Vector<Integer> intVector = new Vector<Integer>();
         
        // Print the initial size of the Vector
        System.out.println("The initial size of the Vector = " + intVector.size());
        System.out.println();
         
        // Add elements using add method
        intVector.add(11);
        intVector.add(18);
        intVector.add(1);
        intVector.add(87);
        intVector.add(19);
        intVector.add(11);
         
        // Print the Vector on the console
        System.out.println("The Vector intVector : ");
        System.out.println(intVector);
        System.out.println("Size of intVector : " + intVector.size());
         
        System.out.println();
         
        // Remove the element at index 2
        intVector.remove(2);
         
        // Print the vector again on the console
        System.out.println("The Vector intVector after removing element at 2 : ");
        System.out.println(intVector);
         
        System.out.println();
         
        // Clear all elements of the Vector and
        // Print the Vector on the console
        intVector.clear();
        System.out.println("The Vector intVector after using clear : ");
        System.out.println(intVector);
 
    }
 
}

The initial size of the Vector = 0

The Vector intVector : 
[11, 18, 1, 87, 19, 11]
Size of intVector : 6

The Vector intVector after removing element at 2 : 
[11, 18, 87, 19, 11]

The Vector intVector after using clear : 
[]

3. b) i) Pila

La clase de pila se extiende desde la clase Vector. La pila es una estructura LIFO (último en entrar, primero en salir). Puede visualizarlo como una pila de libros sobre una mesa: el libro que se guarda primero tiene que recuperarse en último lugar, y el libro que se guarda en la pila en último lugar tiene que recuperarse primero. Los métodos básicos de la clase de pila son empujar, abrir, mirar, vaciar y buscar.

Sintaxis:

Stack<?> stackName = new Stack<?>();

Ejemplo: Entendamos mejor Stack con un ejemplo. En el código que se proporciona a continuación, primero instanciamos una pila denominada strStack, cuyos elementos son de tipo String. Los elementos se agregan usando el método push(). El método size() devuelve el número de elementos presentes en la pila. El método search() se utiliza para buscar un elemento en la pila. Devuelve la posición basada en 1 del elemento si se encuentra; de lo contrario, se devuelve -1 para indicar que dicho elemento no existe en la pila.

// An example to show workings of a Stack
import java.util.*;
 
public class StackExample {
 
    public static void main(String[] args) {
         
        // Instantiate a Stack named strStack
        Stack<String> strStack = new Stack<String>();
         
        // Add elements using the push() method
        strStack.push("Stack");
        strStack.push("a");
        strStack.push("is");
        strStack.push("This");
         
        // The size() method gives the
        // number of elements in the Stack
        System.out.println("The size of the Stack is : " + strStack.size());
         
        // The search() method is
        // used to search an element
        // it returns the position of
        // the element
        int position = strStack.search("a");
        System.out.println("\nThe string 'a' is at position " + position);
         
        System.out.println("\nThe elements of the stack are : ");
        String temp;
        int num = strStack.size();
         
        for(int i = 1; i <= num; i++)
        {
            // peek() returns the topmost element
            temp = strStack.peek();
            System.out.print(temp + " ");
             
            // pop() removes the topmost element
            strStack.pop();
 
        }
         
    }
 
}

The size of the Stack is : 4

The string 'a' is at position 3

The elements of the stack are : 
This is a Stack 

3. c) Lista enlazada

La clase LinkedList implementa la interfaz List así como la interfaz Deque. LinkedList es la implementación de clase de la estructura de datos de lista enlazada, donde cada elemento tiene un puntero al siguiente elemento que forma un enlace. Dado que cada elemento tiene una dirección del siguiente elemento, los elementos de la lista enlazada, denominados Nodes, se pueden almacenar en ubicaciones no contiguas en la memoria.

Sintaxis:

LinkedList<?> linkedListName = new LinkedList<?>();

Tomemos un ejemplo para entender LinkedList. En el código que se proporciona a continuación, creamos una instancia de LinkedList denominada strLinkedList. El método add() se usa para agregar elementos y el método remove() para eliminar elementos. La recuperación de los elementos se realiza mediante el método get().

// An example for the LinkedList
import java.util.*;
 
public class LinkedListExample {
     
    public static void main(String[] args) {
         
        // Instantiate LinkedList named strLinkedList
        LinkedList<String> strLinkedList = new LinkedList<String>();
         
        // Add elements to the LinkedList using add()
        strLinkedList.add("This");
        strLinkedList.add("is");
        strLinkedList.add("a");
        strLinkedList.add("LinkedList");
         
        // The elements are retrieved using the get() method
        System.out.println("The contents of strLinkedList : ");
        for(int i = 0; i < strLinkedList.size(); i++)
        {
            System.out.print(strLinkedList.get(i) + " ");
        }
         
        // The elements are removed using remove()
        strLinkedList.remove(0);
        strLinkedList.remove(1);
         
        System.out.println("\n\nThe contents of strLinkedList after remove operation : ");
        for(int i = 0; i < strLinkedList.size(); i++)
        {
            System.out.print(strLinkedList.get(i) + " ");
        }
         
    }
 
}

The contents of strLinkedList : 
This is a LinkedList 

The contents of strLinkedList after remove operation : 
is LinkedList 

4. Cola

La interfaz Queue amplía la interfaz Collection. Queue es la implementación de la interfaz de la estructura de datos de la cola. Dado que Queue en Java es una interfaz, no tiene una definición de los métodos, solo sus firmas. La cola suele tener una estructura de primero en entrar, primero en salir ( FIFO ), aunque ese no es el caso de PriorityQueue. Puede visualizarlo como una cola de personas en un mostrador, la persona que entra primero recibe servicios primero y sale primero.

4. a) Cola de prioridad

La clase PriorityQueue implementa la interfaz Queue. Los elementos de PriorityQueue se ordenan en orden natural o en un orden especificado por un Comparator, que depende del constructor utilizado. PriorityQueue no tiene límites, pero hay una capacidad que dicta el tamaño de la array en la que se almacenan los elementos. La capacidad inicial es igual al tamaño de la array, pero a medida que se agregan nuevos elementos, se expande dinámicamente.

Sintaxis:

PriorityQueue<?> priorityQueueName = new PriorityQueue<?>();

Entendamos PriorityQueue mejor con un ejemplo. En el código que se proporciona a continuación, creamos una instancia de un objeto de PriorityQueue llamado intPriorityQueue, dado que no se especifica ningún Comparador en el constructor, los elementos de esta PriorityQueue se ordenarán de forma natural. El método add() se usa para agregar elementos y remove() se usa para eliminar una sola instancia del elemento especificado. El método peek() se implementa desde la interfaz Queue y devuelve el elemento al principio de PriorityQueue. Sin embargo, el método poll() elimina el elemento en la cabecera de PriorityQueue y lo devuelve.

// An example for PriorityQueue
import java.util.*;
 
public class PriorityQueueExample {
 
    public static void main(String[] args) {
     
        // Instantiate PriorityQueue object named intPriorityQueue
        PriorityQueue<Integer> intPriorityQueue = new PriorityQueue<Integer>();
         
        // Add elements using add()
        intPriorityQueue.add(17);
        intPriorityQueue.add(20);
        intPriorityQueue.add(1);
        intPriorityQueue.add(13);
        intPriorityQueue.add(87);
         
        // Print the contents of PriorityQueue
        System.out.println("The contents of intPriorityQueue : ");
        System.out.println(intPriorityQueue);
         
        // The peek() method is used to retrieve
          // the head of the PriorityQueue
        System.out.println("\nThe head of the PriorityQueue : " + intPriorityQueue.peek());
         
        // The remove() method is used
        // to remove a single instance
        // of the specified object
        intPriorityQueue.remove(17);
         
        // Print the contents of PriorityQueue
        System.out.println("\nThe contents of intPriorityQueue after removing 17 : ");
        System.out.println(intPriorityQueue);
         
        // The poll() method is used
        // to retrieve and remove the
        // element at the head of the PriorityQueue
        Integer head = intPriorityQueue.poll();
        System.out.println("\nThe head of the PriorityQueue was : " + head);
         
        // Print the contents of PriorityQueue
        System.out.println("\nThe contents of intPriorityQueue after poll : ");
        System.out.println(intPriorityQueue);
    }
 
}

The contents of intPriorityQueue : 
[1, 13, 17, 20, 87]

The head of the PriorityQueue : 1

The contents of intPriorityQueue after removing 17 : 
[1, 13, 87, 20]

The head of the PriorityQueue was : 1

The contents of intPriorityQueue after poll : 
[13, 20, 87]

5. Deque

La interfaz Deque amplía la interfaz Queue. El Deque es una implementación de la estructura de datos de cola de dos extremos, que es una estructura lineal donde la inserción y la eliminación se pueden realizar en ambos extremos de la cola. La interfaz de Deque admite deques que tienen restricciones de capacidad, así como que no tienen límite fijo. Deque se puede utilizar como una estructura de último en entrar, primero en salir (LIFO), así como una estructura de primero en entrar, primero en salir (FIFO).

5. a) ArrayDeque

La clase ArrayDeque implementa la interfaz Deque. ArrayDeque es una implementación redimensionable de Deque, no tiene una capacidad fija pero aumenta según sea necesario. El ArrayDeque se puede usar como una pila y es más rápido en comparación con la clase Stack. ArrayDeque no es seguro para subprocesos y no permite el acceso simultáneo de diferentes subprocesos.

Sintaxis:

ArrayDeque<?> arrayDequeName = new ArrayDeque<?>();

6. Establecer

La interfaz Set amplía la interfaz Collection. El Conjunto es una estructura que modela la definición matemática de un conjunto. Es una colección de objetos y no se permiten objetos duplicados. El Conjunto permite como máximo un elemento nulo. 

6. a) HashSet

La clase HashSet implementa la interfaz Set. En un HashSet, el orden de los elementos puede no ser el mismo que el orden de inserción. Cuando se agrega un elemento al HashSet, se calcula un HashCode y el elemento se agrega al depósito apropiado (un depósito es una ranura en cualquier estructura Hash). Un buen algoritmo HashSet distribuirá uniformemente los elementos para que el rendimiento temporal de la estructura permanezca constante. Un rendimiento de tiempo constante significa que se necesita un tiempo constante para operaciones básicas como insertar, eliminar y buscar.

6. b) Conjunto de hash vinculado

LinkedHashSet implementa la interfaz Set. El LinkedHashSet es muy similar al HashSet con la diferencia de que para cada cubo que la estructura usa para almacenar elementos es una lista doblemente enlazada. El pedido de LinkedHashSet es mejor en comparación con HashSet sin ningún costo adicional.

Tomemos un ejemplo para entender HashSet y LinkedHashSet. En el código que se proporciona a continuación, instanciamos un HashSet llamado strHashSet, usando el método add() para agregar elementos al HashSet. El método hasNext() y el método next() son métodos de la interfaz iterable que se utilizan para verificar si existe el siguiente elemento y recuperar el siguiente elemento respectivamente en cualquier colección. Usando el constructor de LinkedHashSet, todos los elementos de HashSet se le agregan. Se crea un iterador para atravesarlo y, usándolo, los elementos se imprimen en la consola.

// An example for HashSet and LinkedHashSet
import java.util.*;
 
public class HashSetAndLinkedHashSet {
 
    public static void main(String[] args) {
         
        /*-----------HashSet-------------*/
         
        // Instantiate a HashSet object named strHashSet
        HashSet<String> strHashSet = new HashSet<String>();
         
        // Add elements using add()
        strHashSet.add("This");
        strHashSet.add("is");
        strHashSet.add("a");
        strHashSet.add("HashSet");
         
        // Create an Iterator to traverse through the HashSet
        Iterator<String> hsIterator = strHashSet.iterator();
         
        // Print all the elements of the HashSet
        System.out.println("Contents of HashSet : ");
        while(hsIterator.hasNext())
        {
            System.out.print(hsIterator.next() + " ");
        }
 
        /*---------LinkedHashSet----------*/
         
        // Instantiate an object of LinkedHashSet named strLinkedHashSet
        // Pass the name of the HashSet created earlier to copy all of the contents
        // of the HashSet to the LinkedHashSet using a constructor
        LinkedHashSet<String> strLinkedHashSet = new LinkedHashSet<String>(strHashSet);
         
        // Create an Iterator to traverse through the LinkedHashSet
        Iterator<String> lhsIterator = strLinkedHashSet.iterator();
         
        // Print all the elements of the LinkedHashSet
        System.out.println("\n\nContents of LinkedHashSet : ");
        while(lhsIterator.hasNext())
        {
            System.out.print(lhsIterator.next() + " ");
        }
         
    }
 
}

Contents of HashSet : 
a This is HashSet 

Contents of LinkedHashSet : 
a This is HashSet 

7. Conjunto ordenado

La interfaz SortedSet amplía la interfaz Set. El SortedSet proporciona una ordenación completa de los elementos. El orden predeterminado es por orden natural, de lo contrario, se ordena por un comparador especificado en el momento de la construcción. El recorrido típicamente es en orden ascendente de elementos.

8. Conjunto navegable

La interfaz NavigableSet se extiende desde la interfaz SortedSet. Además de los métodos de SortedSet, NavigableSet tiene métodos de navegación que brindan coincidencias más cercanas, como piso, techo, inferior y superior. Un NavigableSet se puede recorrer en orden ascendente y descendente. Aunque permite implementaciones de elementos nulos, se desaconseja ya que estas implementaciones pueden dar resultados ambiguos.

8. a) Conjunto de árboles

La clase TreeSet implementa la interfaz Navigable. El TreeSet, como sugiere el nombre, utiliza una estructura de árbol para almacenar elementos y un conjunto para ordenar los elementos. El ordenamiento es un ordenamiento natural o un ordenamiento por el Comparador especificado en el momento de la construcción. El TreeSet no está sincronizado, es decir, si varios subprocesos quieren acceder a él al mismo tiempo, necesitamos sincronizarlo externamente.

Sintaxis:

TreeSet<?> treeSetName = new TreeSet<?>();

Tomemos un ejemplo para entender mejor TreeSet. En el código que se proporciona a continuación, creamos una instancia de un objeto llamado intTreeSet. Como puede observar, el orden en este TreeSet es un orden natural y no se permiten elementos duplicados. El método add() se usa para agregar los elementos y el método remove() se usa para eliminar elementos.

// An example for TreeSet
import java.util.*;
 
public class TreeSetExample {
 
    public static void main(String[] args) {
         
        // Instantiate an object of TreeSet named intTreeSet
        TreeSet<Integer> intTreeSet = new TreeSet<Integer>();
         
        // Add elements using add()
        intTreeSet.add(18);
        intTreeSet.add(13);
        intTreeSet.add(29);
        intTreeSet.add(56);
        intTreeSet.add(73);
         
        // Try to add a duplicate
        // Observe output as it will not be added
        intTreeSet.add(18);
         
        // Print the TreeSet on the console
        System.out.println("The contents of intTreeSet : ");
        System.out.println(intTreeSet);
         
        // Remove 18 using remove()
        if(intTreeSet.remove(18))
        {
            System.out.println("\nElement 18 has been removed");
        }
        else
        {
            System.out.println("\nNo such element exists");
        }
 
        // Try to remove a non-existent element
        if(intTreeSet.remove(12))
        {
            System.out.println("\nElement 18 has been removed");
        }
        else
        {
            System.out.println("\nNo such element exists");
        }
         
        System.out.println();
         
        // Print the TreeSet on the console
        System.out.println("The contents of intTreeSet : ");
        System.out.println(intTreeSet);
 
    }
 
}

The contents of intTreeSet : 
[13, 18, 29, 56, 73]

Element 18 has been removed

No such element exists

The contents of intTreeSet : 
[13, 29, 56, 73]

9. Mapa

La interfaz Map es una estructura que asigna una clave a cada valor. Un mapa no permite elementos duplicados ya que una clave no puede tener múltiples asignaciones. Un mapa tiene tres vistas diferentes, una vista de conjunto de las claves, una vista de conjunto de asignaciones de clave-valor y una vista de colección de los valores. Los métodos de la interfaz Map se dan a continuación, cada clase que implementa Map debe proporcionar definiciones para estos métodos.

9. a) Mapa hash

La clase HashMap implementa la interfaz Map. Para cada entrada en un HashMap, se calcula un hashCode y esta entrada se inserta en el depósito con el valor de hashCode como índice. Cada entrada es un par clave-valor. Un cubo en un HashMap puede contener más de una entrada. Un buen algoritmo HashMap intentará distribuir uniformemente los elementos en el HashMap. HashMap tiene un rendimiento de tiempo constante para operaciones básicas de recuperación, inserción, eliminación y manipulación. Los dos factores más importantes que afectan el rendimiento de un HashMap son la capacidad inicial y el factor de carga. El número de cangilones es la capacidad y la medida de cuándo aumentar esta capacidad es el factor de carga. HashMap es más rápido en comparación con HashTable.

Sintaxis:

HashMap<? , ?> hashMapName = new HashMap<? , ?>();

9. b) Tabla hash

La clase Hashtable implementa la interfaz Map. Hashtable tiene pares clave-valor como elementos. Para una implementación efectiva de la tabla hash, las claves deben ser únicas. Un Hashtable es muy similar a un Hashtable, pero Hashtable es síncrono. Un buen algoritmo Hashtable intentará distribuir uniformemente los elementos en Hashtable. Hashtable tiene un rendimiento de tiempo constante para operaciones básicas de recuperación, inserción, eliminación y manipulación. Los dos factores más importantes que afectan el rendimiento de una Hashtable son la capacidad inicial y el factor de carga. El número de cangilones es la capacidad y la medida de cuándo aumentar esta capacidad es el factor de carga.

Sintaxis:

HashTable<? , ?> hashTableName = new HashTable<? , ?>();

9. c) Mapa hash vinculado

La clase LinkedHashMap implementa la interfaz Map. Un LinkedHashMap es una implementación de lista enlazada de mapa hash de un mapa. Cada entrada en LinkedHashMap tiene una lista doblemente enlazada que la atraviesa. Esta lista vinculada define el orden de iteración que es el orden de las claves insertadas en LinkedHashMap. Como todas las implementaciones de Map, los elementos de LinkedHashMap son pares clave-valor.

Sintaxis:

LinkedHashMap<? , ?> linkedHashMapName = new LinkedHashMap<? , ?>();

Tomemos un ejemplo para comprender todas las implementaciones de mapas. En el código que se proporciona a continuación, agregamos elementos mediante el método put() a todos los HashMap, Hashtable y LinkedHashMap. Como put() es un método de la interfaz Map, por lo tanto, se implementa mediante estas tres clases. Como puede observar, el orden de inserción de Hashtable no es el mismo que el orden interno, por lo tanto, no es determinista. Cuando intentamos insertar una clave duplicada, el valor anterior se reemplaza en los tres. Y cuando intentamos insertar un valor duplicado con una clave diferente, se agrega como una nueva entrada. Básicamente, esto es para representar que podemos tener valores duplicados pero no claves duplicadas.

// An example for HashMap,
// Hashtable and LinkedHashMap
import java.util.*;
 
public class MapImplementaionExample {
 
    public static void main(String[] args) {
         
        /*--------------HashMap---------------*/
         
        // Instantiate an object of HashMap named hashMap
        HashMap<Integer, String> hashMap = new HashMap<Integer, String>();
         
        // Add elements using put()
        hashMap.put(1, "This");
        hashMap.put(2, "is");
        hashMap.put(3, "HashMap");
         
        // Print the HashMap contents on the console
        System.out.println("Contents of hashMap : ");
        System.out.print(hashMap.entrySet());
         
        // Add a duplicate key
        hashMap.put(3, "Duplicate");
         
        // Add a duplicate value
        hashMap.put(4, "This");
         
        // Print the HashMap contents on the console
        System.out.println("\nContents of hashMap after adding duplicate : ");
        System.out.print(hashMap.entrySet());
         
        /*--------------Hashtable----------------*/
         
        // Instantiate an object of Hashtable named hashTable
        Hashtable<Integer, String> hashTable = new Hashtable<Integer, String>();
         
        // Add elements using put()
        hashTable.put(11, "This");
        hashTable.put(12, "is");
        hashTable.put(13, "Hashtable");
         
        // Print the Hashtable contents on the console
        System.out.println("\n\nContents of hashTable : ");
        System.out.print(hashTable.entrySet());
 
        // Add a duplicate key
        hashTable.put(11, "Duplicate");
         
        // Add a duplicate value
        hashTable.put(14, "is");
         
        // Print the Hashtable contents on the console
        System.out.println("\nContents of hashTable after adding duplicate : ");
        System.out.print(hashTable.entrySet());
         
        /*---------------LinkedHashMap---------------*/
         
        // Instantiate an object of LinkedHashMap named linkedHashMape
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<Integer, String>();
         
        // Add elements using put()
        linkedHashMap.put(21, "This");
        linkedHashMap.put(22, "is");
        linkedHashMap.put(23, "LinkedHashMap");
         
        // Print the LinkedHashMap contents on the console
        System.out.println("\n\nContents of linkedHashMap : ");
        System.out.print(linkedHashMap.entrySet());
         
        // Add a duplicate key
        linkedHashMap.put(22, "Duplicate");
         
        // Add a duplicate value
        linkedHashMap.put(24, "This");
         
        // Print the LinkedHashMap contents on the console
        System.out.println("\nContents of linkedHashMap after adding duplicate : ");
        System.out.print(linkedHashMap.entrySet());
    }
 
}

Contents of hashMap : 
[1=This, 2=is, 3=HashMap]
Contents of hashMap after adding duplicate : 
[1=This, 2=is, 3=Duplicate, 4=This]

Contents of hashTable : 
[13=Hashtable, 12=is, 11=This]
Contents of hashTable after adding duplicate : 
[14=is, 13=Hashtable, 12=is, 11=Duplicate]

Contents of linkedHashMap : 
[21=This, 22=is, 23=LinkedHashMap]
Contents of linkedHashMap after adding duplicate : 
[21=This, 22=Duplicate, 23=LinkedHashMap, 24=This]

10. Mapa ordenado

La interfaz SortedMap amplía la interfaz Map con una estipulación adicional de un orden total de claves. Las claves se ordenan por ordenamiento natural o por un Comparador especificado en el momento de la construcción, según el constructor utilizado. Todas las claves deben ser comparables. 

10. a) Mapa de árbol

La clase TreeMap implementa la interfaz SortedMap. La clase TreeMap utiliza una estructura de árbol rojo-negro para el almacenamiento y un mapa para ordenar los elementos. Cada elemento es un par clave-valor. Esta implementación proporciona un costo de tiempo de registro (n) garantizado para las operaciones básicas.

Sintaxis:

TreeMap<? , ?> treeMapName = new TreeMap<? , ?>();

Tomemos un ejemplo para comprender los conceptos básicos de TreeMap. En el código que se proporciona a continuación, instanciamos un objeto del objeto TreeMap llamado treeMap. Agrega elementos usando el método put(). Cuando intentamos agregar una clave duplicada con un valor diferente, la instancia anterior se reemplaza con el nuevo valor asociado con esta clave. Pero cuando intentamos agregar un valor duplicado con una nueva clave, se toma como una entrada diferente.

// An example of TreeMap
import java.util.*;
 
public class TreeMapExample {
 
    public static void main(String[] args) {
         
        // Instantiate an object of TreeMap named treeMap
        TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();
         
        // Add elements using put()
        treeMap.put(1, "This");
        treeMap.put(2, "is");
        treeMap.put(3, "TreeMap");
         
        // Print the contents of treeMap on the console
        System.out.println("The contents of treeMap : ");
        System.out.println(treeMap);
         
        // Add a duplicate key
        treeMap.put(1, "Duplicate");
         
        // Add a duplicate value
        treeMap.put(4, "is");
         
        // Print the contents of treeMap on the console
        System.out.println("\nThe contents of treeMap after adding duplicates : ");
        System.out.println(treeMap);
         
    }
 
}

The contents of treeMap : 
{1=This, 2=is, 3=TreeMap}

The contents of treeMap after adding duplicates : 
{1=Duplicate, 2=is, 3=TreeMap, 4=is}

GeeksforGeeks también ha preparado un curso Fundamentos de Java y Colecciones de Java para enseñarle los conceptos de Java en profundidad. Este curso lo ayudará a usar las clases y funciones integradas de Collections Framework para implementar algunas de las estructuras de datos complejas de manera fácil y eficiente y realizar operaciones en ellas. Mira este curso: