[java] array/vettore

[nuovoUtente86]

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;

[andbin]

Originariamente inviato da nuovoUtente86

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]

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.

[andbin]

Originariamente inviato da nuovoUtente86

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]

Originariamente inviato da andbin

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");

[andbin]

Originariamente inviato da nuovoUtente86

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.

Originariamente inviato da nuovoUtente86

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.

Originariamente inviato da nuovoUtente86

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!

Originariamente inviato da nuovoUtente86

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]

Originariamente inviato da andbin

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";

[andbin]

Originariamente inviato da nuovoUtente86

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().

Originariamente inviato da nuovoUtente86

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]

Originariamente inviato da andbin

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?

Originariamente inviato da andbin

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";
?

[andbin]

Originariamente inviato da nuovoUtente86

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".

Originariamente inviato da nuovoUtente86

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.

Originariamente inviato da nuovoUtente86

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]

come mai mantiene in memoria anche la literal se potrebbe in realtà farne una copia profonda e liberarsene,liberando anche risorsa.

[andbin]

Originariamente inviato da nuovoUtente86

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/t...al.html#3.10.5
http://java.sun.com/docs/books/jvms/...doc.html#22973