Lista concatenata a puntatori espliciti

[Markus85]

Ciao a tutti.

devo sviluppare una classe che utilizzi una lista concatenata a puntatori espliciti.

Vi espongo il mio problema :

Ho una classe "ContenitoreDatiAstratto" che implementa un'interfaccia "ContenitoreDati" ; questa interfaccia estende Iterable

package poo.data;

public interface ContenitoreDati<E> extends Iterable<E> {
	
	void aggiungi(E elem);
	boolean aggiungi(ContenitoreDati<E> cd, Criterio<E> c);
	boolean aggiungi(ContenitoreDati<E> cd, Criterio<E> c, Funzione<E> f);
	boolean rimuovi(E elem);
	boolean rimuovi(Criterio<E> c);
	ContenitoreDati<E> estrai(Criterio<E> c);
	ContenitoreDati<E> estraiETrasforma(Criterio<E> c, Funzione<E> f);
	void applica(Funzione<E> f);
	void applica(Funzione<E> f, Criterio<E> c);
	int size();
	

}

public abstract class ContenitoreDatiAstratto<E> implements ContenitoreDati<E>{
....
.....
}

Mi si chiede di scrivere una classe concreta di nome "ContenitoreDatiLC" erede di "ContenitoreDatiAstratto" che utilizza una lista concatenata a puntatori espliciti.

Allora ; io ho fatto in questo modo :

public class ContenitoreDatiLC<E> extends ContenitoreDatiAstratto<E> {

	class ListaConcatenata<E> implements Iterable<E>{
		
		private class Nodo<T>{
			
			T info;
			Nodo<T> next;
			
			Nodo(T info){
				this.info=info;
			}
		}
		
		private int size;
		private Nodo<E> testa;
		private Nodo<E> coda;
		
.....
.......
........

}

non potrei scrivere pure cosi ?

public class ListaConcatenata<E> extends ContenitoreDatiAstratto<E>

Cioè ; dato che ListaConcatenata deve implementare Iterable , potrebbe essere corretto scrivere come sopra , dato che ContenitoreDatiAstratto implementa un'interfaccia che estende Iterable?

Spero di essere stato chiaro.

Aiutatemi

Ciao

[andbin]

Originariamente inviato da Markus85
Mi si chiede di scrivere una classe concreta di nome "ContenitoreDatiLC" erede di "ContenitoreDatiAstratto"

public class ContenitoreDatiLC<E> extends ContenitoreDatiAstratto<E> {

	class ListaConcatenata<E> implements Iterable<E>{
		
		private class Nodo<T>{

La prima riga è ok. Che poi dentro tu voglia avere una classe Nodo privata è ancora ok. Che tu debba mettere dentro una ListaConcatenata, questo invece è dubbio ... perché?

Tra l'altro Nodo è una inner-class. Vorrebbe dire che ogni oggetto Nodo ha il riferimento alla classe contenitore. Ma in questo caso non serve. Nodo sarebbe più utile se fosse una "nested" (static) class. E preferibilmente con una type variable differente (T invece di E ma solo per questione "visiva" e di leggibilità).

Originariamente inviato da Markus85
che utilizza una lista concatenata a puntatori espliciti.

Cosa intendi per "puntatori espliciti"? Magari sono ignorante io in questo caso.

[Markus85]

Sinceramente per lista concatenata a puntatori espliciti , non so cosa si intenda di preciso.
Cmq ti posto il codice di quest'ultima cosi ti rendi conto meglio :

package poo.lista;

import java.util.*;


public class ListaConcatenata<E> implements Iterable<E> {

	private static class Nodo<T> {
		T info;

		Nodo<T> next;

		Nodo(T info) {
			this.info = info;
		}

	}

	private int size;
	private Nodo<E> testa;
	private Nodo<E> coda;

	public void inserisci(E c) {
		Nodo<E> n = new Nodo<E>(c);

		if (testa == null)
			testa = n;// inserisci in testa
		else
			coda.next = n;
		coda = n;
		size++;
	}

	public boolean rimuovi(E c) {
		Nodo<E> pre = null;
		Nodo<E> cor = testa;
		while (cor != null) {
			if (cor.info.equals(c)) {
				if (pre == null)
					testa = cor.next;
				else
					pre.next = cor.next;
				if (cor == coda)
					coda = pre;
				cor.next = null;
				size--;
				return true;
			}

			pre = cor;
			cor = cor.next;
		}

		return false;
	}

	public boolean contiene(E c) {
		Nodo<E> cor = testa;
		while (cor != null) {
			if (cor.info.equals(c))
				return true;
			cor = cor.next;
		}
		return false;
	}

	public int size() {
		return size;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder(size * 10);
		sb.append("[");
		Nodo<E> cor = testa;
		while (cor != null) {
			sb.append(cor.info);
			sb.append(" ");
			cor = cor.next;
		}
		sb.append("]");
		return sb.toString();
	}

	@Override
	public Iterator<E> iterator() {

		return new IteratoreLista();
	}

	class IteratoreLista implements Iterator<E> {

		private Nodo<E> cor = null;

		private Nodo<E> pre = null;

		@Override
		public boolean hasNext() {
			if (cor == null)
				return testa != null;
			return cor.next != null;
		}

		@Override
		public E next() {

			if (!hasNext())
				throw new NoSuchElementException();
			pre = cor;
			if (cor == null)
				cor = testa;
			else
				cor = cor.next;
			return cor.info;
		}

		@Override
		public void remove() {
			if (pre == cor)
				throw new IllegalStateException();
			if (cor == testa) {
				testa = testa.next;
			} else {
				pre.next = cor.next;
			}
			if (cor == coda)
				coda = pre;
			cor = pre;
			--size;
		}

	}

}

Tornando al mio problema , ho scritto cosi :

public class ContenitoreDatiLC<E> extends ContenitoreDatiAstratto<E> {

	class ListaConcatenata<E> implements Iterable<E>{
		
		private static class Nodo<T>{

Però Eclipse mi da errore dicendomi che non posso dichiarare la classe static
(The member type Nodo cannot be declared static; static types can only be declared in static or top level types)

[andbin]

Originariamente inviato da Markus85

public class ContenitoreDatiLC<E> extends ContenitoreDatiAstratto<E> {

	class ListaConcatenata<E> implements Iterable<E>{
		
		private static class Nodo<T>{

Se hai già una classe ListaConcatenata<E> altrove .... allora a cosa ti serve dichiararne un'altra dentro ContenitoreDatiLC<E>??
Semplicemente usa un ListaConcatenata dentro ContenitoreDatiLC tenendo un campo di istanza per la lista.

public class ContenitoreDatiLC<E> extends ContenitoreDatiAstratto<E> {
    private ListaConcatenata<E> lista;

    // .... usa la lista per implementare il tuo ContenitoreDatiLC
}

P.S. comunque, giusto per la cronaca, in quello che hai scritto tu ListaConcatenata è una inner-class (in ContenitoreDatiLC) e le inner-class non possono dichiarare membri "static" (ad eccezione di costanti a tempo di compilazione!).

[Markus85]

Ok

quindi mi scrivo la lista concatenata a parte e poi la utilizzo in ContenitoreDatiLC

public class ContenitoreDatiLC<E> extends ContenitoreDatiAstratto<E> {
    private ListaConcatenata<E> lista;

lista.inserisci(elemento);
lista.rimuovi(elemento);

....

Giusto?

[Markus85]

Cmq non è che la avevo altrove.

Quella che ti ho postato era quella che dovevo scrivere.

Cmq vedi se è giusto quello che ho detto sopra.

[andbin]

Originariamente inviato da Markus85
quindi mi scrivo la lista concatenata a parte e poi la utilizzo in ContenitoreDatiLC

public class ContenitoreDatiLC<E> extends ContenitoreDatiAstratto<E> {
    private ListaConcatenata<E> lista;

lista.inserisci(elemento);
lista.rimuovi(elemento);

....

Giusto?

Beh sì nel senso dell'uso, no per come l'hai mostrato qui. Chiaramente dovrai mettere un costruttore (es. per istanziare l'oggetto ListaConcatenata, se non vuoi farlo nella dichiarazione oppure per altro). Avrai dei metodi in ContenitoreDatiLC (per implementare ciò che è richiesto da ContenitoreDatiAstratto) al cui interno ovviamente userai la lista.

Originariamente inviato da Markus85
Cmq non è che la avevo altrove.

Quella che ti ho postato era quella che dovevo scrivere.

Ma se l'hai scritta ed è una classe sensata e riutilizzabile, allora appunto tienila separata. Ti serve per ContenitoreDatiLC ma potrebbe servirti per altro e comunque .... da sola è sensata!

[Markus85]

Dovrebbe essere cosi allora :

public class ContenitoreDatiLC<E> extends ContenitoreDatiAstratto<E>{

private ListaConcatenata<E> lista;

public ContenitoreDatiLC(ListaConcatenata<E> l){
lista = l;
}

//Utilizzo in un metodo :

@Override
public void aggiungi(E elemento){
 lista.aggiungi(elemento);
}

[andbin]

Originariamente inviato da Markus85
Dovrebbe essere cosi allora :

Se vuoi ricevere il ListaConcatenata dall'esterno ok. Ma potresti anche istanziarlo lì dentro. O offrire entrambe le possibilità. La scelta (di "design") è tua.

Per il aggiungi ok, fa quel che deve fare. Per il resto dei metodi ovviamente devi vederlo tu.