Compréhension approfondie des types natifs Java et des types de wrapper-javaDidacticiel-php.cn

Résumé :

Cet article fournit une analyse approfondie des types natifs Java et des types de wrapper, impliquant principalement les quatre aspects suivants : principes de base des types natifs et des types wrapper, concepts et types de valeurs littérales, transformation automatique et transformation forcée des types de base, et mécanismes automatiques de boxing et de unboxing.

Points clés :

Types primitifs et types wrapper
Concept de valeur littérale et types
Types de base, transformation automatique et transformation forcée
Mécanisme d'autoboxing et de déballage (Autoboxing et Unboxing)

1. Types primitifs et types de wrapper

Il existe huit types de données de base en Java :

　　　 Compréhension approfondie des types natifs Java et des types de wrapper

Une attention particulière doit être portée aux points suivants :

Entier sans identification du suffixe de caractèrePar défaut, le type int , Nombres à virgule flottante sans identifiant de suffixe de caractère par défaut en double type
Uniquement les quatre types de base byte, char, short, int et leurs classes wrapper (nécessite la prise en charge de Java5.0/1.5 ou supérieur) peuvent être utilisés pour switch instruction (seuls le type enum et le type int peuvent être appliqués au commutateur) , la compilation d'autres types signalera une erreur ;
char (deux octets) peut utiliser des guillemets simples pour représenter un seul caractère (peut être un caractère chinois), tel que :
'Liang', 'A';
Un entier peut être composé de binaire (
commence par 0B/0b), octal ( commence par 0 Entier ), décimal, hexadécimal (Entier commençant par 0x ou 0X ) ; >2. Valeur littérale
Dans le code source Java, la valeur littérale est utilisée pour représenter une valeur fixe. Les valeurs littérales numériques sont les plus courantes. Les valeurs littérales

sont également très courantes et peuvent être considérées comme un type. Bien sûr, le

null

spécial peut également être considéré comme. une valeur littérale. Les valeurs littérales peuvent être grossièrement divisées en

littéraux entiers (littéraux entiers, littéraux longs et littéraux de caractères) , littéraux entiers, Type à virgule flottante valeur littérale (valeur littérale de type double et valeur littérale de type float), Valeur littérale de chaîne, valeurs littérales spéciales quatre types. (1) Valeur littérale entière

　 Les valeurs qui sont formellement des entiers sont classées comme valeurs littérales entières. Par exemple : 10, 100000L,

'B''B', 0XFF Celles-ci peuvent toutes être appelées valeurs littérales entières. Lors de l'utilisation, vous devez faire attention aux points suivants :

Les littéraux entiers peuvent être utilisés en décimal,

hexadécimal

Commence par 0X/0x), Octal(Commence par 0) et Binaire( commence par 0B/0b). Bien entendu, la base ne peut pas dépasser la plage de base Par exemple, 09 est illégal, et la base octale ne peut aller qu'à 7. Généralement, les littéraux créent des types int, mais les littéraux int peuvent être attribués à byte, short, char, long et int.
à condition que la valeur littérale soit dans la plage cible (Java terminera automatiquement la conversion) ; convertir une valeur littérale hors plage Lors de l'attribution à un certain type (par exemple, attribuer 128 au type d'octet), ne peut pas être compilé et nécessite une conversion de type forcée .

byte b0 = 128;      
 // Type mismatch: cannot convert from int to bytebyte b1 = 12;       
 // OKbyte b2 = (byte)300；
 // OK 需要强制转换，但表示的数字是截取后的数字（300二进制为100101100，截取后为00101100，即44）char c0 = 5;       
 // OKchar c1 = char(-3);       
 // 编译通过,但打印值为 ？（char 为无符号的）System.out.println(c1);   
 // ？

Copier après la connexion

Si vous souhaitez créer un type long qui ne peut pas être représenté par le type int, vous devez ajouter L ou l à la fin de la valeur littérale ( il est généralement recommandé d'utiliser un L facilement reconnaissable). Par conséquent, les littéraux entiers incluent les littéraux int et les littéraux longs.
En Java, les littéraux de caractères sont placés entre guillemets simples (appartiennent également aux littéraux entiers) , tels que '@', '1'. Tous les jeux de caractères UTF-16 sont inclus dans les littéraux de caractères. Pour les caractères qui ne peuvent pas être saisis directement, des caractères d'échappement peuvent être utilisés, tels que « n » qui est un caractère de nouvelle ligne. Vous pouvez également utiliser octal ou hexadécimal pour représenter les caractères. Octal est représenté par une barre oblique inverse plus 3 chiffres. Par exemple, « 141 » représente la lettre a. L'hexadécimal est représenté par u plus 4 sous forme de nombre hexadécimal. Par exemple, « u0061 » représente le caractère a. Autrement dit, en utilisant des caractères d'échappement, tous les caractères du clavier, qu'ils soient présents ou non, peuvent être représentés. Les séquences de caractères d'échappement courantes sont :
ddd (octal), uxxxx (caractères Unicode hexadécimaux), ' (guillemet simple), " (guillemet double), (barre oblique inverse) r (caractère de retour chariot) n (saut de ligne) f (formulaire feed) t (tab) b (retour arrière)

(2) Littéral à virgule flottante

　Les littéraux à virgule flottante peuvent être simplement compris sous forme de décimales, divisés en littéraux flottants et littéraux doubles s'ils sont ajoutés après la virgule F ou f signifie qu'il s'agit d'une valeur littérale flottante, telle que 11,8F. . S'il n'y a pas de F/f après la virgule (comme 10.4), ou si D/d est ajouté après la virgule, cela signifie qu'il s'agit d'une valeur littérale double 🎜>

double d1 = 10；     
// OK，自动类型转换double d2 = 11.4;    
// OKdouble d3 = 1.23E3;    
// OK  double d4 = 10D;    
// OK  double d5 = 0.4D;     
// OK float f1 = 10;      
// OK，自动类型转换float f2 = 11.1F;      
// OKfloat f3 = 11.1;      
// Type mismatch: cannot convert from double to float

Copier après la connexion

(3) Caractère et. littéraux de chaîne

Les littéraux de caractères en Java sont placés entre guillemets simples

, tels que '@', '1' all Le jeu de caractères UTF-16 est inclus dans la valeur littérale de caractère. caractères qui ne peuvent pas être saisis directement, des caractères d'échappement peuvent être utilisés, tels que « n » comme caractère de nouvelle ligne. Les caractères peuvent également être représentés en octal ou en hexadécimal, et une barre oblique inverse est utilisée pour l'octal. Le tiret plus 3 chiffres représentent la lettre a. Hexadécimal utilise u plus 4 pour représenter le nombre hexadécimal, tel que « u0061 » représente le caractère a. , peut représenter tous les caractères du clavier, qu'ils soient présents ou non. Les séquences de caractères d'échappement courantes sont : ddd (octal), uxxxx. (caractères Unicode hexadécimaux), ' (guillemet simple), " (guillemets doubles). ), (barre oblique inverse) r (retour chariot) n (saut de ligne) f (saut de page) t (tabulation) b (retour arrière)
　

Valeur littérale de chaîne En utilisant des guillemets doubles, les littéraux de chaîne peuvent également contenir la séquence de caractères d'échappement

dans les littéraux de caractères.

(4) Valeur littérale spéciale

null est un type spécial qui peut être attribué à n'importe quelle référenceTypeVariable , indiquant que cette variable ne fait référence à rien. Si une variable de type référence est nulle, cela signifie que la variable n'est pas disponible. 　

Il existe également un littéral class spécial, qui est représenté par le nom du type plus .class, tel que String.class. Tout d'abord, String est une instance (object) de la classe Class (java.lang.Class), et "This is a string" est une instance de l'objet String de classe. Ensuite, le littéral de classe est utilisé pour représenter un objet de classe Class, par exemple, String.class est utilisé pour représenter un objet String de classe Class. En termes simples, les littéraux de classe sont des valeurs littérales telles que String.class et Integer.class. Ce qu'ils représentent, c'est la classe String et la classe Integer. Si vous imprimez Integer.class, vous obtenez la classe java.lang.Integer. La sortie de List.class est l'interface java.util.List. En résumé, le littéral de classe est utilisé pour représenter le type lui-même .

Une attention particulière doit être portée à :

en littéral numérique Les traits de soulignement peuvent être utilisés dans (à partir du JDK7, un ou plusieurs traits de soulignement peuvent être insérés dans des littéraux numériques (y compris des littéraux entiers et des littéraux à virgule flottante). Cependant, Les traits de soulignement ne peuvent être utilisés que pour séparer les nombres Les traits de soulignement ne peuvent être utilisés que pour séparer les nombres, pas les caractères et les caractères, ni les caractères et les chiffres

int x = 123_456_789；  
// 在编译的时候，下划线会自动去掉。float f = 1.22_3344;  
 //可以连续使用下划线int = _123;  
 // Errorlong = 1_L;  
 // Error

Copier après la connexion

3. Transformation automatique et transformation forcée

1. Transformation automatique

自动转型总原则：byte,short,char(同级)-> int -> long -> float -> double (由低精度到高精度)

(1) 由低精度到高精度的自动转换

具体可分为以下两种情形：

从位数低的类型向位数高的类型转换

    byte b = 1;    char c = 1;    short s = 1;    int i = 1;

    c = b;  // Error，同级
    c = s;  // Error，同级
    s = c;  // Error，同级
    i = c;  // OK

Copier après la connexion

从整型向浮点型的转换———-
从整型向浮点型的转换

    int i = 1；    long t = 1;    float f = 1;    double d = 1;

    f = i;  //  Ok
    f = t;  //  Ok
    d = f;  // Ok

Copier après la connexion

(2) 运算符对基本类型的影响

具体可分为以下两种情形：

1) 当使用 +、-、*、/、%、==、>、< 等等运算符对基本类型进行运算时，遵循如下规则：

　　两个操作数中，先考虑是否有一个是double类型的。如果有，另一个操作数和结果将会被转换成double类型。再依次考虑float,long。除此之外，两个操作数（包括byte、short、int、char）都将会被转换成int类型。

byte b1 = 10 ;  
//OK，会检查发现10没有超过byte类型的最大值byte b2 = 12;   
//OK，会检查发现12没有超过byte类型的最大值byte b = b1 + b2; 
//Error，byte类型在计算时会自动提升为int类型，此时就会报错，因为b1+b2实际上是int类型，但是左侧的变量为byte类型。short s1=1; 
//OK，会检查发现1没有超过short类型的最大值s1=s1+1;    
//Error，因为s1+1 结果int，但左侧变量为 short，报错s1++;      
//OK，不会报错，与s1=s1+1不同！！！，会检查发现2没有超过short类型的最大值s1=1+1;   
//OK，1+1 是个编译时可以确定的常量，&#39;+&#39;运算在编译时就被执行了，而不是在程序执行的时候，这个语句的效果等同于s1=2

Copier après la connexion

2) 当使用 +=、-=、*=、/=、%= 、 i++、 ++i 运算符对基本类型进行运算时，遵循如下规则：

