Eine kurze Einführung in das automatische Unboxing in Java

In diesem Artikel werden hauptsächlich die relevanten Informationen zum automatischen Unboxing von Java ausführlich vorgestellt, die einen gewissen Referenzwert haben.

Während des Interviewprozesses gibt es oft Wenn der Interviewer grundlegende Fragen stellt, Er wird nach dem Entpacken von Java fragen. Diese Frage ist eigentlich nicht schwierig, aber wenn Sie während des Selbststudiums nicht aufpassen, kann es sein, dass Sie verwirrt sind. Daher wird der Autor diese Frage zusammenfassen !

1. Das Konzept des Unboxings

Das sogenannte Unboxing ist der Unterschied zwischen Javas Grundtypen und Referenztypen seit JDK1.5.

1.1 Unboxing

Unboxing ist die Konvertierung von Long-, Integer-, Double-, Float- und anderen entsprechenden Referenztypen mit Großbuchstaben des ersten Buchstabens des Basisdatentyps Auspacken.

1.2 Boxen

Boxen bedeutet Byte, Int, Short, Long, Double, Float, Boolean, Char. Diese grundlegenden Datentypen von Java werden bei der Definition des Datentyps nicht als entsprechend deklariert Der Vorgang der automatischen Konvertierung eines Referenztyps in einen Referenztyp während der Verarbeitung durch den Compiler wird als Boxen bezeichnet.

2. Verwandte Anwendungen des Unboxings

Nach JDK1.5 wird es praktisch sein, wenn wir Basistypen und Referenztypen konvertieren:

package com.hzp.CZX;
/**
 * 测试拆装箱
 * @author 夜孤寒
 * @version 1.1.1
 */
public class TestDemo {
  /**
   * 拆装箱JDK1.5后
   */
  public static void first(){
    Integer i=7;//基本类型-->引用类型
    int j=i;//引用类型-->基本类型
    System.out.println(j);
  }
  /**
   * 拆装箱JDK1.4
   */
  public static void second(){
    Integer i=new Integer(78);
    int j=i.intValue();
    System.out.println(j);
  }
  /**
   * 测试方法
   * @param args
   */
  public static void main(String[] args) {
    first();
    second();
  }
}

Oben werden einige grundlegende Punkte und Verwendungsmethoden zur Demontagebox vorgestellt, es gibt jedoch einige Vorsichtsmaßnahmen, die bei der Verwendung der Demontagebox beachtet werden müssen, wie folgt. Fassen wir diese wichtigen Punkte zusammen .

3. Notizen

Posten Sie zunächst einen Code wie folgt:

package com.ygh.CZX;
/**
 * 关于java的拆装箱范围剖析
 * @author 夜孤寒
 * @version 1.1.1
 */
public class Test {
  /**
   * 以Integer类型为例
   */
  public static void first(){
    Integer i=new Integer(124);
    Integer j=new Integer(124);
    System.out.println(i==j);//false
    Integer a1=-128;
    Integer a2=-128;
    System.out.println(a1==a2);//true
    Integer b1=-129;
    Integer b2=-129;
    System.out.println(b1==b2);//false
    Integer c1=127;
    Integer c2=127;
    System.out.println(c1==c2);//true
    Integer d1=128;
    Integer d2=128;
    System.out.println(d1==d2);//false
  }
  public static void main(String[] args) {
    first();
    
  }
}

Einfach erklären:

Der Grund, warum das erste Ergebnis falsch ist, liegt darin, dass unterschiedliche Objekte erstellt werden, also sind die beiden unterschiedlich.

Aber warum sind die Ergebnisse des zweiten und drittens unterschiedlich?

Der Quellcode für die Integer-Klasse wird unten veröffentlicht, um dieses Problem aus der Perspektive des Quellcodes zu analysieren:

  /**
   * Returns an {@code Integer} instance representing the specified
   * {@code int} value. If a new {@code Integer} instance is not
   * required, this method should generally be used in preference to
   * the constructor {@link #Integer(int)}, as this method is likely
   * to yield significantly better space and time performance by
   * caching frequently requested values.
   *
   * This method will always cache values in the range -128 to 127,
   * inclusive, and may cache other values outside of this range.
   *
   * @param i an {@code int} value.
   * @return an {@code Integer} instance representing {@code i}.
   * @since 1.5
   */
  public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
      return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
  }

Der obige Code bedeutet Beim Auspacken gibt es einen Bereich, der nicht auf dasselbe Objekt verweist, sondern ein neu erstelltes Objekt zurückgibt. Dieser Bereich kann in IntegerCache, einer internen privaten Klasse in der Integer-Klasse, widergespiegelt werden. Der Quellcode lautet wie folgt:

 private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
      // high value may be configured by property
      int h = 127;
      String integerCacheHighPropValue =
        sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
      if (integerCacheHighPropValue != null) {
        try {
          int i = parseInt(integerCacheHighPropValue);
          i = Math.max(i, 127);
          // Maximum array size is Integer.MAX_VALUE
          h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
        } catch( NumberFormatException nfe) {
          // If the property cannot be parsed into an int, ignore it.
        }
      }
      high = h;

      cache = new Integer[(high - low) + 1];
      int j = low;
      for(int k = 0; k < cache.length; k++)
        cache[k] = new Integer(j++);

      // range [-128, 127] must be interned (JLS7 5.1.7)
      assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
  }

Von hier aus können wir sehen, dass der Bereichswert zwischen [-128.127] liegt.

Beachten Sie, dass die Implementierung der valueOf-Methode der Klassen Integer, Short, Byte, Character und Long ähnlich ist.
Die Implementierung der valueOf-Methode von Double und Float ist ähnlich.

Zusammenfassung: Der Bereich dieser Grundtypen für das automatische Unboxing ist wie folgt:

1. Boolescher Typwert

2. Alle Bytewerte

3 . Der Wert des Typs short liegt zwischen -128 und 127

Der Wert des Typs int liegt zwischen -128 und 127

5 >

und Double und Float sind unterschiedlich. Wir nehmen Double als Beispiel und veröffentlichen die Codediskussion:

package com.ygh.CZX;

/**
 * 关于java的拆装箱范围剖析
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */
public class Test {
  /**
   * Double
   */
  public static void first() {
    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
  }
  /**
   * 测试方法
   */
  public static void main(String[] args) {
    first();
  }
}

Beachten Sie, warum oben. Die Ausgabeergebnisse von Code sind alle falsch? In ähnlicher Weise verwenden wir immer noch die valueOf-Methode in der Double-Klasse, um Folgendes zu besprechen:

  /**
   * Returns a {@code Double} instance representing the specified
   * {@code double} value.
   * If a new {@code Double} instance is not required, this method
   * should generally be used in preference to the constructor
   * {@link #Double(double)}, as this method is likely to yield
   * significantly better space and time performance by caching
   * frequently requested values.
   *
   * @param d a double value.
   * @return a {@code Double} instance representing {@code d}.
   * @since 1.5
   */
  public static Double valueOf(double d) {
    return new Double(d);
  }

Mit anderen Worten, egal in welchem ​​Bereich Ihr Double ist Wert, es gibt Ihnen ein neues Objekt zurück. float ist dasselbe wie double, daher werde ich nicht auf Details eingehen.

Das Obige ist die Anordnung des Autors zum Auspacken. Wenn Leser unterschiedliche Meinungen haben, können sie diese im Kommentarbereich äußern, und der Autor wird Änderungen vornehmen!

Das obige ist der detaillierte Inhalt vonEine kurze Einführung in das automatische Unboxing in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!