[JAVA] Piccolo dubbio sugli array, helpme

[D4rkAng3l]

Sul compito d'esame la professoressa mette quasi sempre un esercizio dove dato un pezzo di codice di una classe e di un main dobbiamo mostrare cosa succede in memoria (stack ed heap)...ora non mi serve sapere come si fà perchè bene o male me la cavicchio...ho solo un dubbio allucinante sugli array (lo sò è una cosa stupida e credo di sapere la risposta ma il dubbio permane in me)

Se ho il seguente codice:

public class StranoOggetto {
       private int[] A;
    
       /** COSTRUTTORE:
           @param un array di interi
           @return un oggetto istanza della classe StranoOggetto */
       public StranoOggetto (int[] V) {
           int i;
           A = new int[V.length];		// Cosruisci A della stessa lunghezza del parametro ricevuto dal costruttore

           for (i=0; i<A.length; i++) A[i] = V[i]; 	// Copia in A gli elementi di V
       }

       public int[] getArray() {
			return A; 
		}
}

public class Test {
	public static void main(String[] args) {
		int i;
		int[] x={4,5,6};
		StranoOggetto C = new StranoOggetto(x);
		b = “domani”;
		x[0] = 48; // 1
		x = C.getArray()
		x[0]++; // 2
	}
}

dove il primo codice è la classe StranoOggetto e l'altro codice è una classe di test che contiene il metodo main()

Il mio dubbio è riferito a cosa succede in memoria quando viene eseguito il costruttore della classe StranoOggetto

Quanto eseguo l'operazione:
for (i=0; i<A.length; i++) A[i] = V[i]; // Copia in A gli elementi di V

io stò copiando fisicamente tutti i valori interi presenti in V dentro ad A e non i riferimenti a tale valori, giusto? (perchè sono valori primitivi).

Mentre invece se avessi avuto che A e V erano vettor di oggetti, allora facendo A[i] = V[i] avrei copiato nelle celle di memoria di A i riferimenti agli oggetti che erano nelle celle di memoria di V.

Ho capito bene?

Grazie
Andrea

[banryu79]

Originariamente inviato da D4rkAng3l

...
Il mio dubbio è riferito a cosa succede in memoria quando viene eseguito il costruttore della classe StranoOggetto

Quanto eseguo l'operazione:
for (i=0; i<A.length; i++) A[i] = V[i]; // Copia in A gli elementi di V

io stò copiando fisicamente tutti i valori interi presenti in V dentro ad A e non i riferimenti a tale valori, giusto? (perchè sono valori primitivi).

Mentre invece se avessi avuto che A e V erano vettor di oggetti, allora facendo A[i] = V[i] avrei copiato nelle celle di memoria di A i riferimenti agli oggetti che erano nelle celle di memoria di V.

Ho capito bene?

Sì, quando fai l'assegnazione:

for (i=0; i<A.length; i++) 
    A[i] = V[i];

con 'A' e 'V' che sono di tipo int[] stai copiando il valore di ogni singolo int contenuto nell'array V nell'array A.


Invece se A e V fossero stati array di oggetti, le cose sarebbero state diverse:

// crea solo una reference ad array di Object; l'array viene inizializzato con lo stesso numero di elementi presenti in V
Object[] A = new Object[V.length];

// copia i valori degli elementi di V in A
for (i=0; i<A.length; i++) 
    A[i] = V[i];

con 'A' e 'V' che sono di tipo Object[] stai copiando il valore di ogni singolo elemento contenuto nell'array V nell'array A.
Essendo i due array di tipo Object[], copiare un elemento da uno all'altro significa copiare il valore di una reference a Object (l'elemento, appunto è una reference) nel valore dell'altra reference; il valore di una reference è l'indirizzo in memoria dell'oggetto puntato.

Quindi se poi si va a modificare qualcosa ad un elemento di V (esempio di fantasia):

V[0].setValue(10);

si modifica l'oggetto puntato da quella reference e quindi la modifica è visibile anche dalle reference dell'array A, proprio perchè queste non fanno altro che puntare agli stessi Object di V.

// ora
A[0].getValue();
// tornerebbe 10

In pratica A[0] e V[0] nel caso degli int accedono a due diverse 'entità' (due diverse variabili di tipo intero) mentre nel caso degli oggetti A[0] e V[0] accedono [a due diverse reference in memoria che però hanno lo stesso valore e quindi di fatto puntano] allo stesso oggetto.

[D4rkAng3l]

Ok ti ringrazio, quindi la mia idea era corretta
Quindi se avessi avuto due array di Object per evitare possibili effetti collaterali (ovvero: se modifico un elemento di V mi si modifica anche un elemento di A) avrei dovuto farne una copia hard, giusto?

E tanto per approfondire bene...
un array è un intero, quindi starà nello heap e non nella stack, ogni oggetto punta a sua volta nello heap al record di allocazione della sua classe (che eventualmente contiene le variabili di classe ed il codice dei metodi di classe).

Quindi quando nel main si esegue l'istruzione: int[] x={4,5,6};

nella stack ho la variabile X che è un riferimento all'oggetto array nello heap che a suavolta punta al proprio record di allocazione della sua classe nello heap int[]

Giusto?

[banryu79]

Originariamente inviato da D4rkAng3l

Quindi quando nel main si esegue l'istruzione: int[] x={4,5,6};

nella stack ho la variabile X che è un riferimento all'oggetto array nello heap che a suavolta punta al proprio record di allocazione della sua classe nello heap int[]

Giusto?

Ecco, qui alzo le mani perchè in verità non conosco i dettagli di come sia gestito/piazzato in memoria un int[] in Java (avevo letto qualcosa su come vengono allocate le variabili e gli oggetti membro da parte della JVM quando deve inizializzare le classi ma è passato del tempo e non ricordo i dettagli).

[D4rkAng3l]

Originariamente inviato da banryu79

Ecco, qui alzo le mani perchè in verità non conosco i dettagli di come sia gestito/piazzato in memoria un int[] in Java (avevo letto qualcosa su come vengono allocate le variabili e gli oggetti membro da parte della JVM quando deve inizializzare le classi ma è passato del tempo e non ricordo i dettagli).

Vabbè ti ringrazio, casomai glielo chiedo domani alla proff visto che è tanto fissata che gli disegnamo cosa succede nello stack e nello heap al compito

[fero86]

Originariamente inviato da D4rkAng3l

Ho capito bene?

si, ma non é solo una questione di array: in generale in Java i tipi nativi vengono passati per copia di valore, mentre gli oggetti per copia di riferimento.
vale per tutto, anche per il passaggio di parametri o le comuni assegnazioni.

[banryu79]

Originariamente inviato da fero86

si, ma non é solo una questione di array: in generale in Java i tipi nativi vengono passati per copia di valore, mentre gli oggetti per copia di riferimento.
vale per tutto, anche per il passaggio di parametri o le comuni assegnazioni.

Sì, infatti nel linguaggio Java l'assegnamento/passaggio è sempre fatto per valore.

Questo potrebbe sembrare controintuitivo ma in realtà è così; in Java puoi avere solo due casi:
- tipi primitivi

// primitiva di tipo int = valore letterale int
int a = 1;

- reference (riferimento a oggetto)

// riferimento di tipo Object = oggetto
Object ref = new Object();

Cosa significa copiare il valore di una variabile di tipo primitivo in un'altra è abbastanza immediato.
Cosa significa copiare il valore di una reference in un'altra reference te l'ho spiegato sopra: equivale a copiare il valore di quella reference (un indirizzo) dentro a un'altra reference, in altri termini significa far puntare la seconda reference allo stesso oggetto a cui punta la prima.

[malocchio]

Gli array (tutti i tipi) stanno nell'heap. Nello stack ci stanno solo le variabili primitive o reference (ad oggetto o array) dichiarate all'interno di un metodo, o in un blocco di codice tipo if o ciclo di qualsiasi tipo.

variabili d'istanza -> heap
variabili locali (chiamate anche variabili automatiche perché si "autodistruggono" alla fine del blocco di codice) -> stack

Il modo migliore per capire dove sta una variabile è guardare dov'è stata dichiarata.