Il metodo che mi blocca il programma è questo:
codice:
public void salvaListaClienti(ListNode l) {
while(l.length()!=1) {
salvaCliente((ClienteSocieta)l.head());
salvaListaClienti((ListNode)l.tail());
}
}
ListNode è una lista di clienti (implementata con riferimenti). Quello che vorrei fare è scorrere tutta la lista e salvare su file ogni oggetto Cliente man mano che li scorro!
Qualcuno può aiutarmi a correggere il metodo?
GRAZIE MILLE!
Codice:
codice:
public class ListNode implements List {
private Node node;
/** Costruttore della lista vuota */
public ListNode() {
node = null;
}
/** Costruttore che inizializza il primo elemento della lista con l'oggetto
* passato come parametro. */
public ListNode(Object o) {
node = new Node(o);
}
/** Costruttore che inserisce tutti gli elementi della lista l mantenendo
* l'ordine, poi inserisce l'elemento o. */
public ListNode(Object o, List l) {
if(l != null) revInsert(l);
insert(o);
}
/** Metodo privato che viene invocato da altri metodi. Legge gli elementi della
* lista l e li inserisce in modo da mantenere l'ordine. */
private void revInsert(List l) {
if (!l.isEmpty()) {
revInsert(l.tail());
insert(l.head());
}
}
/** Metodo che mi dice se la lista è vuota. */
public boolean isEmpty() {
return (node == null);
}
/** Metodo che restituisce il primo elemento della lista. */
public Object head() {
if (isEmpty()) return null;
else return node.info;
}
/** Metodo che restituisce l'ultimo elemento della lista. */
public Object last() {
if (isEmpty()) return null;
Node tmp = node;
// Scorre tutti gli elementi della lista.
while (tmp.next != null) tmp = tmp.next;
return tmp.info;
}
/** Metodo che restituisce la lista senza il primo elemento (coda). */
public List tail() {
if (isEmpty()) return null;
else {
// Costruisce una lista nuova.
ListNode tmp = new ListNode();
// Impone che il primo nodo sia il vecchio secondo nodo.
tmp.node = node.next;
return tmp;
}
}
/** Metodo che inserisce un elemento in testa alla lista. */
public void insert(Object o) {
// Costruisce un nuovo nodo con o all'inizio e il vecchio nodo come successivo.
node = new Node(o, node);
}
/** Metodo che cancella un elemento dalla lista. */
public void remove(Object o) {
if (!isEmpty()) {
Node pred = node;
Node tmp = node.next;
if (node.info.equals(o)) node = node.next;
else
while(tmp != null)
if (tmp.info.equals(o)) {
pred.next = tmp.next;
return;
}
else {
pred = pred.next;
tmp = tmp.next;
}
}
}
/** Metodo che calcola la lunghezza della lista. Versione dipendente dall'implementazione. */
public int lengthD() {
Node tmp = node;
int cont = 0;
while(tmp != null) {
tmp = tmp.next;
cont++;
}
return cont;
}
/** Metodo che calcola la lunghezza della lista. Versione indipendente dalla
* implementazione. */
public int length() {
if (isEmpty()) return 0;
else return (tail().length()+1);
}
/** Metodo che dice se un elemento è nella lista. */
public boolean contains(Object o) {
Node tmp = node;
while (tmp != null) {
if (tmp.info.equals(o)) return true;
tmp = tmp.next;
}
return false;
}
/** Metodo che permette di ottenere una stringa corrispondente alla lista. */
public String toString() {
String tmp = "";
for(Node i=node; i!=null; i=i.next) tmp = tmp + " " + i.info.toString();
return tmp;
}
}
Classe Node:
codice:
class Node {
/** Classe accessoria non visibile all'esterno. */
Object info;
Node next; /** Struttura ricorsiva; next è un riferimento ad un oggetto della classe stessa. */
public Node(Object o) {
this(o, null);
}
public Node(Object o, Node n) {
info = o;
next = n;
}
}
Rispondi quotando