　　运算符右边的数值将首先被强制转换成与运算符左边数值相同的类型，然后再执行运算，且运算结果与运算符左边数值类型相同。自增(减)运算也类似。

short s1=1; // OK，会检查发现1没有超过short类型的最大值short s2;

s1+=1;    // OK，正确，1首先被强制转换为short型，然后再参与运算，并且结果也是short类型s2 = ++s1;     
// OK，正确，s2的值为2

Copier après la connexion

2、强制转型
　　强制转换的格式是在需要转型的数据前加上 “( )”，然后在括号内加入需要转化的数据类型。主要发生于以下两种情形：

由高精度向低精度转换
一种类型到另一种类型转换，则必须使用强制类型转化（同级之间：byte,short,char）

 byte b = 3; int i = 3; long t = 3; float f = 3; char c = 3; short s = 3;

 i = (int) f;  // OK，由高精度向低精度转换
 t = (long) f;  // OK，由高精度向低精度转换
 b = (byte) i;  // OK，由高精度向低精度转换

 i = b; // OK，由低精度向高精度转换，自动转型
 System.out.println(c==s);  // OK，true，c 和 s 自动转型为int,然后比较

 b = (byte) s;  // OK，一种类型到另一种类型转换
 c = (char) b;  // OK，一种类型到另一种类型转换
 c = (char) s;   // OK，一种类型到另一种类型转换

Copier après la connexion

　　特别需要注意的是，强制转换常常会导致二进制位的截取，甚至会导致意想不到的结果：

 int i = 128; byte b = (byte)i;
 System.out.println(b);           // -128(即-0)

