(java) rimozione nodo

[aduri]

Mentre mi e' chiara la prima parte che controlla che l'oggetto x non sia null , la coda non sia vuota e se ce un solo oggetto;
la seconda parte dopo il ciclo for non mi e' altrettanto chiara.
Qualcuno puo' spiegarmi sommariamente i passaggi?

Grazie


public boolean remove(Object x) {
if (x==null) throw new IllegalArgumentException();
if (isEmpty()) return false;
if (x.equals(first.element)){
if (first==last)
last=null;
first=first.next;
mod++;
return true;
}
for(Node i=first; i.next!=null; i = i.next){
if(x.equals(i.next.element)){
if(i.next==last)
last=i;
i.next=i.next.next;
mod++;
return true;
}
}
return false;}

[leox@mitoalfaromeo]

hai riportato un pezzo di codice con alcune lacune a occhio e croce...
in particolare non si spiega come mai ci sia questo mod++ che poi non viene utilizzato...

[PGI-Bis]

Il premio per aver scritto quella routine sono 5 anni nelle patrie galere ma dovrei controllare per esserne certo.

Credo che la seguente sia un'interpretazione corretta anche se per esserne certi occorrerebbe interrogare un etruscologo.

public boolean remove(Object x) {
if (x==null) throw new IllegalArgumentException();
if (isEmpty()) return false;
if (x.equals(first.element)){
if (first==last)
last=null;
first=first.next;
mod++;
return true;
}
/* Se non si sia verificata una delle peraltro
incomprensibilmente esposte condizioni di cui sopra...*/

/* I nodi scanditi sono i.next e non i, come potrebbe pensare uno
che non avesse escluso grazie alle confusione precedente
il primo nodo. Facciamo finta che i.next sia, tutto incluso,
il nodo corrente */
for(Node i=first; i.next!=null; i = i.next){
/* Se il valore cercato equivale al contenuto del
nodo corrente, allora il nodo corrente, i.next è il
nodo da rimuovere */
if(x.equals(i.next.element)) {
/* se il nodo da rimuovere è l'ultimo, l'ultimo
diventa il nodo precedente a quello che contiene
il valore cercato. Il nodo precedente è i (il nodo
correntemente valutato, infatti, è i.next) */
if(i.next==last) last=i;

/* Il nodo corrente viene eliminato. Per farlo, il nodo
precedente di quello che contiene il valore cercato (i)
viene collecato (i.next =) al nodo successivo a quello
che contiene il valore cercato (i.next.next) */
i.next=i.next.next;

/* Non mi capacito del significato di questo mod */
mod++;

return true;
}
}
return false;
}

[aduri]

Grazie delle delucidazioni.
Per cio' che riguarda la variabile mod (modifiche) e' un contatore che viene incrementato ogni volta che viene usato un metodo remove(), add() e clear()
per evitare che modifiche concorrenti possano interferire col comportamento degli iteratori.
Il codice e' poco chiaro perche' e' uno stralcio di codice ho tralasciato il resto per questioni di spazio.