Java 기본 유형 및 래퍼 유형에 대한 심층적인 이해

추상:

이 문서에서는 주로 다음과 관련된 Java 기본 유형 및 래퍼 유형에 대한 심층 분석을 제공합니다. 다음 네 가지 측면: 기본 유형 및 래퍼 유형의 기본, 리터럴 값의 개념 및 유형, 기본 유형의 자동 변환 및 강제 변환, 자동 boxing 및 unboxing 메커니즘.

---

핵심 사항:

• 기본 유형 및 래퍼 유형

• 리터럴 값 개념 및 유형

• 기본 유형, 자동 변환 및 강제 변환

• Autoboxing 및 Unboxing 메커니즘(Autoboxing 및 Unboxing)

---

1. 기본 유형 및 래퍼 유형

Java에는 8가지 기본 데이터 유형이 있습니다.

　　　　

다음 사항에 특별한 주의를 기울여야 합니다.

• 문자 접미사 식별이 없는 정수기본값은 int 유형입니다. , 문자 접미사 식별자가 없는 부동 소수점 숫자는 기본적으로 double 유형

• 4가지 기본 유형만 byte, char, short, int 및 해당 래퍼 클래스(Java5.0/1.5 이상 지원 필요)를 switch 문 (enum 유형과 int 유형만 스위치에 적용 가능) , 다른 유형을 컴파일하면 오류가 보고됩니다.

• char(2바이트)는 작은따옴표를 사용하여 단일 문자(한자일 수 있음)를 나타낼 수 있습니다. 예:

  'Liang' ' A';

• 정수는 2진수(

  는 0B/0b로 시작), 8진수()로 구성될 수 있습니다. 0으로 시작하는 정수 ), 10진수, 16진수(0x 또는 0X로 시작하는 정수 ); >2. 리터럴 값

  Java 소스 코드에서는 리터럴 값을 사용하여 고정된 값을 나타냅니다. 숫자 리터럴 값이 가장 일반적입니다.
String

리터럴 값도 매우 일반적이며 하나의 유형으로 간주할 수 있습니다. 물론 특수한

---

null

도 다음과 같이 간주할 수 있습니다. 리터럴 값. 리터럴 값은 크게

정수 리터럴(int 리터럴, long 리터럴, 문자 리터럴) , 정수 리터럴, 부동 소수점 형식 리터럴 값(이중 유형 리터럴 값 및 float 유형 리터럴 값), 문자열 리터럴 값, 특수 리터럴 값 ​​ 4가지. (1) 정수 리터럴 값　 형식적으로 정수인 값은 정수 리터럴 값으로 분류됩니다. 예: 10, 100000L,

---

'B'

'B', 0XFF 이것들은 모두 정수 리터럴 값이라고 부를 수 있습니다. 사용 시 다음 사항에 주의해야 합니다.

정수 리터럴은 십진수, 16진수

(

에서 사용할 수 있습니다.
• 0X/0x로 시작

  ), 8진수(0으로 시작) 및 2진수(은 0B/0b로 시작합니다. 물론 베이스는 베이스 범위를 초과할 수 없습니다. 예를 들어 09는 불법이고 8진수는 7에만 도달할 수 있습니다. 일반적으로 리터럴은 int 유형을 생성하지만 int 리터럴은 byte, short, char, long 및 int에 할당될 수 있습니다.

  물론
• 리터럴 값이 대상 범위 내에 있는 경우(Java는

  자동으로 변환을 완료합니다) ; 범위를 벗어난 리터럴 값 변환 특정 유형에 할당할 때(예: 바이트 유형에 128 할당) 을 컴파일할 수 없으며 강제 유형 변환 이 필요합니다.

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);   
 // ？

