Newsgroup: it.comp.java
Titolo: Parametri e assegnazioni.

class PPP{
	public static void main(String[] args){
		String[] pippo;
		pippo = new String[2];
		pippo[0] = "rosso";
		pippo[1] = "arancio";
		System.out.println(pippo[0]);
		System.out.println(pippo[1]);
		System.out.println(Modifica(pippo));
		System.out.println(pippo[0]);
		System.out.println(pippo[1]);
	}
	public static String Modifica(String[] pluto){
		String[] paperino;
		paperino = new String[pluto.length];
		paperino = pluto;
		pluto[0] = "yuck";
		pluto[1] = "squak";
		return paperino[0] + "\n" + paperino[1] + "\n" + pluto[0] + "\n" +
pluto[1] + "\n";
	}
}
L'istruzione Paperino = Pluto copia il valore di Pluto in Paperino,
valore che in questo caso è il riferimento ad un oggetto array di
stringhe. Io vorrei che in paperino venisse memorizzato un array
uguale ma non il riferimento a quello già esistente e che quindi il
return del metodo restituisca "rosso" "arancio" "yuck" "squak"  dal
momento che l'assegnazione avviene prima della modifica e non "yuck"
"squak" "yuck" "squak" come invece fà. Come faccio? E più in generale,
io sto modificando sempre lo stesso oggetto array dal momento che
anche il println nel main restituisce la stessa cosa e tra l'altro
credo di aver messo qualche istruzione di troppo nel metodo
Modifica(). Mi chirite le idee in proposito? Che fine fà quell'array
new che io ho memorizzato in paperino nel momento in cui io in
paperino memorizzo il riferimento di pluto? Come avrei fatto oltre che
per avere un nuovo array uguale in paperino ad averne uno nuovo ed
uguale a pippo in pluto senza che neanche pluto memorizzi il
riferimento di pippo, ovvero ad avere tre oggetti array distinti?
Grazie

 Grazie
Se guardi bene nella documentazione, troverai un costruttore di String che
accetta come parametro un'altro oggetto String, permettendoti di crearne uno
equivalente ma distinto dall'originale. Nello specifico, il metodo Modifica
dovrebbe essere:
  public static String modifica(String[] pluto) {
    String[] paperino = new String[pluto.length];
    for(int i=0;i<pluto.length;i++) paperino[i]=new String(pluto[i]);
    pluto[0] = "yuck";
    pluto[1] = "squak";
    return paperino[0] + "\n" + paperino[1] + "\n" + pluto[0] + "\n" +
pluto[1] + "\n";
  }
Quando poi i tuoi programmi diventeranno sempre più complessi, il mio
consiglio personale è di non affidarti troppo all'operatore "+" per
concatenare le stringhe. A lungo andare potresti ritrovarti con consumi di
memoria eccessivi. Meglio usare StringBuffer e il metodo append(), e
convertire solo all'ultimo il tutto in String tramite toString().
-- 
Fermiamo Scientology prima che sia troppo tardi!!!
http://xenu.com-it.net
 - 
http://xenu.freewinds.cx/
 - 
http://www.xenu.net/
(per rispondere personalmente leva IlDitoDalCulo)

 convertire solo all'ultimo il tutto in String tramite toString().
Grazie del consiglio sulla concatenazione di stringhe anche se per ora
non so precisamente a cosa ti riferisci in quanto sono solo 7 giorni
che ho scritto la mia prima istruzione Java ;-)
Per quanto riguarda gli array di stringhe volevo sapere se esistesse
un'istruzione per copiare un array in un altro senza usare un ciclo
che itera tutti gli elementi dell'array, ma dalla tua risposta deduco
di no.
Il metodo funziona anche "paperino[i]= pluto[i];" così, senza
utilizzare il costruttore di String che accetta uno String come
parametro, ma in questo caso non mi è ben chiaro il motivo di scrivere
l'istruzione come l'hai scritta tu.
Grazie. 
bYe

 
A guardare bene il codice originale mi rendo conto di aver fatto un errore
di valutazione, e lo spreco di memoria era proprio il mio :D
Infatti l'istruzione
  for(int i=0;i<pluto.length;i++) paperino[i]=new String(pluto[i]);
puň essere riscritta per copiare solo i riferimenti (come hai detto tu):
  System.arrayCopy(pluto,0,paperino,0,pluto.length);
In effetti quello che ti serve č un "backup" dei riferimenti originali, non
una copia binaria...
Chiedo scusa per la confusione...
