Une brève introduction au déballage automatique en Java

Cet article présente principalement en détail les informations pertinentes sur le déballage automatique Java, qui ont une certaine valeur de référence. Les amis intéressés peuvent s'y référer

Pendant le processus d'entretien, il y a souvent des moments où l'intervieweur pose des questions de base, il posera des questions sur le déballage de Java. Cette question n'est en fait pas difficile, mais si vous n'y prêtez pas attention pendant l'auto-apprentissage, vous pourriez être confus, alors l'auteur fera quelques recherches sur cette question, faisons la promotion ensemble. !

1. Le concept de unboxing

Le soi-disant unboxing est la différence entre les types de base de Java et les types de référence depuis JDK1.5.

1.1 Unboxing

Le déballage est l'action de convertir Long, Integer, Double, Float et autres types de référence correspondants avec la première lettre du type de données de base en majuscule en types de données de base. déballage.

1.2 Boxing

Boxing signifie byte, int, short, long, double, float, boolean, char. Ces types de données de base de Java ne sont pas déclarés comme correspondants lors de la définition du type de données. L'action de convertir automatiquement un type référence en type référence sous le traitement du compilateur est appelée boxe.

2. Applications associées du unboxing

Après JDK1.5, ce sera pratique lorsque nous convertirons les types de base et les types de référence :

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();
  }
}

Ce qui précède présente quelques points de base et méthodes d'utilisation concernant la boîte de démontage, mais il y a quelques précautions à prendre lors de l'utilisation de la boîte de démontage, comme suit Résumons ces points d'attention .

3. Notes

Publiez d'abord un morceau de code comme suit :

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();
    
  }
}

Expliquez simplement :

La raison pour laquelle le premier résultat est faux est que des objets différents sont créés, donc les deux sont différents

Mais pourquoi les résultats du deuxième et du troisième sont-ils différents ?

Le code source de la classe Integer est publié ci-dessous pour analyser ce problème du point de vue du code source :

  /**
   * 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);
  }

Le code ci-dessus signifie automatiquement lors du déballage, il y a une plage. Une fois qu'elle dépasse cette plage, elle ne pointera pas vers le même objet, mais renverra un objet nouvellement créé. Cette plage peut être reflétée dans IntegerCache, une classe privée interne dans la classe Integer. Sortez, le code source est le suivant :

 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() {}
  }

De là, nous pouvons voir que la valeur de la plage est comprise entre [-128,127].

Notez que l'implémentation de la méthode valueOf des classes Integer, Short, Byte, Character et Long est similaire.
L'implémentation de la méthode valueOf de Double et Float est similaire.

Résumé : La plage de ces types de base pour le déballage automatique est la suivante :

1. Valeur de type booléen

Toutes les valeurs d'octets

3. .La valeur du type court entre -128~127

4. La valeur du type int entre -128~127

5 La valeur du type char entre u0000~ u00ff La valeur <🎜. >

et double et float sont différents, nous prendrons double comme exemple et publierons la discussion sur le code :

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();
  }
}

Notez pourquoi ci-dessus Les résultats de sortie du les codes sont tous faux ? De même, nous utilisons toujours la méthode valueOf dans la classe Double pour discuter. La publication du code source le précisera :

  /**
   * 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);
  }

C'est-à-dire, quoi qu'il arrive. la portée de votre double est valeur, elle vous renvoie un nouvel objet. float est la même chose que double, donc je n'entrerai pas dans les détails.

Ce qui précède est la disposition de l'auteur de la boîte de déballage. Si les lecteurs ont des opinions différentes, ils peuvent les faire valoir dans la zone de commentaire, et l'auteur apportera des modifications !

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!