• int 타입으로 표현할 수 없는 long 타입을 생성하려면 리터럴 값 끝에 L 또는 l을 추가해야 합니다( 일반적으로 쉽게 구별할 수 있는 L을 사용하는 것이 좋습니다. 따라서 정수 리터럴에는 int 리터럴과 long 리터럴이 포함됩니다.

• Java에서 문자 리터럴은 작은따옴표로 묶입니다(정수 리터럴에도 속함). , 예: '@', '1'. 모든 UTF-16문자 세트는 문자 리터럴에 포함됩니다. 직접 입력할 수 없는 문자의 경우 줄 바꿈 문자인 'n'과 같은 이스케이프 문자를 사용할 수 있습니다. 8진수나 16진수를 사용하여 문자를 나타낼 수도 있습니다. 8진수는 백슬래시와 3자리 숫자로 표시됩니다. 예를 들어 '141'은 문자 a를 나타냅니다. 16진수는 u에 4를 더한 16진수 숫자로 표시됩니다. 예를 들어 'u0061'은 문자 a를 나타냅니다. 즉, 이스케이프 문자를 사용하면 키보드의 문자 유무에 관계없이 모든 문자를 표현할 수 있습니다. 일반적인 이스케이프 문자 시퀀스는 다음과 같습니다.
  ddd(8진수), uxxxx(16진수 유니코드 문자), '(작은따옴표), "(큰따옴표), (백슬래시) r(캐리지 리턴 문자) n(줄 바꿈) f(형식) 피드) t(탭) b(백스페이스)

---

(2) 부동 소수점 리터럴

　부동 소수점 리터럴은 간단하게 이해하면 됩니다. 소수점으로, 부동 리터럴과 이중 리터럴으로 나누어집니다. 소수점 뒤에 추가되면 F 또는 f는 11.8F와 같은 부동 소수점 리터럴 값임을 의미합니다. . 소수점 뒤에 F/f가 없거나(예: 10.4) 소수점 뒤에 D/d가 추가되면 이는 이중 리터럴 값임을 의미합니다.

---

(3) 문자 및 문자열 리터럴.

　

Java의 문자 리터럴은 작은따옴표로 묶입니다(예: 모든 UTF에 대해 -16 문자 세트가 문자 리터럴 값에 포함됩니다. 직접 입력할 수 없는 문자는 이스케이프 문자를 사용할 수 있습니다. 예를 들어 '141'과 같이 8진수 또는 16진수를 사용하여 문자를 표현할 수도 있습니다. 문자 a를 나타냅니다. 16진수는 u에 4를 더하여 16진수를 나타냅니다. 예를 들어 'u0061'은 문자 a를 나타냅니다. 즉, 키보드에 있거나 없는 모든 문자를 나타낼 수 있습니다. 일반적인 이스케이프 문자 시퀀스는 다음과 같습니다. ddd(8진수), uxxxx(16진수 유니코드 문자), '(작은따옴표), "(큰따옴표), (백슬래시) r(캐리지 리턴) n(줄 바꿈) f(폼 피드) ) t(탭) b(백스페이스)

　

문자열 리터럴에 double 사용 따옴표, 문자열 리터럴은 문자 리터럴에 이스케이프 문자 시퀀스 를 포함할 수도 있습니다.

---

(4) 특수 리터럴 값

　

null은 모든 참조Type변수에 할당할 수 있는 특수 유형입니다. , 이 변수는 아무 것도 참조하지 않음을 나타냅니다. 참조형 변수가 null이면 해당 변수를 사용할 수 없다는 의미입니다.

　

String.class와 같이 유형 이름과 .class로 표시되는 특수 class 리터럴도 있습니다. 우선 String은 클래스 Class(java.lang.Class)의 인스턴스(object)이고 "This is a string"은 인스턴스입니다. String 객체 클래스의 것입니다. 그런 다음 클래스 리터럴은 Class 클래스의 개체를 나타내는 데 사용됩니다. 예를 들어 String.class는 Class 클래스의 개체 String을 나타내는 데 사용됩니다. 간단히 말해서 클래스 리터럴은 String.class 및 Integer.class와 같은 리터럴 값입니다. 이들이 나타내는 것은 String 클래스와 Integer 클래스입니다. Integer.class를 인쇄하면 java.lang.Integer 클래스를 얻게 됩니다. List.class의 출력은 인터페이스 java.util.List입니다. 요약하면 클래스 리터럴은 유형 자체를 나타내는 데 사용됩니다.

---

다음 사항에 특별한 주의를 기울여야 합니다.

• in

  숫자 리터럴 에서는 밑줄 을 사용할 수 있습니다. (JDK7부터는 숫자 리터럴(정수 리터럴 및 부동 소수점 리터럴 포함)에 하나 이상의 밑줄을 삽입할 수 있습니다. 단, 밑줄은 숫자를 구분하는 데만 사용할 수 있습니다. 밑줄은 숫자만 구분하는 데 사용할 수 있으며 문자와 문자, 문자와 숫자는 사용할 수 없습니다.); >3. 자동변환과 강제변환

  1. 자동변환

自动转型总原则：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

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

• 从整型向浮点型的转换

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

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

---

(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 是个编译时可以确定的常量，'+'运算在编译时就被执行了，而不是在程序执行的时候，这个语句的效果等同于s1=2

---

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

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

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

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

---

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，一种类型到另一种类型转换

---

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

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

---

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

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

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

Integer i = new Integer(10);

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

Integer i = 10;

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

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

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

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

---

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

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

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

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

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

　　　　　　　　
　　　　　　　　　　　
　　从反编译得到的字节码内容可以看出，在装箱的时候自动调用的是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() {}
    }

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

• public int intValue()：实例方法

public int intValue() {    return value;
}

　从这段代码可以看出，在拆箱时，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
    }
}

---

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

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

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

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

• public int intValue()：实例方法

 public double doubleValue() {    return value;
}

　　从这段代码可以看出，在拆箱时，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
    }
}

　　为什么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);
}

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

• public boolean booleanValue()：实例方法

 public boolean booleanValue() {    return value;
    }
}

　　从这段代码可以看出，在拆箱时，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
    }
}

---

　总之，

• 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，拆箱
    }
}

---

// 代码片段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
    }
}

• 第一个和第二个输出结果没有什么疑问；

• 第三个打印语句由于 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方法时传进来原生类型的值）；若需要的是原生类型，但传进来的值是引用类型，则自动拆箱（例如，使用运算符进行运算时，操作数是包装类型）。

위 내용은 Java 기본 유형 및 래퍼 유형에 대한 심층적인 이해의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!