Newsgroup: it.comp.java
Titolo: Domanda sulle LinkedList

Supponiamo di avere un oggetto Data che gestisce determinate operazioni su
dei dati estratti da un DB (che vengono memorizzate in una collezione), e di
voler visualizzare questi dati in una JTable. Per il concetto della
separazione modello-vista la JTable non dovrebbe avere un accesso diretto a
queste informazioni, quindi il suo TableModel deve fare riferimento ad una
sorta di copia di questi dati.
Secondo voi quando invoco il costruttore LinkedList(Collection c) oppure
Vector(Collection c), viene allocata una nuova porzione di memoria (e quindi
viene fatta una copia degli oggetti contenuti nella collezione c) oppure
vengono creati una sorta di riferimenti agli oggetti presenti nella
collezione ???
Grazie delle opinioni, Claudio
________________________________________________  
Se c'è soluzione perché ti preoccupi ??
Se non c'é soluzione perché ti preoccupi ???
________________________________________________

 collezione ???
Immagino che venga cmq allocata nuova memoria ma per la collezione non per
gli oggetti che non vengono copiati. La nuova collezione deve contenere gli
stessi oggetti (o meglio, gli stessi riferimenti...)dell'originale non le
loro copie. Per altro per permettere la "copia profonda" di un oggetto
bisogna implementare Compearable e fare l'override di clone() per cui se
non l'hai fatto non credo che ci siano dubbi in merito alla copia :)
Ciao
Matteo
-- 
chi sono e soprattutto chi non sono:
http://web.tiscali.it/sifoneteagnalla/
un piccolo programma per studenti universitari:
http://www.ifthenelse.it/leonetti/imsv/

 non l'hai fatto non credo che ci siano dubbi in merito alla copia :)
Gli oggetti che sono contenuti nella collezione implementano Comparable,
potresti darmi qualche consiglio riguardo all'overriding di clone() ?? Che
tipo di codice dovrei scrivere ??
Ti ringrazio, Claudio
-- 



Se leggete bene la documentazione della API, il costruttore della classe
LinkedList avente la seguente dichiarazione:
LinkedList(Collection c)
o alternativamente quello della classe Vector, non fa altro che creare un
"NUOVO" oggetto LinkedList (o Vector) avente come elementi gli stessi
presenti nell'oggetto Collection passato in ingresso. Quindi viene fatta una
copia bella e buona di tutti gli elementi presenti nell'oggetto Collection,
allocando per questo la memoria sufficiente per la allocazione dei singoli
oggetti. Tenete presente che la classe LinkedList e la classe Vector
gestiscono in maniera differente la memoria, ma non voglio dilungarmi in
troppe spiegazioni. Per maggiori dettagli, andatevi a leggere la relativa
documentazione oppure postate una esplicita richiesta e vi accontenterò.
Ciao a tutti. Alla prossima ;-)
--------------------------------
Inviato via 
http://usenet.libero.it

Marco wrote:

A me sembra che ci sia una contraddzione. Proprio perché l'oggetto
LinkedList creato contiene gli stessi elementi della collection passata
come argomento non viene fatta alcuna copia degli elementi. Altrimenti non
vedo come potrebbero essere gli stessi.


 potresti darmi qualche consiglio riguardo all'overriding di clone() ?? 
ho detto una immane cazzata :)
volevo dire Cloneable non Comparable.
Ovviamente Comparable non c'entra niente con clone()


Attenzione!!! Non vengono semplicemente inseriti nella nuova LinkedList le
instanze degli Object contenuti nella Collection di ingresso. Praticamente
queste instanze vengono clonate, o meglio vengono create delle NUOVE
instanze di Object che sono i cloni di quelli contenuti nella Collection. In
ogni caso puoi stare tranquillo che se modifichi gli elementi della
LinkedList non vengono affatto interessati quelli della Collection, ok?
Spero di aver chiarito la situazione.
Bye ;-)

--------------------------------
Inviato via 
http://usenet.libero.it

 Spero di aver chiarito la situazione.
Era chiaro anche prima, solo che non sono d'accordo :)
Prova ad eseguire questo:
import java.util.*;
public class Main {
  public static void main(String[] arg) {
    Vector v = new Vector();
    v.add(new IntContainer());
    v.add(new IntContainer());
    LinkedList l = new LinkedList(v);
    ((IntContainer)l.getFirst()).i=5;
    System.out.println(((IntContainer)v.get(0)).i);
  }
}
class IntContainer {
    int i;
}
Come vedi modifico l'offetto da l ma accedendo all'oggetto da v trovo il
valore modificato. Le due collezioni hanno gli stessi oggetti non viene
fatta alcuna copia.


bravo. Credo proprio che tu abbia ragione
In ogni caso, io ho sempre evitato quel costruttore.
Se si vuole creare una collezione di oggetti a partire da un'altra, č meglio
fare in altro modo. Credo sia inutile suggerire metodologie a riguardo, in
quanto sono abbastanza banali ;-)
Alla prossima.

--------------------------------
Inviato via 
http://usenet.libero.it