perchè la modifica di un oggetto di un arraylist è riflessa?

[pupone83]

Salve ho creato un grafo dove i vertici sono oggetti remoti ognuno avente un arraylist con gli archi incidenti.
Perchè se modifico un arco(ad esempio variando il peso) la modifica viene ripetuta su un altro nodo(oggetto remoto) il quale incide sull'arco modificato(ovvero viene modificato l'arco contenuto nell'arraylist dell'altro nodo incidente sull'arco) e perchè la modifica non rimane locale?
Sto impazzendo!

[satifal]

Magari del codice di esempio e qualche spiegazione in più potrebbero facilitare la ricerca della soluzione al tuo problema.

[pupone83]

Classe Arco :

//classe Arco
public class Arco implements Serializable{
	//campi
	
	//i due id dei nodi
	public int IDNodo1=-1,IDNodo2=-1;
	//peso o id dell'arco
	public int pesoArco=-1;
	//stato dell'arco
	public enum stato{rejected,branch,basic};
	public stato statoArco;
	
	
	
	//costruttore
	public Arco(int n1,int n2,int peso,Arco.stato stato){
		IDNodo1=n1;
		IDNodo2=n2;
		pesoArco=peso;
		statoArco=stato;
	}
	
	//get/set
	
	public int getIDNodo1() {
		return IDNodo1;
	}

	public void setIDNodo1(int iDNodo1) {
		IDNodo1 = iDNodo1;
	}

	public int getIDNodo2() {
		return IDNodo2;
	}

	public void setIDNodo2(int iDNodo2) {
		IDNodo2 = iDNodo2;
	}

	public stato getStatoArco() {
		return statoArco;
	}

	public void setStatoArco(stato sArco) {
		statoArco = sArco;
	}

	public int getPesoArco() {
		return pesoArco;
	}
	
	public void setPesoArco(int peso) {
		pesoArco = peso;
	}
}

Classe Remota :

public class InterfacciaRemotaDMSTImpl extends UnicastRemoteObject implements InterfacciaRemotaDMST,Runnable{
	//campi
	
	//lista archi incidenti sul nodo
	public ArrayList listaArchiIncidenti;
...

//wakeup
	public void wakeup() throws RemoteException{
		
                //nodo adiacente al nodo 1
		InterfacciaRemotaDMST nodo5=RRServer.getRRNodoById(5);
		//ottengo l'arraylist degli archi incidenti al nodo 5
               ArrayList archinodo5=nodo5.getListaArchiIncidenti();
	

                 //arco di peso minimo incidente sul nodo 5
		Arco b=((Arco)archinodo5.get(1));
	        //modifico lo stato
         	b.setStatoArco(Arco.stato.rejected);

se listo lo stato degli archi incidenti al nodo 5 tale arco risulta modificato ma risulta modificato anche sul nodo adiacente 1,nel relativo arraylist.
perchè la modifica non è rimasta locale all'arraylist sul nodo 5?

[pupone83]

succede anche in talo esempio che la modifica viene riflessa perchè?

ArrayList lista1=new ArrayList();
		Arco a=new Arco(1,2,1,Arco.stato.basic);
		Arco b=new Arco(1,2,1,Arco.stato.basic);
		Arco c=new Arco(1,2,1,Arco.stato.basic);

		lista1.add(a);
		lista1.add(b);
		lista1.add(c);
		
		ArrayList lista2=new ArrayList();
		lista2.add(a);
		lista2.add(b);
		
			for(int i=0;i<lista1.size();i++)
				System.out.println(/*nodo1.getIdNodo()+" "+*/((Arco)lista1.get(i)).getStatoArco());
			
			for(int i=0;i<lista2.size();i++)
				System.out.println(/*nodo2.getIdNodo()+" "+*/((Arco)lista2.get(i)).getStatoArco());
		
			Arco test=(Arco)lista1.get(0);
			test.setStatoArco(Arco.stato.rejected);
			
			for(int i=0;i<lista1.size();i++)
				System.out.println(/*nodo1.getIdNodo()+" "+*/((Arco)lista1.get(i)).getStatoArco());
			
			for(int i=0;i<lista2.size();i++)
				System.out.println(/*nodo2.getIdNodo()+" "+*/((Arco)lista2.get(i)).getStatoArco());

grazie.

[mxa]

Perche' gli oggetti Arco nelle due liste sono gli stessi.

lista1.get(0) e lista2.get(0) ritornano lo stesso oggetto, quindi quando lo modifichi lo modifichi e basta, indipendentemente dal fatto che tu recuperi quell'oggetto da lista1 o lista2.

[pupone83]

come posso modificare solo dalla prima arraylist e non dalla seconda?

[Alex'87]

Originariamente inviato da pupone83
come posso modificare solo dalla prima arraylist e non dalla seconda?

In un arraylist metti gli archi, nell'altro metti dei loro cloni (guarda l'interfaccia Cloneable)

[mxa]

Fai una copia invece che mettere dentro lo stesso oggetto.

Pero' non sono sicuro che sarebbe la scelta giusta:

Prendiamo l'esempio di un grafo non orientato composto da 2 nodi (N1 e N2) connessi tramite un arco (A1).

Tramite N1 recuperi l'istanza ad A1, e ne cambi lo stato. Dal punto di vista logico, quando da N2 recupere l'istanza dell'arco che lo connette ad N1, che sara' sempre A1, e' corretto che tu veda lo stato modificato di quell'arco, perche' e' di fatto lo stesso arco.

Ti pare che il mio esempio abbia senso?

[LeleFT]

Come da Regolamento interno (punto 6), usa i tag CODE quando posti del codice.

Sistemo io.


Ciao.