View Full Version : [java] array/vettore
nuovoUtente86
02-07-2007, 10:46
Sento alcuni programmatori parlare di array e vettori come entità differenti quando per me sono la medesima cosa,voi come la pensate e come utilizzate i 2 termini.
Per me parlare di array o vettore indica questo:
Object [] variabile;
Sento alcuni programmatori parlare di array e vettori come entità differenti quando per me sono la medesima cosa,voi come la pensate e come utilizzate i 2 termini."array" e "vettore" sono la stessa cosa. Dal punto di vista puramente linguistico, "vettore" è il termine specifico usato in matematica.
Ma nel campo dell'informatica il significato è lo stesso: un tipo di dato che rappresenta un insieme di dati dello stesso tipo.
http://it.wikipedia.org/wiki/Array
nuovoUtente86
02-07-2007, 11:10
infatti io li ho sempre utilizzati indifferentementi.Un altro dubbio sui vettori.
se per fare la copia di array di tipi primitivi si fa qualcosa del genere:
int[] v1 = new int[5];
v1[0] = 10;
v1[1] = 12;
v1[2] = 14;
v1[3] = 16;
v1[4] = 18;
int[] v2 = new int[5];
int i = 0;
while(i < v1.lengt) {
v2[i] = v1[i];
}
in modo che i 2 array non condividano memoria,come si agisce quando si tratta di oggetti e facendo v2[i]=v1[i] si crea cmq un secondo riferimento allo stesso oggetto.Ipotzzando che sia una stringa..se la modifica il vettore V2..la modifica si ripercuote anche su v1..per cui equivale a fare un' assegnazione..cioè nn vi è piu diferenza tra l' assegnazione e la deferenziazione.
se per fare la copia di array di tipi primitivi si fa qualcosa del genere:
int[] v1 = new int[5];
v1[0] = 10;
v1[1] = 12;
v1[2] = 14;
v1[3] = 16;
v1[4] = 18;
int[] v2 = new int[5];
int i = 0;
while(i < v1.lengt) {
v2[i] = v1[i];
}
in modo che i 2 array non condividano memoria,come si agisce quando si tratta di oggetti e facendo v2[i]=v1[i] si crea cmq un secondo riferimento allo stesso oggetto.Ipotzzando che sia una stringa..se la modifica il vettore V2..la modifica si ripercuote anche su v1..per cui equivale a fare un' assegnazione..cioè nn vi è piu diferenza tra l' assegnazione e la deferenziazione.Parlando in generale, per copiare i valori tra due array, oltre alla strada "fai-da-te", in genere basta usare il metodo System.arraycopy(). Come puoi immaginare, copia i valore o reference pari pari.
Se ti interessa fare una "deep copy" (clonazione profonda), allora devi fare tu un clone() dei singoli oggetti (che naturalmente devono essere clonabili).
Nel caso di String, però non è clonabile (non implementa Cloneable) ma in genere non è un problema e non ha molto senso clonare una stringa. Infatti una stringa è un oggetto immutabile.
nuovoUtente86
02-07-2007, 11:30
Parlando in generale, per copiare i valori tra due array, oltre alla strada "fai-da-te", in genere basta usare il metodo System.arraycopy(). Come puoi immaginare, copia i valore o reference pari pari.
Se ti interessa fare una "deep copy" (clonazione profonda), allora devi fare tu un clone() dei singoli oggetti (che naturalmente devono essere clonabili).
Nel caso di String, però non è clonabile (non implementa Cloneable) ma in genere non è un problema e non ha molto senso clonare una stringa. Infatti una stringa è un oggetto immutabile.
se ho capito bene il metodo arraycopy
fa questo
Object[] v2=.........
while(........)
v2[i]=v1[i];
cosa che però potrei ad esempio evitare con un costruttore per copia
v2[i]=new MiaClasse(v1[i]);
corretto?
La stringa come mai è immutabile?
se io faccio
String s="ciao";
s=s+"ciao" equivale se ho ben capito a fare s=new String("ciaociao");
se ho capito bene il metodo arraycopy
fa questo
Object[] v2=.........
while(........)
v2[i]=v1[i];Sì, diciamo più o meno così. Non so dirti esattamente cosa fa arraycopy(), perché è un metodo nativo.
cosa che però potrei ad esempio evitare con un costruttore per copia
v2[i]=new MiaClasse(v1[i]);
corretto?Eeehhhh??? Non ha senso in Java parlare di "costruttore di copia" (non siamo in C++). Basta che implementi Cloneable se vuoi avere un oggetto clonabile.
La stringa come mai è immutabile?Perché una volta che hai costruito un oggetto String, non esiste alcun metodo per alterarne il contenuto. Tutti i metodi della classe String (es. trim(), concat(), ecc....) restituiscono un nuovo oggetto che contiene appunto le modifiche ma non modificano l'oggetto String su cui è stato invocato il metodo!
se io faccio
String s="ciao";
s=s+"ciao" equivale se ho ben capito a fare s=new String("ciaociao");eh eh, classico errore .... non ti preoccupare.
No, non è la stessa cosa. La operazione di concatenazione s+"ciao" crea un nuovo oggetto il cui reference viene semplicemente assegnato alla variabile 's'. Che sostituisce il vecchio reference che puntava a "ciao".
nuovoUtente86
02-07-2007, 11:50
Sì, diciamo più o meno così. Non so dirti esattamente cosa fa arraycopy(), perché è un metodo nativo.
Eeehhhh??? Non ha senso in Java parlare di "costruttore di copia" (non siamo in C++). Basta che implementi Cloneable se vuoi avere un oggetto clonabile.
Perché una volta che hai costruito un oggetto String, non esiste alcun metodo per alterarne il contenuto. Tutti i metodi della classe String (es. trim(), concat(), ecc....) restituiscono un nuovo oggetto che contiene appunto le modifiche ma non modificano l'oggetto String su cui è stato invocato il metodo!
eh eh, classico errore .... non ti preoccupare.
No, non è la stessa cosa. La operazione di concatenazione s+"ciao" crea un nuovo oggetto il cui reference viene semplicemente assegnato alla variabile 's'. Che sostituisce il vecchio reference che puntava a "ciao".Come mai nn ha senso in java parlare di costruttore per copia?
Io sn stato sempre abituato a ragionare appunto per costruttore per copia e a non utilizzare mai cloneable.Penso cmq il risultato finale sia identico no?
Non ho ben capito il discorso della concatenazione e la differenza con gli altri metodi,non viene cmq creato un nuovo oggetto ed assegnato alla variabile:
cosa cambia tra
String s="ciao";
s="ciao pippo";
s+="pippo";
Come mai nn ha senso in java parlare di costruttore per copia?
Io sn stato sempre abituato a ragionare appunto per costruttore per copia e a non utilizzare mai cloneable.Penso cmq il risultato finale sia identico no?Nessuno ti vieta di fare una tua classe in cui c'è un costruttore che ha come parametro un reference della stessa classe, in modo che poi nel costruttore puoi copiare i vari fields.
Ma non sarebbe un comportamente generico/generale. Solo il programmatore che ispeziona il sorgente o legge la documentazione può poi capire: "oh guarda ... c'è un costruttore apposito per fare una copia dell'oggetto!".
In Java si implementa la interfaccia Cloneable e il metodo clone().
Non ho ben capito il discorso della concatenazione e la differenza con gli altri metodi,non viene cmq creato un nuovo oggetto ed assegnato alla variabile:
cosa cambia tra
String s="ciao";
s="ciao pippo";
s+="pippo";Partiamo da un presupposto: le stringhe "qualcosa" che si mettono nei sorgenti sono stringhe dette "literal" e sono memorizzate in un "constant pool".
Quindi fare:
String s = "ciao";
e fare
String s = new String ("ciao");
non è proprio esattamente la stessa cosa (anche se il risultato è lo stesso). Nel primo caso c'è solo una stringa literal assegnata ad s (1 oggetto). Nel secondo caso hai una stringa literal e a runtime viene creato un secondo oggetto (il cui reference è diverso da quello della stringa literal) che contiene la stessa sequenza di caratteri della stringa literal (2 oggetti)
Passiamo alla concatenazione.
String s = "ciao";
s = s + " pippo";
la concatenazione NON modifica la stringa originalmente referenziata da s ma crea un nuovo oggetto che è il risultato della concatenazione e lo assegna poi ad s.
È una cosa diversa dal fare:
String s = "ciao pippo";
perché nel primo caso hai 2 stringhe literal e a runtime viene creato un terzo oggetto che contiene la concatenazione.
nuovoUtente86
02-07-2007, 12:53
Nessuno ti vieta di fare una tua classe in cui c'è un costruttore che ha come parametro un reference della stessa classe, in modo che poi nel costruttore puoi copiare i vari fields.
Ma non sarebbe un comportamente generico/generale. Solo il programmatore che ispeziona il sorgente o legge la documentazione può poi capire: "oh guarda ... c'è un costruttore apposito per fare una copia dell'oggetto!".
In Java si implementa la interfaccia Cloneable e il metodo clone()..
Quindi è essenzialmente un questione di leggibilità e universalità del codice ma ciò non inficia la corretteza del codice stesso?
Partiamo da un presupposto: le stringhe "qualcosa" che si mettono nei sorgenti sono stringhe dette "literal" e sono memorizzate in un "constant pool".
Quindi fare:
String s = "ciao";
e fare
String s = new String ("ciao");
non è proprio esattamente la stessa cosa (anche se il risultato è lo stesso). Nel primo caso c'è solo una stringa literal assegnata ad s (1 oggetto). Nel secondo caso hai una stringa literal e a runtime viene creato un secondo oggetto (il cui reference è diverso da quello della stringa literal) che contiene la stessa sequenza di caratteri della stringa literal (2 oggetti)
Passiamo alla concatenazione.
String s = "ciao";
s = s + " pippo";
la concatenazione NON modifica la stringa originalmente referenziata da s ma crea un nuovo oggetto che è il risultato della concatenazione e lo assegna poi ad s.
È una cosa diversa dal fare:
String s = "ciao pippo";
perché nel primo caso hai 2 stringhe literal e a runtime viene creato un terzo oggetto che contiene la concatenazione.
Domanda principale:come mai java utilizza tale sistema per le stringhe?
quindi diciamo new String("ciao"); costringe java a tenere 2 oggetti in memoria senza che il garbace possa intervenire?
Grossolanamente avviene una cosa del genere
class MiaStringa{
String s;
public MiaString(String st){s=st;}}
ma allora dopo tutti questo discorso cosa serve il costruttore String(String);
computazionalmente seppur in termini ridotti è meglio utilizzare sempre String s="qualcosa";
?
Quindi è essenzialmente un questione di leggibilità e universalità del codice ma ciò non inficia la corretteza del codice stesso?La questione è che implementando Cloneable tu definisci un "contratto", come dire: "guardate ... il mio oggetto è clonabile".
Domanda principale:come mai java utilizza tale sistema per le stringhe?
quindi diciamo new String("ciao"); costringe java a tenere 2 oggetti in memoria senza che il garbace possa intervenire?Le stringhe literal non vengono reclamate dal gc. Ma oggetti creati con 'new' possono essere reclamati dal gc, se il gc scopre che tali oggetti non sono più utilizzati.
Integer i = new Integer (12);
i = new Integer (20);
L'oggetto Integer che vale 12 non viene più referenziato, perché nella seconda riga ho assegnato ad i un nuovo reference. L'oggetto Integer che contiene il numero 12 può quindi essere preso in considerazione dal garbage collector.
Grossolanamente avviene una cosa del genere
class MiaStringa{
String s;
public MiaString(String st){s=st;}}Non, non è così. Non è solo una copia di un reference! La classe String internamente ha un char[] che contiene i caratteri. Nel caso di costruzione partendo da un stringa, vengono copiati proprio tutti i caratteri. Il nuovo oggetto String creato e lo String passato al costruttore non hanno nulla in comune, se non la stessa sequenza di caratteri.
nuovoUtente86
02-07-2007, 13:20
come mai mantiene in memoria anche la literal se potrebbe in realtà farne una copia profonda e liberarsene,liberando anche risorsa.
come mai mantiene in memoria anche la literal se potrebbe in realtà farne una copia profonda e liberarsene,liberando anche risorsa.Le stringhe literal vengono messe in un constant pool.
Se fai:
String a = "ciao";
....
String b = "ciao";
I due reference sono esattamente uguali. Il compilatore si accorge che sono stringhe literal uguali e nel constant pool ne mette una sola.
http://java.sun.com/docs/books/jls/third_edition/html/lexical.html#3.10.5
http://java.sun.com/docs/books/jvms/second_edition/html/Overview.doc.html#22973
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.