Java/Tipi di dato: differenze tra le versioni

Contenuto cancellato Contenuto aggiunto
contenuto
Riga 73:
Per i tipi numerici esistono anche le classi [http://download.oracle.com/javase/6/docs/api/java/math/BigInteger.html java.math.BigInteger] e [http://download.oracle.com/javase/6/docs/api/java/math/BigDecimal.html java.math.BigDecimal], le quali, però, non sono considerate classi wrapper. Queste due classi permettono di rappresentare numeri interi o decimali arbitrariamente grandi, uscendo fuori dai limiti imposti sulle dimensioni dei tipi primitivi.
 
==== AutuboxingAutoboxing e unboxing ====
La famiglia dei tipi base e la famiglia dei tipi riferimento sono separate l'una dall'altra: esse definiscono due gerarchie distinte che non hanno alcun punto di giunzione. Per questo motivo, fino alla terza edizione delle specifiche di linguaggio, non erano ammesse conversioni tra tipi primitivi e tipi riferimento, né tramite ''cast'' esplicito, né tramite ''cast'' implicito.
{{...}}
 
Tuttavia, le classi wrapper definite nel package <tt>java.lang</tt> permettono di associare un oggetto a un valore del tipo primitivo corrispondente, e viceversa. Ad esempio, era possibile ottenere un oggetto <tt>Integer</tt> partendo da un <tt>int</tt>, invocando il costruttore [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html#Integer(int) Integer(int)], ed è possibile ottenere il numero intero corrispondente tramite il metodo [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html#intValue() intValue()]. Un discorso analogo vale per ciascuno degli altri tipi primitivi.
== Le stringhe ==
Nel linguaggio Java le stringhe sono degli [[Java/Classi e oggetti|oggetti]].
Esistono molte classi per la gestione delle stringhe. Quelle più comunemente utilizzate sono String (stringhe immutabili, quindi [[Java/Multithreading|thread-safe]]), StringBuffer (stringhe modificabili e [[Java/Multithreading|thread-safe]]) e StringBuilder (stringhe modificabili e non thread-safe; presente dalla versione 1.5 in poi).
 
Queste due operazioni (costruttore e metodo <tt>xxxValue()</tt>) sono di uso frequente dovunque sia necessario un oggetto in luogo di un valore di tipo primitivo; ad esempio, nelle collezioni.
Le stringhe forniscono metodi che permettono di manipolarle, confrontarle e dividerle in parti. Di seguito si riportano i casi più comuni; si rimanda alla [http://download.oracle.com/javase/6/docs/api/java/lang/String.html documentazione ufficiale].
 
Per rendere più semplice e leggibile il codice che richiama queste operazioni, dalla terza versione delle specifiche di linguaggio (Java 5) in poi, è ammesso il ''cast implicito'' di un valore di un tipo primitivo verso il corrispondente tipo wrapper, e viceversa. Il compilatore inserisce automaticamente l'invocazione ai metodi o costruttori sul tipo wrapper utilizzato.
; Creazione di stringhe
<source lang="Java">
String s1 = "stringa1";
String s2 = "stringa2";
String s3;
s3 = "ciao";
</source>
 
Quindi, da Java 5 in poi, è possibile scrivere una istruzione come:
<tt>Integer k = 3;</tt>
invece di:
<tt>Integer k = new Integer(3);</tt>
oppure di:
<tt>Integer k = Integer.valueOf(3);</tt><ref>Il metodo [http://download.oracle.com/javase/6/docs/api/java/lang/Integer.html#valueOf(int) valueOf(int)] è stato introdotto in Java 5.</ref>
in quanto la conversione viene tradotta automaticamente dal compilatore.
 
La conversione da tipo primitivo a tipo wrapper è detta ''autoboxing'',<ref group="fonte">[http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#5.1.7 The Java Language Specification, Chapter 5]</ref><ref group="fonte">[http://download.oracle.com/javase/1.5.0/docs/guide/language/autoboxing.html Java Programming Language, Autoboxing]</ref> mentre la conversione inversa è detta ''unboxing''<ref group="fonte">[http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#5.1.8 The Java Language Specification, Chapter 5]</ref>. Si noti che questi due meccanismi non cambiano il fatto che i tipi primitivi sia '''distinta e separata''' dalla famiglia dei tipi riferimento: essi sono solo zucchero sintattico tradotto dal compilatore in una forma equivalente, ma più lunga da scrivere, perché coinvolge l'invocazione a metodi o costruttori della classe del tipo wrapper in uso.
; Concatenazione
Si usa l'operatore +, che, in questo caso, non ha il suo solito significato aritmetico.
<source lang="Java">
String s1 = "ciao";
String s2 = "come va?";
//mostrerà "Ciao, amico, come va? Spero bene"
System.out.println(s1+", amico, "+s2+" spero bene");
</source>
 
== Le stringhe ==
Una stringa è un'istanza della classe <tt>String</tt>: un oggetto che incapsula una sequenza di caratteri.<br/>
Esistono molte classi per la manipolazione delle stringhe. Quelle più comunemente utilizzate sono definite nel package <tt>java.lang</tt> e sono:
*String (oggetti immutabili, quindi [[Java/Multithreading|thread-safe]]);
*StringBuffer (oggetti modificabili e [[Java/Multithreading|thread-safe]]);
*StringBuilder (oggetti modificabili e non thread-safe; presente dalla versione 1.5 in poi).
 
Le stringhe forniscono metodi che permettono di manipolarle, confrontarle e dividerle in parti. Di seguito si riportano i casi più comuni; per gli altri, si rimandalegga allala [http://download.oracle.com/javase/6/docs/api/java/lang/String.html documentazione ufficiale] della classe String.
; Confronto di due stringhe
 
*La creazione di una stringa avviene tramite l'invocazione dei costruttori (operazione sconsigliata) o tramite uno ''[[Java/Variabili_locali#Valori letterali|string literal]]''.
*La concatenazione di due stringhe si ottiene interponendo tra le due stringhe l'operatore di concatenazione <tt>+</tt>:
<source lang="Java">
String s1 = "stringa1Ciao";
if(s1.equals(s2)) System.out.println("s1 e s2 sono uguali e contengono "+s1);
String s2 = "stringa2come va?";
//mostrerà "Ciao, amico, come va? Spero bene"
System.out.println(s1+", amico, "+s2+" spero bene");
</source>
*Il confronto di stringhe avviene tramite il metodo <tt>equals</tt> (confronto ''case-sensitive'' con un altro oggetto String), uno dei metodi <tt>equalsIgnoreCase</tt> (confronto ''case-insensitive'' con altro oggetto String), uno dei metodi <tt>contentEquals</tt> (confronto ''case-sensitive'' con oggetto di altra classe).
 
:'''Nota''': le stringhe si confrontano con il metodo ''equals'', ''non'' con l'operatore <code><nowiki>==</nowiki></code>. Infatti, due stringhe possono essere uguali pur essendo contenute da due oggetti diversi:
<tt>String s = new String("Ciao");</tt>
<tt>String t = new String("Ciao");</tt>
<tt>assert s.equals(t); // true</tt>
<tt>assert s == t; // false</tt>
 
Line 121 ⟶ 130:
System.out.println(s1.length());
</source>
 
 
== Note ==
; Note esplicative
<references/>
; Fonti
<references group="fonte"/>
 
[[Categoria:Java|Tipi di dati]]