La clase ConcurrentLinkedDeque en Java es parte de Java Collection Framework e implementa la interfaz Collection y la clase AbstractCollection . Pertenece al paquete java.util.concurrent . Se utiliza para implementar Deque con la ayuda de LinkedList al mismo tiempo.
Características de ConcurrentLinkedDeque
- Los iteradores y spliteradores son débilmente consistentes.
- Las operaciones simultáneas de inserción, eliminación y acceso se ejecutan de forma segura en varios subprocesos.
- No permite elementos nulos.
- El método size() no está implementado en tiempo constante. Debido a la naturaleza asíncrona de estos deques, determinar el número actual de elementos requiere un recorrido de los elementos.
Jerarquía de clases:
Declaración:
public abstract class ConcurrentLinkedDeque<E>
extends AbstractCollection<E>
implements Deque<E>, Serializable
Here, E is the type of elements maintained by this collection.
Implementa interfaces Serializable, Iterable<E>, Collection<E>, Deque<E> , Queue<E> .
Constructores de ConcurrentLinkedDeque:
1. ConcurrentLinkedDeque() : este constructor se utiliza para construir una deque vacía.
ConcurrentLinkedDeque<E> cld = new ConcurrentLinkedDeque<E>();
2. ConcurrentLinkedDeque(Collection<E> c) : este constructor se utiliza para construir una deque con los elementos de la colección pasados como parámetro.
ConcurrentLinkedDeque<E> cld = new ConcurrentLinkedDeque<E>(Colección<E> c);
A continuación se muestra el programa de ejemplo para ilustrar ConcurrentLinkedDeque en Java:
Java
// Java Program to demonstrate ConcurrentLinkedDeque
import java.util.concurrent.*;
class ConcurrentLinkedDequeDemo {
public static void main(String[] args)
{
// Create a ConcurrentLinkedDeque
// using ConcurrentLinkedDeque()
// constructor
ConcurrentLinkedDeque<Integer>
cld = new ConcurrentLinkedDeque<Integer>();
// add element to the front
// using addFirst() method
cld.addFirst(12);
cld.addFirst(70);
cld.addFirst(1009);
cld.addFirst(475);
// Displaying the existing ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ cld);
// Create a ConcurrentLinkedDeque
// using ConcurrentLinkedDeque(Collection c)
// constructor
ConcurrentLinkedDeque<Integer>
cld1 = new ConcurrentLinkedDeque<Integer>(cld);
// Displaying the existing ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque1: "
+ cld1);
}
}
Producción:
ConcurrentLinkedDeque: [475, 1009, 70, 12] ConcurrentLinkedDeque1: [475, 1009, 70, 12]
Ejemplo:
Java
// Java code to illustrate
// methods of ConcurrentLinkedDeque
import java.util.concurrent.*;
class ConcurrentLinkedDequeDemo {
public static void main(String[] args)
{
// Create a ConcurrentLinkedDeque
// using ConcurrentLinkedDeque() constructor
ConcurrentLinkedDeque<Integer>
cld = new ConcurrentLinkedDeque<Integer>();
// add element to the front
// using addFirst() method
cld.addFirst(12);
cld.addFirst(70);
cld.addFirst(1009);
cld.addFirst(475);
// Displaying the existing ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ cld);
// Displaying the Last element
// using getLast() method
System.out.println("The Last element is: "
+ cld.getLast());
// Displaying the first element
// using peekFirst() method
System.out.println("First Element is: "
+ cld.peekFirst());
// Remove the Last element
// using removeLast() method
cld.removeLast();
// Displaying the existing ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ cld);
}
}
Producción:
ConcurrentLinkedDeque: [475, 1009, 70, 12] The Last element is: 12 First Element is: 475 ConcurrentLinkedDeque: [475, 1009, 70]
Operaciones básicas de ConcurrentLinkedDeque
1. Agregar elementos
Para agregar un elemento o una colección de elementos, ConcurrentLinkedDeque proporciona métodos como los métodos add(E e), addAll(Collection<? extends E> c), addFirst(E e), addLast(E e). El siguiente ejemplo explica estos métodos.
Java
// Java Program Demonstrate adding
// elements to the ConcurrentLinkedDeque
import java.util.concurrent.*;
class AddingElements {
public static void main(String[] args)
{
// create instance using ConcurrentLinkedDeque
ConcurrentLinkedDeque<Integer> cld1
= new ConcurrentLinkedDeque<Integer>();
// Add element to the tail using
// add or addLast methods
cld1.add(12);
cld1.add(110);
// Add element to the head
// using addFirst method
cld1.addFirst(55);
// Displaying the existing ConcurrentLinkedDeque
System.out.println("Initial Elements in "
+ "the LinkedDeque cld : "
+ cld1);
// create instance using ConcurrentLinkedDeque
ConcurrentLinkedDeque<Integer> cld2
= new ConcurrentLinkedDeque<Integer>();
// Add elements of cld1 to the
// cld2 using addAll method
cld2.addAll(cld1);
// Displaying the modified ConcurrentLinkedDeque
System.out.println("Initial Elements in "
+ "the LinkedDeque cld2: "
+ cld2);
}
}
Producción:
Initial Elements in the LinkedDeque cld : [55, 12, 110] Initial Elements in the LinkedDeque cld2: [55, 12, 110]
2. Eliminar elementos
Para eliminar un elemento, ConcurrentLinkedDeque proporciona métodos como remove(), remove(Object o), removeFirst(), removeLast(), etc. Estos métodos se explican en el siguiente ejemplo.
Java
// Java Program to demonstrate removing
// elements of ConcurrentLinkedDeque
import java.util.concurrent.*;
class RemovingElements {
public static void main(String[] args)
{
// Create a ConcurrentLinkedDeque
// using ConcurrentLinkedDeque() constructor
ConcurrentLinkedDeque<Integer> cld
= new ConcurrentLinkedDeque<Integer>();
// Add elements using add() method
cld.add(40);
cld.add(50);
cld.add(60);
cld.add(70);
cld.add(80);
// Displaying the existing LinkedDeque
System.out.println(
"Existing ConcurrentLinkedDeque: " + cld);
// remove method removes the first
// element of ConcurrentLinkedDeque
// using remove() method
System.out.println("Element removed: "
+ cld.remove());
// Remove 60 using remove(Object)
System.out.println("60 removed: " + cld.remove(60));
// Displaying the existing ConcurrentLinkedDeque
System.out.println(
"Modified ConcurrentLinkedDeque: " + cld);
// Remove the first element
cld.removeFirst();
// Remove the Last element
cld.removeLast();
// Displaying the existing ConcurrentLinkedDeque
System.out.println(
"Modified ConcurrentLinkedDeque: " + cld);
}
}
Producción
Existing ConcurrentLinkedDeque: [40, 50, 60, 70, 80] Element removed: 40 60 removed: true Modified ConcurrentLinkedDeque: [50, 70, 80] Modified ConcurrentLinkedDeque: [70]
3. Elementos iterativos
Podemos iterar el ConcurrentLinkedDeque usando los métodos iterator() o descendingIterator(). El siguiente código explica ambos métodos.
Java
// Java code to illustrate iterating
// elements of ConcurrentLinkedDeque
import java.util.concurrent.*;
import java.util.*;
public class IteratingConcurrentLinkedDeque {
public static void main(String args[])
{
// Creating an empty ConcurrentLinkedDeque
ConcurrentLinkedDeque<String> deque
= new ConcurrentLinkedDeque<String>();
// Use add() method to add elements
// into the ConcurrentLinkedDeque
deque.add("Welcome");
deque.add("To");
deque.add("Geeks");
deque.add("4");
deque.add("Geeks");
// Displaying the ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque: "
+ deque);
// Creating an iterator
Iterator fitr = deque.iterator();
// Displaying the values
// after iterating through the ConcurrentLinkedDeque
System.out.println("The iterator values are: ");
while (fitr.hasNext()) {
System.out.println(fitr.next());
}
// Creating a desc_iterator
Iterator ditr = deque.descendingIterator();
// Displaying the values after iterating
// through the ConcurrentLinkedDeque
// in reverse order
System.out.println("The iterator values are: ");
while (ditr.hasNext()) {
System.out.println(ditr.next());
}
}
}
Producción
ConcurrentLinkedDeque: [Welcome, To, Geeks, 4, Geeks] The iterator values are: Welcome To Geeks 4 Geeks The iterator values are: Geeks 4 Geeks To Welcome
4. Elementos de acceso
Para acceder a los elementos de ConcurrentLinkedDeque, proporciona métodos como getFirst(), getLast(), element(). El siguiente ejemplo explica estos métodos.
Java
// Java Program to Demonstrate accessing
// elements of ConcurrentLinkedDeque
import java.util.concurrent.*;
import java.util.*;
class Accessing {
public static void main(String[] args)
{
// Creating an empty ConcurrentLinkedDeque
ConcurrentLinkedDeque<String> cld
= new ConcurrentLinkedDeque<String>();
// Add elements into the ConcurrentLinkedDeque
cld.add("Welcome");
cld.add("To");
cld.add("Geeks");
cld.add("4");
cld.add("Geeks");
// Displaying the ConcurrentLinkedDeque
System.out.println("Elements in the ConcurrentLinkedDeque: " + cld);
// Displaying the first element
System.out.println("The first element is: "
+ cld.getFirst());
// Displaying the Last element
System.out.println("The Last element is: "
+ cld.getLast());
// Displaying the head of ConcurrentLinkedDeque
System.out.println("The Head of ConcurrentLinkedDeque is: "
+ cld.element());
}
}
Producción:
Elements in the ConcurrentLinkedDeque: [Welcome, To, Geeks, 4, Geeks] The first element is: Welcome The Last element is: Geeks The Head of ConcurrentLinkedDeque is: Welcome
Métodos de ConcurrentLinkedDeque
Aquí, E es el tipo de elemento.
|
MÉTODO |
DESCRIPCIÓN |
|---|---|
| agregar(E e) | Inserta el elemento especificado al final de este deque. |
| addAll(Colección<? extiende E> c) | Agrega todos los elementos de la colección especificada al final de esta deque, en el orden en que los devuelve el iterador de la colección especificada. |
| añadirPrimero(E e) | Inserta el elemento especificado al principio de este deque. |
| añadirÚltimo(E e) | Inserta el elemento especificado al final de esta deque. |
| clear() | Elimina todos los elementos de este deque. |
| contiene(Objeto o) | Devuelve verdadero si esta deque contiene el elemento especificado. |
| iterador descendente() | Devuelve un iterador sobre los elementos de este deque en orden secuencial inverso. |
| elemento() | Recupera, pero no elimina, la cabeza de la cola representada por este deque (en otras palabras, el primer elemento de este deque). |
| forEach(Consumidor<? super E> acción) | Realiza la acción dada para cada elemento del iterable hasta que se hayan procesado todos los elementos o la acción genere una excepción. |
| obtenerPrimero() | Recupera, pero no elimina, el primer elemento de este deque. |
| obtener ultimo() | Recupera, pero no elimina, el último elemento de este deque. |
| esta vacio() | Devuelve verdadero si esta colección no contiene elementos. |
| iterador() | Devuelve un iterador sobre los elementos de este deque en la secuencia adecuada. |
| oferta(E e) | Inserta el elemento especificado al final de este deque. |
| ofertaPrimero(E e) | Inserta el elemento especificado al principio de este deque. |
| ofertaÚltimo(E e) | Inserta el elemento especificado al final de esta deque. |
| estallido() | Extrae un elemento de la pila representada por este deque. |
| empujar (E mi) | Empuja un elemento a la pila representada por este deque (en otras palabras, al principio de este deque) si es posible hacerlo inmediatamente sin violar las restricciones de capacidad, lanzando una IllegalStateException si no hay espacio disponible actualmente. |
| retirar() | Recupera y elimina la cabeza de la cola representada por este deque (en otras palabras, el primer elemento de este deque). |
| eliminar(Objeto o) | Elimina la primera aparición del elemento especificado de esta deque. |
| removeAll(Colección<?> c) | Elimina todos los elementos de esta colección que también están contenidos en la colección especificada (operación opcional). |
| removeFirst() | Recupera y elimina el primer elemento de este deque. |
| eliminarPrimeraOcurrencia(Objeto o) | Elimina la primera aparición del elemento especificado de esta deque. |
| removeIf(predicado<? filtro super E>) | Elimina todos los elementos de esta colección que satisfacen el predicado dado. |
| eliminarÚltimo() | Recupera y elimina el último elemento de este deque. |
| eliminarÚltimaOcurrencia(Objeto o) | Elimina la última aparición del elemento especificado de este deque. |
| retenerTodo(Colección<?> c) | Retiene solo los elementos de esta colección que están contenidos en la colección especificada (operación opcional). |
| Talla() | Devuelve el número de elementos en este deque. |
| divisor() | Devuelve un Spliterator sobre los elementos de esta deque. |
| aArray() | Devuelve una array que contiene todos los elementos de este deque, en la secuencia adecuada (desde el primero hasta el último elemento). |
| a la Array(T[] a) | Devuelve una array que contiene todos los elementos de este deque, en la secuencia adecuada (desde el primero hasta el último elemento); el tipo de tiempo de ejecución de la array devuelta es el de la array especificada. |
Métodos declarados en la clase java.util.AbstractCollection
|
MÉTODO |
DESCRIPCIÓN |
|---|---|
| contieneTodo(Colección<?> c) | Devuelve verdadero si esta colección contiene todos los elementos de la colección especificada. |
| Enstringr() | Devuelve una representación de string de esta colección. |
Métodos declarados en la interfaz java.util.Collection
|
MÉTODO |
DESCRIPCIÓN |
|---|---|
| contieneTodo(Colección<?> c) | Devuelve verdadero si esta colección contiene todos los elementos de la colección especificada. |
| es igual a(Objeto o) | Compara el objeto especificado con esta colección para la igualdad. |
| código hash() | Devuelve el valor del código hash para esta colección. |
| flujoParalelo() | Devuelve un Stream posiblemente paralelo con esta colección como fuente. |
| corriente() | Devuelve un Stream secuencial con esta colección como fuente. |
| toArray(IntFunction<T[]> generador) | Devuelve una array que contiene todos los elementos de esta colección, utilizando la función de generador proporcionada para asignar la array devuelta. |
Métodos declarados en la interfaz java.util.Deque
|
MÉTODO |
DESCRIPCIÓN |
|---|---|
| ojeada() | Recupera, pero no elimina, la cabeza de la cola representada por este deque (en otras palabras, el primer elemento de este deque), o devuelve un valor nulo si este deque está vacío. |
| mirarPrimero() | Recupera, pero no elimina, el primer elemento de este deque, o devuelve un valor nulo si este deque está vacío. |
| mirarÚltimo() | Recupera, pero no elimina, el último elemento de este deque, o devuelve un valor nulo si este deque está vacío. |
| encuesta() | Recupera y elimina la cabeza de la cola representada por este deque (en otras palabras, el primer elemento de este deque), o devuelve un valor nulo si este deque está vacío. |
| sondearprimero() | Recupera y elimina el primer elemento de este deque, o devuelve un valor nulo si este deque está vacío. |
| última encuesta() | Recupera y elimina el último elemento de este deque, o devuelve un valor nulo si este deque está vacío. |
Referencia : https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentLinkedDeque.html
Publicación traducida automáticamente
Artículo escrito por RishabhPrabhu y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA