Newsgroup: it.comp.java
Titolo: Prendetemi pure per il c... ma...Aiuto!

Bene. Domani consegno un progetto che mi è costato abbastanza
fatica...stasera ultimi test...e non ti trovo un "buco" della miseria!!!
In poche parole, ho un array di oggetti e devo fare una copia del elemento
in posizione i+1 sul elemento in posizione i. ma sembra che facendo
oggetti[i]=oggetti[i+1]
il tutto non funzioni minimamente.
come devo fare....
grazie mille

 wrote in message
news:Rd7s7.3101$_42.1...@news.infostrada.it...



ricorda che se l'array contiene Object, quello che copi e` solo il
riferimento all'oggetto, quindi quando fai
  a[i]=a[i+1]
non hai due copie dell'oggetto a[i+1] ma due riferimenti allo stesso
oggetto in memoria.
Se vai successivamente a modificare lo stato di a[i+1], hai di
conseguenza modificato anche quello di a[i];
Per capirsi:
class P {
   int val;
   P( int v ) { val = v; }
}
public class Prova {
   public static void main( String[] args ) {
      P[] a = new P[2];
      a[0] = new P(1);
      a[1] = new P(2);
      for( int i = 0; i < a.length; i++ )
      // stampa 1, 2
         System.out.println( a[i].val );
      a[0]=a[1];
      for( int i = 0; i < a.length; i++ )
      // stampa 2, 2
         System.out.println( a[i].val );
      a[1].val = 3;
      for( int i = 0; i < a.length; i++ )
      // stampa 3, 3
         System.out.println( a[i].val );
   }
}
L'unico altro "problema" che puo` darti un array e` se vai a
scrivere/leggere oltre il limite, ...ma piu` precisamente che problema
hai??
-- 
Ciao,  |     Gott weiss ich will kein Engel sein
Matteo |                     -- Rammstein, Engel

In poche parole io ho una pila di oggetti, voiglio toglierne uno dal mezzo e
per far questo faccio un ciclo for del tipo
for(i=indice;i<Counter;i++){
oggetti[i]=oggetti[i+1]
}
che "dovrebbe" far scorrere in alto tutta la pila di uno a partire da
indice. Eppure qiesto non č il risultato ottenuto, a mio avviso perchč
l'istruzione oggetti[i]=oggetti[i+1]  non va a mettere in oggetti[i] oggetti
[i+1].

: 

L'istruzione "va a mettere in oggetti[i] in oggetti [i+1]" di sicuro :-),
ma ci sono mille possibilita' per cui quello che accade non sia quello
che tu vuoi che accada.
Ad esempio, puoi aver ridichiarato "oggetti" localmente. Oppure, se
"Counter" e' uguale alla lunghezza dell'array avrai un'eccezione
sull'ultimo elemento. Se quando il "for" viene incontrato, "indice" non
e' strettamente minore di "Counter", il corpo del ciclo non viene mai
eseguito. Eccetera. 
-- 
Life's something u don't get out alive..
ObjectZone - 
http://space.tin.it/computer/csadun


ti faccio un altro esempio allora, che piu` o meno fa quello che chiedi:
// gli elementi contenuti nell'array
class Item {
  int val;
  Item( int v ) { val = v; }
  public String toString() { return ""+val; }
}
public class Prova {
  Item[] lista;
  // crea l'array
  public Prova( int size ) {
    lista = new Item[size];
    for( int i = 0; i < lista.length; i++ ) 
      lista[i] = new Item( i );
  }
  // per stampare l'array
  public String toString() {
    StringBuffer sb = new StringBuffer();
    for( int i = 0; i < lista.length; i++ ) {
      sb.append( lista[i].toString() );
      sb.append( " " );
    }
    return sb.toString();
  }
  // cancella un elemento dall'array "shiftando" il resto
  Item cancella( int indice ) {
    Item rimosso = lista[ indice ];
    for( int i = indice; i < lista.length - 1; i++)
      lista[i] = lista[i+1];
    lista[ lista.length - 1 ] = new Item( -1 );
    return rimosso;
  }
  // programma di esempio
  static public void main( String[] args ) {
    try {
       Prova test = new Prova( 10 );
       System.out.println( test );
       Item cancellato = test.cancella( 5 );
       System.out.println( "cancellato = "+cancellato );
       System.out.println( test );
    } catch( Exception e ) {
       System.err.println( "[ERROR]: " + e );
       System.exit( 1 );
    }
    System.exit( 0 );
  }
}
dai un'occhiata al metodo Prova.cancella(). Come vedi il ciclo si ferma
a   i == lista.length - 2   poiche` in questo caso
  i+1 == lista.length - 1 e` proprio l'indice dell'ultimo elemento e
l'ultimo valore per cui  lista[i+1] abbia un senso.
Se andasse ancora avanti avrei alla prossima esecuzione
  lista[i] = lista[i+1]  errore ArrayIndexOutOfBoundsException
con lista[i+1] oltre il limite dell'array.
Notare poi che l'array non si e` "accorciato" e che quindi inserisco in
ultima posizione un valore "fittizio" (-1) che mi dica che quella cella
e` vuota. Se ponessi semplicemente lista[ lista.length - 1 ] = null poi
avrei un NullPointerException ad un successivo tentativo di accesso a
meno di non fare ogni volta il controllo elemento != null, o di tenermi
un'altra variabile con il numero di elementi presenti nell'array
(<= lista.length) da aggiornare ad ogni cancellazione. In ogni caso
questa gestione non e` propriamente "comoda".
Ovviamente non posso entrare nel merito di quello che stai facendo,
visto che ci ha dato ben poche informazioni, pero` secondo me gli array
non vanno bene per fare quello che vuoi fare, nel senso che sono
strutture dati che non si possono ridimensionare dinamicamente durante
l'esecuzione. Se volessi realmente eliminare l'ultima cella dell'array,
dovresti copiare le altre n-1 in un nuovo array e sostituirlo al
vecchio, il che e` un'operazione non proprio "indolore"
computazionalmente parlando (sono poche istruzioni, ma se l'array e`
grande ti prende molto tempo).
Se tu vuoi un qualcosa che cambi dimensione, ti consiglio di dare
un'occhiata a Vector o ArrayList, che dovresti trovare piuttosto comodi.
Nella libreria standard java trovi gia` molte classi di utilita` che
permettono di implementare facilmente ed efficacemente una "collezione
di oggetti", con diverse specializzazioni a seconda dell'uso che devi
farne. In definitiva forse ti conviene dare un'occhiata al package
java.util ed al Java Tutorial alla sezione "Collection", e usare la
"trasformazione in array" solo quando la tua collezione e` divenuta
"stabile" e da trattare in "read-only".
Spero di essere stato chiaro e di esserti stato di un qualche aiuto.
