Java/Tipi di dato: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
→Differenze con il C++: + link |
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.
====
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 ==▼
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.
String s1 = "stringa1";▼
String s2 = "stringa2";▼
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.
//mostrerà "Ciao, amico, come va? Spero bene"▼
System.out.println(s1+", amico, "+s2+" spero bene");▼
▲== 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
*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">
</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]]
|