Lista Doblemente Enlazada
 
Mis aficiones
Lista Doblemente Enlazada
Album de fotos
Curriculum vitae
Mis enlaces favoritos
Lista Doblemente Enlazada

 
Codigo lista
ListIterator.java
class ListIterator (
Propietario LinkedList;
Pos ListItem;

ListIterator (propietario LinkedList, pos ListItem) (
= this.owner propietario;
this.pos = pos;
)

/ *
* Compruebe si el objeto posee el iterador
* /
public boolean belongsTo (propietario del objeto) (
this.owner retorno == propietario;
)

/ *
* Pasar a la posición de la cabeza
* /
cabeza public void () (
= pos owner.head;
)

/ *
* Pasar a la siguiente posición
* /
public void next () (
pos = pos.next;
)

/ *
* Pasar a la posición anterior
* /
public void Anterior () (
pos = pos.previous;
)
)
LinkedList.java
import java.util .*;

public class LinkedList (
ListItem cabeza;
/ *
* Crea una lista vacía
* /
public LinkedList () (
cabeza = new ListItem (null);
= head.next head.previous = cabeza;
)

/ *
* Elimine todos los elementos en la lista
* /
public void sincronizar final claro () (
= head.next head.previous = cabeza;
)

/ *
* Devuelve true si el contenedor está vacío.
* /
público isEmpty final boolean () (
head.next retorno == cabeza;
)

/ *
* Elemento insertar después de la posición actual de
* /
public void InsertAfter sincronizado (Object obj, el cursor ListIterator) (
NewItem ListItem = new ListItem (cursor.pos, obj, cursor.pos.next);
newItem.next.previous = newItem;
= cursor.pos.next newItem;
)

/ *
* Elemento insertar antes de la posición actual
* /
public void insertBefore sincronizado (Object obj, cursor ListIterator) (
NewItem ListItem = new ListItem (cursor.pos.previous, obj, cursor.pos);
= newItem.previous.next newItem;
cursor.pos.previous = newItem;
)

/ *
* Eliminar el elemento en la posición actual
* /
public void sincronizar final eliminar (cursor ListIterator) (
si (IsEmpty ()) (
lanzar IndexOutOfBoundsException nuevo ( "lista vacía.");
)
if (cursor.pos == cabeza) (
lanza NoSuchElementException nuevo ( "No se puede quitar de la cabeza");
)
cursor.pos.previous.next = cursor.pos.next;
cursor.pos.next.previous = cursor.pos.previous;
)

/ *
* Regresa un iterador posicionado a la cabeza.
* /
público cabeza ListIterator final () (
volver ListIterator (esto, la cabeza);
)

/ *
* Busque la primera aparición del objeto en una lista
* /
público ListIterator sincronizado final encontramos (Object obj) (
si (IsEmpty ()) (
lanzar IndexOutOfBoundsException nuevo ( "lista vacía.");
)
Pos ListItem = cabeza;
while (pos.next! = cabeza) (/ / Hay todavía elementos para ser inspeccionados
pos = pos.next;
if (pos.obj == obj) (
volver ListIterator (esto, pos);
)
)
lanza NoSuchElementException nuevo ( "No se ha encontrado el objeto");
)

/ *
* Devuelve una enumeración de los elementos. Utilice los métodos de enumeración de
* El objeto devuelto a buscar a los elementos de forma secuencial.
* /
public final elementos de la enumeración sincronizado () (
volver ListEnumerator nuevo (this);
)
)
La palabra clave synchronized en muchos de los métodos anteriores indica que los métodos que tienen este modificador de cambiar el estado interno de un objeto LinkedList que no es "thread-safe": por ejemplo, las inserciones y eliminaciones de elementos de la lista no debe llevarse a cabo al azar el orden, pero en el orden en que se solicitan. La palabra clave synchronized se encarga de esto: cuando se llama a un método de instancia synchronized Java bloquea la primera instancia para que ningún otro subproceso puede modificar el objeto al mismo tiempo. Vea la sección sobre la interacción entre los hilos para obtener más información sobre la sincronización.
Proporcionar la lista de enumeración
Java proporciona la interfaz de Enumeration de paso a través de los elementos de una instancia de una clase integrada en un contenedor, como Vector Usted puede buscar el código fuente de la interfaz de Enumeration en el kit de desarrollo, se ve como sigue:
public interface Enumeration (

hasMoreElements boolean ();

NextElement Object ();
)
Así pues, estos son los dos métodos que puede utilizar para recorrer el conjunto de valores. Dos ejemplos de su uso.
• Impresión de los nombres de las clases de todos los applets en una página Web:
• Enumeration e = getAppletContext (). GetApplets (); / / obtener todos los applets
• while (e.hasMoreElements ()) (/ / paso a través de todos los applets de
• Applet Object = e.nextElement ();
• System.out.println (applet.getClass (). GetName ());
• )
• Trabajar con vectores:
• Vector vector = new Vector (); / / Declaración de vectores
• vector.addElement (nuevo ...); / / con addElement puede agregar elementos
• Enumeración e = vector.elements (); / / obtener todos los elementos del vector
• while (e.hasMoreElements ()) (/ / paso a través de todos los elementos del vector
• Object obj = e.nextElement ();
• / / Trabajo con el objeto .....
• )
Por supuesto, queremos ofrecer este servicio de enumeración para doblemente listas enlazadas también. El método de elements de la clase LinkedList ya ofrece una Enumeration en realidad una instancia de la clase ListEnumerator
El esqueleto de esta clase es el siguiente:
import java.util .*;

