(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.