[JAVA] Lista di nodi con posizioni

[kkk94]

Salve a tutti.

Sono in difficoltà e vi prego di darmi una mano. Praticamente ho creato una lista doppiamente concatenata. Però non ho capito come è possibile accedere ad un nodo della lista. Come succede in ArrayList la stessa cosa la devo fare con la lista di nodi: cioè poter accedere ad un nodo qualsiasi della lista.
Ho preso il codice del programma che implementa la lista di nodi con le posizioni.

In pratica non ho capito cosa rappresenta Position<E>
Non vi dico di andarvi a vedere tutto il codice ma dirmi solo quello che fa Position<E>, che è un'interfaccia.


public class NodePositionList<E>
{

protected int size;
protected DNode<E> header, trailer;

public NodePositionList()
{
header = new DNode<E>(null, null, null);
trailer = new DNode<E>(header, null, null);
header.setNext(trailer);
size = 0;
}

public int size()
{
return size;
}

public boolean isEmpty()
{
return (size == 0);
}

public Position<E> first()
{
if(isEmpty())
throw new EmptyListException("La lista è vuota");
return header.getNext();
}

public Position<E> last()
{
if(isEmpty())
throw new EmptyListException("La lista è vuota");
return trailer.getPrev();
}

protected DNode<E> checkPosition(Position<E> p)
{
if(p == null) throw new InvalidPositionException("Nulla passato come posizione");
if(p == header) throw new InvalidPositionException("header non è una posizione valida nella lista");
if(p == trailer) throw new InvalidPositionException("trailer non è una posizione valida nella lista");

try
{
DNode<E> temp = (DNode<E>) p;
if((temp.getPrev() == null) || (temp.getNext() == null))
throw new InvalidPositionException("La posizione non fa parte della lista");
return temp;
}
catch(ClassCastException e)
{
throw new InvalidPositionException("Il tipo della posizione non è valido in questa lista");
}
}

public Position<E> prev(Position<E> p)
{
DNode<E> v = checkPosition(p);
DNode<E> prev = v.getPrev();

if(prev == header)
throw new BoundaryViolationException("Non posso retrocedere oltre l'inizio della lista");
return prev;
}

public Position<E> next(Position<E> p)
{
DNode<E> v = checkPosition(p);
DNode<E> next = v.getNext();

if(next == trailer)
throw new BoundaryViolationException("Non posso avanzare oltre la fine della lista");

return next;
}

public void addAfter(Position<E> p, E e)
{
DNode<E> v = checkPosition(p);
size++;
DNode<E> newNodo = new DNode<E>(v, v.getNext(), e);
v.getNext().setPrev(newNodo);
v.setNext(newNodo);
}

public void addBefore(Position<E> p, E e)
{
DNode<E> v = checkPosition(p);
size++;
DNode<E> newNodo = new DNode<E>(v.getPrev(), v, e);
v.getPrev().setNext(newNodo);
v.setPrev(newNodo);
}

public void addFirst(E e)
{
size++;
DNode<E> newNodo = new DNode<E>(header, header.getNext(), e);
header.getNext().setPrev(newNodo);
header.setNext(newNodo);
}

public void addLast(E e)
{
size++;
DNode<E> newNodo = new DNode<E>(trailer.getPrev(), trailer, e);
trailer.getPrev().setNext(newNodo);
trailer.setPrev(newNodo);
}

public E remove(Position<E> p)
{
DNode<E> v = checkPosition(p);
size--;
DNode<E> vPrev = v.getPrev();
DNode<E> vNext = v.getNext();
vPrev.setNext(vNext);
vNext.setPrev(vPrev);
E element = v.element();
v.setNext(null);
v.setPrev(null);
return element;
}


}

[sottovento]

Ciao
purtroppo non hai pubblicato la definizione dell'interfaccia Position<>, della quale chiedi il significato. Capirai che e' ben difficile spiegare qualcosa senza averla vista.
Tuttavia qualche supposizione si puo' fare, soprattutto grazie alla

protected DNode<E> checkPosition(Position<E> p)

(e supponendo che il codice sia quanto meno compilabile).

In questo metodo vengono fatte comparazioni del tipo

if(p == header) throw new InvalidPositionException("header non è una posizione valida nella lista");
if(p == trailer) throw new InvalidPositionException("trailer non è una posizione valida nella lista");


Siccome p e' di tipo Position<E> ed header e trailer sono di tipo DNode<E>, per poter essere compilabile e' necessario che DNode sia una implementazione di Position<E> (o una sottoclasse).

Quindi, i metodi in questione ritornano Position<E> invece di DNode<E> per essere piu' generici (almeno in linea di principio): chi usa questi metodi non deve preoccuparsi di come DNode<E> sia implementato e questo permette al programmatore della classe NodePositionList di poter cambiare l'implementazione piu' facilmente.

Infatti, tutti i metodi pubblici ritornano Position<E>; DNode e' solo un'implementazione che potrebbe essere cambiata a posteriori (per esempio, per motivi di efficienza) ed essere addirittura nascosta all'interno di package (o all'interno della classe stessa), l'importante e' che chi usa questo codice sappia come utilizzare Position<E>