Copier après la connexion

四. 自动装箱与拆箱(Autoboxing and Unboxing)

1、什么是装箱？什么是拆箱？

　　Java为每种基本数据类型都提供了对应的包装器类型。在 Java SE5 之前，如果要 创建一个数值为10的Integer对象，必须这样进行：

Integer i = new Integer(10);

Copier après la connexion

　　而从 Java SE5 之后就提供了自动装箱的特性，如果要 创建一个数值为10的Integer对象，只需要这样就可以了：

Integer i = 10;

Copier après la connexion

　　这个过程中会自动根据数值创建对应的 Integer对象，这就是装箱。

　　那什么是拆箱呢？顾名思义，跟装箱对应，就是自动将包装器类型转换为基本数据类型：

Integer i = 10;  //装箱int n = i;   //拆箱

Copier après la connexion

　　简单一点说，装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。

2、装箱和拆箱是如何实现的

　上一小节了解装箱的基本概念之后，这一小节来了解一下装箱和拆箱是如何实现的。我们就以Interger类为例，下面看一段代码：

public class Main {
    public static void main(String[] args) {

        Integer i = 10;        int n = i;
    }
}

Copier après la connexion

反编译class文件之后得到如下内容：　

　　　　　　　　 Compréhension approfondie des types natifs Java et des types de wrapper
　　　　　　　　　　　
　　从反编译得到的字节码内容可以看出，在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。

　　对于其他的包装器类，比如Double、Character，也同样适用。

　　因此，可以用一句话总结装箱和拆箱的实现过程：

　　装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的（xxx代表对应的基本数据类型）。

3、valueOf、xxxValue 方法在JDK中的实现

(1) 在 Byte,Character,Short,Integer,Long 中的实现（以 Integer 为例）

public static Integer valueOf(int i) ： 类方法

public static Integer valueOf(int i) {        
if(i >= -128 && i <= IntegerCache.high)            
return IntegerCache.cache[i + 128];        
else
            return new Integer(i);
            
    }    private static class IntegerCache {
        static final int high;        
        static final Integer cache[];        
        static {                                         
        // 静态代码块  
            final int low = -128;            
            // high value may be configured by property
            int h = 127;            
            if (integerCacheHighPropValue != null) {                
            // Use Long.decode here to avoid invoking methods that
                // require Integer&#39;s autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);                
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;

            cache = new Integer[(high - low) + 1];            
            int j = low;            
            for(int k = 0; k < cache.length; k++)                      
            // 初始化  
                cache[k] = new Integer(j++);
        }        private IntegerCache() {}
    }

Copier après la connexion

　　在装箱时，valueOf方法会被自动调用：如果整型字面值在[-128,127]之间，便返回 IntegerCache.cache（在类加载时就自动创建）中已经存在的对象的引用；否则，创建一个新的Integer对象并返回。

public int intValue()：实例方法

public int intValue() {    return value;
}

Copier après la connexion

　从这段代码可以看出，在拆箱时，Integer对象会自动调用其 intValue 方法，返回该对象对应的 int 值。
　
下面代码可以很好说明这一点：

public class Main {
    public static void main(String[] args) {

        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;

        System.out.println(i1==i2);          // true
        System.out.println(i3==i4);          // false
    }
}

Copier après la connexion

(2) 在 Float, Double 中的实现（以 Double 为例）

public static Double valueOf(double d) ： 类方法

   public static Double valueOf(double d) {        return new Double(d);
    }

Copier après la connexion

　　在装箱时，valueOf方法会被自动调用，从而创建相应的Double对象并返回。

public int intValue()：实例方法

 public double doubleValue() {    return value;
}

Copier après la connexion

　　从这段代码可以看出，在拆箱时，Double对象会自动调用其 doubleValue 方法，返回该对象对应的 double 值。
　　
　　下面代码可以很好说明这一点：

public class Main {
    public static void main(String[] args) {

        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;

        System.out.println(i1==i2);          // false
        System.out.println(i3==i4);          // false
    }
}

Copier après la connexion

　　为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现呢？原因很简单，在某个范围内的整型数值的个数是有限的，而浮点数却不是。

(3) 在 Boolean 中的实现

public static Boolean valueOf(boolean b) ： 类方法

public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);
public static Boolean valueOf(boolean b) {        
return (b ? TRUE : FALSE);
}

Copier après la connexion

　　在装箱时，valueOf方法会被自动调用，从而创建相应的Boolean对象并返回。

public boolean booleanValue()：实例方法

 public boolean booleanValue() {    return value;
    }
}

Copier après la connexion

　　从这段代码可以看出，在拆箱时，Boolean对象会自动调用其 booleanValue 方法，返回该对象对应的 boolean 值。
　　
　　下面代码可以很好说明这一点：

public class Main {
    public static void main(String[] args) {

        Boolean i1 = false;
        Boolean i2 = false;
        Boolean i3 = true;
        Boolean i4 = true;

        System.out.println(i1==i2);          // true
        System.out.println(i3==i4);          // true
    }
}

Copier après la connexion

　总之，

Integer、Short、Byte、Character、Long 这几个类的valueOf方法的实现是类似的，有限可列举，共享[-128,127]；
Double、Float的valueOf方法的实现是类似的，无限不可列举,不共享；
Boolean的valueOf方法的实现不同于以上的整型和浮点型，只有两个值，有限可列举，共享；

4、Integer i = new Integer(xxx) 和 Integer i =xxx;的区别

第一种方式不会触发自动装箱的过程，而第二种方式会触发；
在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下([-128,127])要优于第一种情况（注意这并不是绝对的）。

5、“==”运算符

　　当使用“==”运算符在基本类型和其包装类对象之间比较时，涉及到自动装箱、拆箱机制，遵循如下规则：

　　 1). 只要两个操作数中有一个是基本类型或表达式（即包含算术运算符），就是比较它们的数值是否相等。
　　 2). 否则，就是判断这两个对象的内存地址是否相等，即是否是同一个对象。

// 代码片段1public class Main {    public static void main(String[] args) {

        Integer i01=59;        int i02=59;
        Integer i03=Integer.valueOf(59);
        Integer i04=new Integer(59);

        System.out.println(i01==i02);  // true，拆箱
        System.out.println(i01==i03);  // true，同一对象
        System.out.println(i03==i04);  // false，不同对象
        System.out.println(i02==i04);  // true，拆箱
    }
}

Copier après la connexion

// 代码片段2public class Main {    public static void main(String[] args) {

        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;
        Integer f = 321;
        Long g = 3L;
        Long h = 2L;

        System.out.println(c==d);  // true
        System.out.println(e==f);  // false
        System.out.println(c==(a+b));  // true
        System.out.println(c.equals(a+b));  // true
        System.out.println(g==(a+b));  // true
        System.out.println(g.equals(a+b));  // false
        System.out.println(g.equals(a+h));  // true
    }
}

Copier après la connexion

第一个和第二个输出结果没有什么疑问；
第三个打印语句由于 a+b 包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法），因此它们比较的是数值是否相等；
对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较；
对于g==(a+b)，会分别触发 Integer 和 Long 的自动拆箱过程，然后 int 自动转为 long，进行比较；
对于g.equals(a+b)，最终会归结于 Long对象与Integer对象的比较，由于二者不为同一类型，直接返回 false ;
对于g.equals(a+h)，最终会归结于 Long对象与Long对象的比较，由于 -128

6、小结

使用“==”运算符在基本类型和其包装类对象之间比较时，只要两个操作数中有一个是 基本类型 或 表达式（即包含算术运算符），就是比较它们的数值是否相等。否则，就是判断这两个对象的内存地址是否相等，即是否是同一个对象。
如果一个 方法中参数类型为原生数据类型 ，所传入的参数类型为其封装类对象，则会自动对其进行拆箱；相应地，如果一个方法中 参数类型为封装类型对象 ，所传入的参数类型为其原始数据类型，则会自动对其进行装箱，例如上述的equals方法。

　　至于什么时候装箱，什么时候拆箱主要取决于：在当前场景下，你需要的是引用类型还是原生类型。若需要引用类型，但传进来的值是原生类型，则自动装箱（例如，使用equals方法时传进来原生类型的值）；若需要的是原生类型，但传进来的值是引用类型，则自动拆箱（例如，使用运算符进行运算时，操作数是包装类型）。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!