La lista enlazada es parte del marco de la colección que está presente en el paquete java.util. Esta clase es una implementación de la estructura de datos LinkedList, que es una estructura de datos lineal en la que 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.
¿Qué es una API de lista enlazada?
- La API de lista enlazada tiene como objetivo implementar la colección de lista enlazada que, como parte del marco de colección heredado del paquete java.util .
- Esta API es una implementación de lista de doble enlace de las interfaces list y deque.
- Esta API implementa todas las operaciones de lista opcionales y permite todos los elementos (incluidos los nulos).
- Todas las operaciones funcionan como cabría esperar de una lista doblemente enlazada. Las operaciones que indexan la lista recorrerán la lista desde el principio o el final, lo que esté más cerca del índice especificado.
- A continuación se muestra el código fuente del programa Java para implementar la API de recopilación LinkedList.
Ejemplo:
Java
// Java Program to Implement LinkedList API
// Importing utility classes from java.util package
import java.util.*;
import java.util.Collection;
// Class
// Main class consisting of all methods
public class LinkedListImpl<E> {
// Member variable of this class
private LinkedList<E> linkedList;
// Constructors of this class
// 1. Default constructor
public LinkedListImpl()
{
linkedList = new LinkedList<E>();
}
// 2. Parameterized constructor
public LinkedListImpl(Collection<? extends E> c)
{
linkedList = new LinkedList<E>(c);
}
// Method 1
// To append specified element to end of this List
public boolean add(E e)
{
// Returning the last element from the List
return linkedList.add(e);
}
// Method 2
// To insert specified element at
// the specified position in this List
public void add(int index, E element)
{
linkedList.add(index, element);
}
// Method 3
// To add all the elements in this List
public boolean addAll(Collection<? extends E> c)
{
return linkedList.addAll(c);
}
// Method 4
// To add all the elements in this List
public boolean addAll(int index,
Collection<? extends E> c)
{
return linkedList.addAll(index, c);
}
// Method 5
// to inserts specified element at beginning of this
// List
public void addFirst(E e) { linkedList.addFirst(e); }
// Method 6
// To appends specified element to end of this List
public void addLast(E e) { linkedList.addLast(e); }
// Method 7
// Removes all of the elements from this list.
public void clear() { linkedList.clear(); }
// Method 8
// Returns a shallow copy of this ArrayList instance.
public Object clone() { return linkedList.clone(); }
// Method 9
// Returns true if this list contains the specified
// element.
public boolean contains(Object o)
{
return linkedList.contains(o);
}
// Method 10
// Returns an iterator over the elements in this
// deque(reverse order)
public Iterator<E> descendingIterator()
{
return linkedList.descendingIterator();
}
// Method 11
// Retrieves, but does not remove, the head (first
// element) of this list.
public E element() { return linkedList.element(); }
// Method 12
// Returns the element at the specified position in this
// list.
public E get(int index)
{
return linkedList.get(index);
}
// Method 13
// Returns the first element in this list.
public E getFirst() { return linkedList.getFirst(); }
// Method 14
// Returns the last element in this list.
public E getLast() { return linkedList.getLast(); }
// Method 15
// Returns the index of the first occurrence of the
// specified element
public int indexOf(Object o)
{
return linkedList.indexOf(o);
}
// Method 16
// Returns true if this list contains no elements.
public boolean isEmpty()
{
return linkedList.isEmpty();
}
// Method 17
// Returns an iterator over the elements
// in this list in proper sequence.
public Iterator<E> iterator()
{
return linkedList.iterator();
}
// Method 18
public int lastIndexOf(Object o)
{
return linkedList.lastIndexOf(o);
}
// Method 19
public ListIterator<E> listIterator()
{
return linkedList.listIterator();
}
// Method 20
public ListIterator<E> listIterator(int index)
{
return linkedList.listIterator(index);
}
// Method 21
// Adds the specified element as the tail (last element)
// of this list.
public boolean offer(E e)
{
return linkedList.offer(e);
}
// Method 22
// Inserts the specified element at the front of this
// list.
public boolean offerFirst(E e)
{
return linkedList.offerFirst(e);
}
// Method 23
// Inserts the specified element at the end of this
// list.
public boolean offerLast(E e)
{
return linkedList.offerLast(e);
}
// Method 24
// Retrieves, but does not remove, the head (first
// element) of this list.
public E peek() { return linkedList.peek(); }
// Method 25
public E peekFirst() { return linkedList.peekFirst(); }
// Method 26
// Retrieves, but does not remove, the last element of
// this list
public E peekLast() { return linkedList.peekLast(); }
// Method 27
// Retrieves and removes the head (first element) of
// this list.
public E poll() { return linkedList.poll(); }
// Method 28
// Retrieves and removes the first element of this list,
// or returns null
public E pollFirst() { return linkedList.pollFirst(); }
// Method 29
// Retrieves and removes the last element of this list,
// or returns null
public E pollLast() { return linkedList.peekLast(); }
// Method 30
// Pops an element from the stack represented by this
// list.
public E pop() { return linkedList.pop(); }
// Method 31
// Pushes an element onto the stack represented by this
// list.
public void push(E e) { linkedList.push(e); }
// Method 32
// Removes the element at the specified position in this
// list.
public E remove(int index)
{
return linkedList.remove(index);
}
// Method 33
// Removes the first occurrence of the specified element
// from this list(if present)
public boolean remove(Object o)
{
return linkedList.remove(o);
}
// Method 34
public boolean removeAll(Collection<?> c)
{
return linkedList.removeAll(c);
}
// Method 35
// Removes and returns the first element from this list.
public E removeFirst()
{
return linkedList.removeFirst();
}
// Method 36
// To remove th first occurrences in this List
public boolean removeFirstOccurrence(Object o)
{
return linkedList.removeFirstOccurrence(o);
}
// Method 37
// Removes and returns the last element from this list.
public E removeLast()
{
return linkedList.removeLast();
}
// Method 38
// Removes the last occurrence of the specified element
// in this list
public boolean removeLastOccurrence(Object o)
{
return linkedList.removeLastOccurrence(o);
}
// Method 39
// Retains only the elements in this list
// contained in specific position
public boolean retainAll(Collection<?> c)
{
return linkedList.removeAll(c);
}
// Method 40
// Replaces the element at the specified position
public E set(int index, E element)
{
return linkedList.set(index, element);
}
// Method 41
// Returns the number of elements in this list.
public int size() { return linkedList.size(); }
// Method 42
// Returns a view of the portion of this list
public List<E> subList(int fromIndex, int toIndex)
{
return linkedList.subList(fromIndex, toIndex);
}
// Method 43
// Returns an array containing all of the elements
// in this list(proper sequence)
public Object[] toArray()
{
return linkedList.toArray();
}
// Method 44
// Returns an array containing all of the elements in
// this list
public <T> T[] toArray(T[] a)
{
return linkedList.toArray(a);
}
// Method 45
// Main driver method
public static void main(String... arg)
{
// Creating an object of above class
// User-defined
LinkedListImpl<Integer> linkedList
= new LinkedListImpl<>();
// Adding custom elements to above object
// Custom input elements addition
// using add() and addAll() methods
linkedList.add(100);
linkedList.add(20);
linkedList.addFirst(101);
linkedList.addLast(200);
// Creating a Set class object of integer type
Set<Integer> set = new HashSet<Integer>();
// Custom input elements addition
// using add() and addAll() methods
set.add(101);
set.add(30);
set.add(32);
linkedList.addAll(4, set);
if (linkedList.contains(300))
System.out.println(
"the linked list contains 300");
else
System.out.println(
"the linked list does not contain 300");
System.out.println(
"the elements in descending order is");
Iterator<Integer> descendingitr
= linkedList.descendingIterator();
while (descendingitr.hasNext()) {
System.out.print(descendingitr.next() + "\t");
}
System.out.println();
System.out.println("the head of this list is "
+ linkedList.element());
System.out.println("the element at index 2 is "
+ linkedList.get(2));
System.out.println("the element first pos is "
+ linkedList.getFirst());
System.out.println("the element at last pos is"
+ linkedList.getLast());
System.out.println("the index of element 200 is "
+ linkedList.indexOf(200));
System.out.println(
"the last index of element 101 is "
+ linkedList.lastIndexOf(101));
System.out.println("the elements of list are");
Iterator<Integer> itr = linkedList.iterator();
while (itr.hasNext()) {
System.out.print(itr.next() + "\t");
}
System.out.println();
linkedList.offer(45);
linkedList.offerFirst(32);
linkedList.offerLast(19);
System.out.println("the head of the linkedlist is "
+ linkedList.peek());
System.out.println(
"the first element of linkedList is "
+ linkedList.peekFirst());
System.out.println(
"the last element of linked List is "
+ linkedList.peekLast());
System.out.println("the elements of list are");
itr = linkedList.iterator();
while (itr.hasNext()) {
System.out.print(itr.next() + "\t");
}
System.out.println();
System.out.println(
"the first element of linkedList is (poll) "
+ linkedList.poll());
System.out.println("the first element polled is "
+ linkedList.pollFirst());
System.out.println("the last element polled is "
+ linkedList.pollLast());
linkedList.push(36);
System.out.println(
"the element popped from linked List is "
+ linkedList.pop());
System.out.println(
"index 3 element removed from list "
+ linkedList.remove(3));
System.out.println(
"last occurrence of 101 removed "
+ linkedList.removeLastOccurrence(101));
linkedList.clear();
if (linkedList.isEmpty())
System.out.println("the linkedList is empty");
else
System.out.println(
"the linked list is not empty");
}
}
Producción :
Explicación del programa:
- Creamos un método de colección LinkedListImpl<E> para invocar el objeto de lista enlazada.
- Creamos un método booleano add() para agregar el elemento especificado al final de esta lista.
- Creamos un método void add() para Insertar el elemento especificado en la posición especificada en esta lista.
- Creamos un método booleano addAll() para agregar todos los elementos de la colección especificada al final de esta lista, en el orden en que son devueltos por el iterador de la colección especificada.
- Creamos un método void addFirst() para insertar el elemento especificado al principio de esta lista.
- Creamos un método void addLast() para agregar el elemento especificado al final de esta lista.
- Creamos el método clear() para eliminar todos los elementos de esta lista.
- Creamos un método clone() que devuelve una copia superficial de esta instancia de ArrayList.
- Creamos un método contains() que devuelve Devuelve verdadero si esta lista contiene el elemento especificado
- Creamos un iterador descendente() que devuelve un iterador sobre los elementos en este deque en orden secuencial inverso.
- Creamos el método element() que recupera, pero no elimina, el encabezado (primer elemento) de esta lista.
- Creamos el método getFirst() que devuelve el primer elemento de esta lista.
- Creamos el método getLast() que devuelve el último elemento de esta lista.
- Creamos el método indexOf() con objeto como parámetro que devuelve el índice de la primera aparición del elemento especificado en la lista o -1 si esta lista no contiene el elemento.
- Creamos isEmpty() para devolver verdadero si esta lista no contiene elementos.
- Creamos el método iterator() para arrayList que devuelve un iterador sobre los elementos de esta lista en la secuencia adecuada.
- Creamos lastIndexOf() para Devuelve el índice de la última aparición del elemento especificado en este o -1.
- Creamos el método listIterator() para ArrayList listIterator<E> para Devuelve un iterador de lista sobre los elementos de esta lista.
- Escribimos listIterator(int index) para Devuelve un iterador de lista sobre los elementos de esta lista.
- Escribimos el método de oferta() para agregar el elemento especificado como la cola (último elemento) de esta lista.
- Escribimos ofrecerPrimero(E e) para Insertar el elemento especificado al principio de esta lista.
Publicación traducida automáticamente
Artículo escrito por ravi.geek24 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA