[java] Confronto tra due ArrayList

[raniero]

Ciao, ho implementato un metodo che dovrebbe confrontare uno ad uno gli elementi di due arraylist , e ritorna true se gli elementi della seconda sono contenuti nella prima. non sono sicuro dell'esattezza del metodo, vi posto il codice.



public boolean disponibilita(ArrayList lista2){

boolean t=false;

for (int i = 0; i < lista1.size(); i++){
Attrezzo attrezzocass = (Attrezzo) lista1.get(i);

for(int j = 0; j < lista2.size(); j++){
String attrezzocheck = (String)listaAttrezzicheck.get(j);

if (attrezzocass.equals(attrezzocheck)){
t=true;
}
}

}

return t;
}

[kingv]

Nella firma del metodo ti sei dimenticato lista1, in ogni caso così non va bene perchè basta che uno degli elementi di lista2 sia uguale a uno di lista1 perchè il metodo ritorni true ;)

[crick_pitomba]

Nella firma del metodo ti sei dimenticato lista1, in ogni caso così non va bene perchè basta che uno degli elementi di lista2 sia uguale a uno di lista1 perchè il metodo ritorni true ;)

più precisamente il codice che hai scritto restituisce true se l'ultimo elemento di lista1 è uguale all'ultimo elemento di lista2, false altrimenti.

Penso che il codice di cui hai bisogno dovrebbe essere questo


trovato=false;
i=0;

while ((i<lista2.size())){
/**
* prendi un elemento della seconda lista: vuoi controllare che la prima
* contenga quelli della seconda. Quindi immagino che la prima possa
* contenere elementi non contenuti nella seconda, ma non deve essere
* vero il viceversa
*/
String attrezzocheck = (String)listaAttrezzicheck.get(i);
//confronta tutti gli elementi della prima con l'elemento corrente
j=0;
while(j<lista1.size()) {
Attrezzo attrezzocass = (Attrezzo) lista1.get(j);
trovato=attrezzocass.equals(attrezzocheck));
/**
* una volta che hai trovato l'elemento della seconda nella prima
* è inutile continuare a cercare nella prima... puoi cominciare a
* controllare l'elemento successivo della seconda
if (trovato) continue;
j++
}
/**
* a questo punto se non hai trovato l'elemento cercato durante il
* ciclo precedente è inutile continuare a cercare perchè sicuramente
* un elemento della seconda lista non è presente nella prima
* quindi puoi uscire dalla funzione restituendo false;
*/
if(!trovato) return trovato;
i++
}
/**
* se sei arrivato qui in pratica non sei mai uscito in precedenza e quindi
* trovato deve essere rimasto true per tutto il corso della funzione
* in questo caso restituisci true
*/
return trovato;

[kingv]

più precisamente il codice che hai scritto restituisce true se l'ultimo elemento di lista1 è uguale all'ultimo elemento di lista2, false altrimenti.



direi di no, basta che uno qualsiasi degli elementi di lista2 sia uguale a uno di lista1 perche' la variabile t venga messa a true e non ci sono istruzioni che ne possano modificare ulteriormente il valore prima del return ;)

[crick_pitomba]

direi di no, basta che uno qualsiasi degli elementi di lista2 sia uguale a uno di lista1 perche' la variabile t venga messa a true e non ci sono istruzioni che ne possano modificare ulteriormente il valore prima del return ;)

hai ragione... evidentemente ero ancora un po' rincoglionito dalla mancanza di sonno :P

[raniero]

il metodo che mi avete suggerito non funziona, non arriva mai al return finale... :(

[raniero]

ho implementato questa soluzione, che ne dite?



public synchronized boolean disponibilita (ArrayList lista2) {


boolean trovato=false;
int i =0;
int j=0;



while (i<lista2.size() && j<lista1.size()){

String attrezzocheck = (String)lista2.get(i);
Attrezzo attrezzocass = (Attrezzo) lista1.get(j);

if (attrezzocass.equals(attrezzocheck)){
trovato=true;

i++;
j=0;
}
else {
j++;}


if(!trovato && j==lista1.size()) {

trovato=false;
} else if (trovato && i==lista2.size()) {


trovato= true;
}
}

return trovato;


}

[crick_pitomba]

il metodo che mi avete suggerito non funziona, non arriva mai al return finale... :(

scusa... ho fatto un errore di distrazione :P

while(j<lista1.size()) {
Attrezzo attrezzocass = (Attrezzo) lista1.get(j);
trovato=attrezzocass.equals(attrezzocheck));
/**
* una volta che hai trovato l'elemento della seconda nella prima
* è inutile continuare a cercare nella prima... puoi cominciare a
* controllare l'elemento successivo della seconda
if (trovato) break;
j++
}

deve essere break e non continue altrimenti cicla all'infinito ....