class ListEnumerator implements Enumeration (
LinkedList lista;
Cursor ListIterator;

ListEnumerator (LinkedList l) (
)

público hasMoreElements boolean () (
)

nextElement public Object () (
)
)
El enumerador contiene
• una variable de instancia LinkedList que apunta a la lista doblemente vinculada queremos enumerar;
• una variable de instancia ListItem que sirve como un cursor a la lista doblemente enlazada en consideración.
Usted puede preguntarse por qué otro cursor para moverte por la estructura de datos, pero cuando se recorre una lista encadenada, tal vez un cursor en uso se encuentra en una posición importante antes de recorrido y debe permanecer allí después de recorrido.
El constructor ListEnumerator(LinkedList l) genera la enumeración de una lista dada doblemente enlazada: se coloca el cursor en la cabecera de la lista y moverla una posición aún más. En el código de Java:
ListEnumerator (LinkedList l) (
l = lista;
= cursor list.head ();
cursor.next ();
)
Lo que queda por hacer es la aplicación de los dos métodos prometido:
• hasMoreElements simplemente comprobar si el cursor en la actualidad los puntos en la cabecera de la lista.
• público hasMoreElements boolean () (
• cursor.pos regreso! = list.head;
• )
• nextElement devolver los datos del elemento de lista en la actualidad y señaló a mover el cursor un paso más allá. Todo esto debe suceder a menos que el cursor ya está apuntando a la cabecera de lista, en la que se lanza caso una excepción. (Vea la sección sobre las excepciones para obtener más información acerca de este tema)
• nextElement public Object () (
• synchronized (lista) (
• if (cursor.pos! = list.head) (
• Objeto = objeto cursor.pos.obj;
• cursor.next ();
• objeto de retorno;
• )
• )
• lanza NoSuchElementException nuevo ( "ListEnumerator");
• )
Aquí puedes ver otro uso de la palabra clave synchronized
synchronized ( expression ) statement
donde expression es un objeto o una matriz que está bloqueado durante la ejecución de la statement Esto asegura que ningún otro subproceso puede ejecutar la sección de programas al mismo tiempo.
Recoger el código Java que define la clase ListEnumerator tenemos:
ListEnumerator.java
import java.util .*;

class ListEnumerator implements Enumeration (
LinkedList lista;
Cursor ListIterator;

ListEnumerator (LinkedList l) (
l = lista;
= cursor list.head ();
cursor.next ();
)

público hasMoreElements boolean () (
cursor.pos regreso! = list.head;
)

nextElement public Object () (
synchronized (lista) (
if (cursor.pos! = list.head) (
Objeto = objeto cursor.pos.obj;
cursor.next ();
objeto de retorno;
)
)
lanza NoSuchElementException nuevo ( "ListEnumerator");
)
)

 
Este es otro párrafo que puedes editar del mismo modo.
Escríbeme
Me interesa tu opinión