La clase ConcurrentLinkedDeque en Java es una deque concurrente ilimitada que almacena sus elementos como Nodes vinculados donde cada Node contiene la dirección del Node anterior y del siguiente. Pertenece al paquete java.util.concurrent . Esta clase es miembro de Java Collections Framework. También extiende las clases Object y AbstractCollection.
Características de la API ConcurrentLinkedDeque
- No permite elementos nulos.
- Los iteradores son débilmente consistentes.
- Las operaciones simultáneas de inserción, eliminación y acceso se ejecutan de forma segura en varios subprocesos, por lo que es seguro para subprocesos.
- El método de tamaño NO es una operación de tiempo constante
Implementando interfaces
1. Serializable 2. Iterable<E> 3. Collection<E> 4. Deque<E> 5. Queue<E>
Parámetros: E — El tipo de elementos en la colección
Sintaxis:
public class ConcurrentLinkedDeque<E> extends AbstractCollection<E> implements Deque<E>, Serializable
Constructores :
- public ConcurrentLinkedDeque(): Crea un deque vacío.
- public ConcurrentLinkedDeque(Collection<E> c): Crea un deque que inicialmente contiene los elementos de la Collection<E>.
Métodos:
| Método | Escribe | Descripción |
|---|---|---|
| añadir (E mi) | booleano | Inserta un elemento en la cola del deque |
| addAll(Colección<E> c) | booleano | Inserta todos los elementos presentes en la Colección especificada |
| añadirPrimero(E e) | vacío | Agrega un elemento en el frente del deque |
| añadirÚltimo(E e) | vacío | Agrega un elemento en el último de la deque |
| clear() | vacío | Elimina todos los elementos del deque. |
| contiene(Objeto o) | booleano | Devuelve verdadero si el deque contiene el Objeto O |
| iterador descendente() | Iterador<E> | Devuelve un iterador sobre los elementos de la deque en orden inverso. |
| elemento() | mi | Recupera la cabeza del deque sin quitarla |
| obtenerPrimero() | mi | Recupera el primer elemento del deque. |
| obtener ultimo() | mi | Recupera el último elemento del deque. |
| esta vacio() | booleano | Devuelve verdadero si el deque no contiene elementos. |
| iterador() | Iterador<E> | Devuelve un iterador sobre los elementos en el deque |
| ojeada() | mi | Recupera la cabeza del deque sin quitarla |
| encuesta() | mi | Recupera y quita la cabeza del deque |
| empujar (E mi) | vacío | Empuja un elemento a la pila representada por el deque |
| estallido() | mi | Extrae un elemento de la pila representada por el deque. |
| retirar() | mi | Recupera y elimina la cabeza de la cola |
| Talla() | En t | Devuelve el tamaño del deque |
| aArray() | Objeto[] | Devuelve una array que contiene todos los elementos de la deque |
Implementación:
Ejemplo
Java
// Java Program to Implement ConcurrentLinkedDeque API
// Importing all classes from
// java.util package
import java.util.*;
import java.util.concurrent.*;
// Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Object 1
// Create a ConcurrentLinkedDeque object
// Declaring object of Integer type
ConcurrentLinkedDeque<Integer> dq
= new ConcurrentLinkedDeque<Integer>();
// Adding element to the front
// using addFirst() method
// Custom entry
dq.add(89);
// Adding an element in the last
// using addLast() method
// Custom entry
dq.addLast(18);
// Adding an element to the front
// Custom inputs
dq.addFirst(10);
dq.add(45);
// Displaying the current ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque1 : "
+ dq);
// Object 2
// Creating a ConcurrentLinkedDeque object
// using ConcurrentLinkedDeque(Collection c)
// Declaring object of Integer type
ConcurrentLinkedDeque<Integer> ldq
= new ConcurrentLinkedDeque<Integer>(dq);
// Displaying the current ConcurrentLinkedDeque
System.out.println("ConcurrentLinkedDeque2 : "
+ ldq);
// Print the size of the deque
// using size() method
System.out.println("Size: " + ldq.size());
// Removing all the elements from the deque
// using clear() method
ldq.clear();
// Checking whether the ConcurrentLinkedDeque object
// is empty or not
System.out.println("Is Deque empty: "
+ ldq.isEmpty());
// Removing the head of deque of object1
dq.remove();
// Iterating over elements and
// printing deque of object1
Iterator it = dq.iterator();
// Condition check using hasNext() which hold
// true till single element remaining in List
while (it.hasNext())
// Print all the elements
System.out.print(it.next() + " ");
}
}
Producción
ConcurrentLinkedDeque1: [10, 89, 18, 45] ConcurrentLinkedDeque2: [10, 89, 18, 45] Size: 4 Is Deque empty: true 89 18 45
Publicación traducida automáticamente
Artículo escrito por namitachaudhary60 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA