[JAVA] dubbio sui tipi di dato

[Player1]

Ciao a tutti, programmo già da qualche anno in java, attualmente sto cercando di approfondirlo ed ho un dubbio sui tipi di dato primitivi che spero qualcuno di voi possa aiutarmi a chiarire.

Se io scrivo
String a = "pippo";
Dovrei aver creato una variabile a contenente un puntatore all'oggetto che contiene pippo.

e se scrivo
String a2 = new String("pippo");?
a2 a cosa punta ad un oggetto che contiene "pippo"?

Se scrivo

if(a==a2){
System.out.println("uguali);
}
else{
System.out.println("diverse");
}

mi dice che le stringhe sono diverse.
Ma se creo una terza stringa
String a3 = "pippo";
if(a==a3){
System.out.println("uguali);
}
else{
System.out.println("diverse");
}

Mi dice che le due sono uguali.

Qualcuno può chiarirmi questo comportamento?
In particolare scrivendo
a2= new String("pippo");
a cosa punta a2?

[Freaxxx]

ti mancano 2 concetti per capire il tutto:
- il concetto di "string literal pool"
- cosa faccia l'operatore new

in Java, come in molti altri linguaggi, scrivi il tuo sorgente, quando finisci lo mandi in compilazione per crearti, nel caso specifico di Java, del bytecode, molto semplice.

Ora c'è una cosa che Java, o meglio javac, fa in automatico, cioé effettua il parsing del tuo codice e se trova delle stringhe, cioé delle parole, delle frasi, le include in un "pool" appunto lo "string literal pool", se la stringa si ripete 2, 3, 10 volte nel tuo codice, comparirà sempre 1 volta nel pool ma verrà soltanto referenziata 2-3-10 volte; cioé Java sfrutta tantissimo meccanismi di referenziazione, passaggi di idirizzi interni alla JVM se vogliamo metterla così, piuttosto che occupare memoria per 10 stringhe tutte uguali, ne conserva 1 copia nel pool e quelle 10 stringhe sono in realtà un riferimento a quella presente nel pool.

Questo è quanto avviene secondo automatismi propri di Java riguardo le costanti stringa.

Quando usi new tu imponi a Java di fare principalmente 2 cose:
- usare il costruttore per il tipo specificato alla destra dell'operatore new
- creare forzatamente 1 nuovo oggetto del tipo di cui sopra e mantenerne il riferimento

quando tu scrivi 20 volte nel tuo codice
"Ciao forum"
, in una println() o dove ti pare, ma comunque tra doppi apici, ovvero come costante, java usa il suo automatismo e i suoi meccanismi di referenziazione, ovvero la "tecnica del pool", ma nel momento in cui scrivi
new String("Ciao forum")
Java è "forzato" ad allocare 1 nuovo oggetto di tipo String creato tramite un metodo costruttore che accetti come input una stringa; quindi anche se nel tuo codice vedrai scritto 21 volte "Ciao forum", in realtà ci saranno 20 riferimenti che punteranno ad una unica stringa nel pool, ma la 21esima stringa sarà un oggetto allocato a parte che nulla avrà a che fare con il pool e che sarà un oggetto come gli altri, cioé creato tramite un metodo costruttore e con un preciso stato.

[Floris]

Le stringhe create con la notazione "..." hanno un nome...che non ricordo e seguono una logica diversa di allocazione in memoria rispetto alle stringhe create con il costruttore della classe String.
Con == stai testando l'uguaglianza del reference...non del contenuto. Per testare l'uguaglianza del contenuto di oggetti devi usare equals. E' corretto che a ed a3 siano ugual nel senso di ==...poichè il litterale "pippo" risiede in un'area di memoria a cui entrambe puntano. new String("pippo") invece risiede in un'area di memoria diversa.
Se dopo riesco cerco dove lo avevo letto che era (ovviamente) spiegato meglio. Comunque prova a fare qualche ricerca sulla differenza tra stringhe create con "" e con new String().

[Player1]

Ok, grazie ad entrambi, ho capito qual'è la gestione delle stringhe.
Già che ci sono vi faccio un paio di domande sugli interi..

Se scrivo
int a = 1;
a punta ad un oggetto contenente il valore 1 o contiene direttamente il valore 1?
e se scrivo
Integer b = new Integer(1)?
In questo caso sicuramente b punterà ad un oggetto contenente il valore 1.

Perchè allora si verifica questo?
int a = 1;
Integer b = new Integer(1);
Integer c = new Integer(1);
if (a==b){
System.out.println("a = b");
}
else{
System.out.println("a e b sono diversi");
}
if (b==c){
System.out.println("b = c");
}
else{
System.out.println("b e c sono diversi");
}
if (c==a){
System.out.println("c = a");
}
else{
System.out.println("a e c sono uguali");
}


L'esecuzione di questo codice mi da il seguente risultato (matematicamente errato):

a = b
b e c sono diversi
c = a

Perché a==b mi restituisce true?
Se int a contiene direttamente il valore 1 allora dovrebbe essere diverso da b che invece contiene un puntatore all'oggetto contenente 1.
Se al contrario int contiene un puntatore all'oggetto contenente 1 suppongo sia comunque un oggetto diverso dall'oggetto a cui punta b visto che per b ho utilizzato la parola chiave new e quindi i due oggetti contenenti il valore 1 dovrebbero comunque essere diversi.

[Freaxxx]

Ok, grazie ad entrambi, ho capito qual'è la gestione delle stringhe.
Già che ci sono vi faccio un paio di domande sugli interi..

Se scrivo

a punta ad un oggetto contenente il valore 1 o contiene direttamente il valore 1?
e se scrivo
?
In questo caso sicuramente b punterà ad un oggetto contenente il valore 1.

Perchè allora si verifica questo?


L'esecuzione di questo codice mi da il seguente risultato (matematicamente errato):

a = b
b e c sono diversi
c = a

Perché a==b mi restituisce true?
Se int a contiene direttamente il valore 1 allora dovrebbe essere diverso da b che invece contiene un puntatore all'oggetto contenente 1.
Se al contrario int contiene un puntatore all'oggetto contenente 1 suppongo sia comunque un oggetto diverso dall'oggetto a cui punta b visto che per b ho utilizzato la parola chiave new e quindi i due oggetti contenenti il valore 1 dovrebbero comunque essere diversi.

int a
è la dichiarazione per la creazione di una variabile a di tipo primitivo uguale ad int

Integer
è un tipo di dato, una classe, e non è quindi un tipo di dato primitivo

ciò che avviene in questo caso è spiegato dai meccanismi di boxing e unboxing, ricorda comunque l'uso dell'operatore di confronto == unitamente alle sole etichette delle varie variabili e dei vari oggetti può dar luogo a situazioni logicamente errate e non è la strada migliore, inoltre con la sola etichetta, nella semantica dei riferimenti, si indica il riferimento ( l'indirizzo ) all'oggetto e non il suo valore.

guardati boxing, unboxing, tipi primitivi, semantica dei valori e semantica dei riferimenti/indirizzi.

[Floris]

Come dice Freaxxx quando si mischiano e confrontano tipi primitivi ed oggetti le cose possono diventare strane. Sarebbe preferibile usare sempre e solo oggetti ovvero Integer. Purtroppo Java non é un linguaggio ad oggetti puro poichè contiene ad esempio tipi che non sono oggetti. Inoltre i refrence possono creare problemi di interferenza. Come diceva un mio professore:
Dire che in Java non ci sono i puntatori è come nascondere un camion a rimorchio sotto ad una coperta.
:D :D :D
A parte tutto, sul momento non saprei dirti il perchè di quell'output. Bisognerebbe guardare alla specifica sematica di == quando un membro è un tipo primitivo e l'altro è un oggetto. Probabilmente, come suggerisce Freaxxx, il compilatore aggiunge una conversione implicita richiamando il metodo intValue di Integer. Ovvero a == b diventa qualcosa del tipo a == b.intValue().

Ricordati comunque che conviene usare sempre il metodo equals per effettuare confronti.

[GByTe87]

Edit... mi ero perso un po' di reply. :fagiano: