java 中的 (Integer)y 和 new Integer(y) 有什么区别？

Question

以下有什么区别:

Integer in = (Integer)y;

和

Integer in = new Integer(y);

我想将 int 类型转换为 Integer 类型，反之亦然。这是我的代码：

public class CompareToDemo {

  public static void main(String[] args) {
    // Integer x=5;
    int y=25;

    System.out.println(y+" this is  int variable");

    Integer in = (Integer)y;

    //Integer in = new Integer(y);

    if(in instanceof Integer){
      System.out.println(in +" this is Integer variable");
    }
  }
}

Answer 1

简而言之，

第 Integer in = (Integer)y; 行使用了不必要的转换。
行 Integer in = new Integer(y); 创建了一个 Integer 实例。

每例详解

首先，让我们考虑显式转换的情况。

Integer i = (Integer)10;

编译器理解 10 是一个 int 原始类型，并且它必须被其 Integer 包装才能编译。看来 javac 会做以下事情：

Integer i = (Integer)Integer.valueOf(10);

但编译器足够聪明，可以进行不必要的强制转换，(Integer) 将被省略：

Integer i = Integer.valueOf(10);

接下来是创建实例的情况

Integer i = new Integer(10);

这里简单介绍一下。无论如何都会创建一个 Integer class 的新实例。但是，正如文档所说，通常情况下，这是不合适的方式：

It is rarely appropriate to use these constructors. The static factories valueOf() are generally a better choice, as it is likely to yield significantly better space and time performance.

结论

在日常代码编写中，我们通常使用autoboxing and unboxing。它们是原始类型和它们对应的对象包装器 classes 之间的自动转换（已在 Java 5 中引入）。所以你不必考虑 Xxx.valueOf(xxx) 和 .xxxValue() 方法。太方便了吧？

Integer i = 10; // autoboxing
int j = i; // unboxing

Answer 2

对于 java 中的每个 primitive type，都有一个对应的包装器 class。您可以在这些原始类型和相应的包装器之间进行转换 class。这称为 装箱和拆箱 。当你写

Integer in = (Integer)y; //this is unnecessary casting

或

Integer in = new Integer(y); //create a new instance of Integer class

您主要是在原始类型和包装器之间进行转换 class。但是 Java 有一个叫做 Auto Boxing and Unboxing 的功能，其中 java 会为你做这些转换。只写

int iPrimi = 20;
Integer iWrapper = iPrimi; //Autoboxing 
int iPrimi2 = iWrapper; //Auto unboxing

自动装箱和拆箱会降低性能。 Primitives seems to be 2-3 times faster then it’s Integer equivalent。因此，如果不需要，请不要使用它们。

Answer 3

如果您只想将 int 基元转换为 Integer 对象，你有四个选择

   Integer in = (Integer)y;         // 1 explicit cast
   Integer in = y;                  // 2 implicit cast (autoboxing)
   Integer in = new Integer(y);     // 3 explicit constructor
   Integer in = Integer.valueOf(y); // 4 static factory method

这里最可取的方法是 2（自动装箱）。显式构造函数 (3) 不太可取，因为它可能会对性能造成一些小的影响。

另外，它们并不严格等价。考虑：

public static void main(String[] args) {
    int x = 25;
    Integer a = new Integer(x);
    Integer b = new Integer(x);
    System.out.println(a == b);     // false
    Integer c = Integer.valueOf(x);
    Integer d = Integer.valueOf(x);
    System.out.println(c == d);     // true
    Integer e = (Integer)x;
    Integer f = (Integer)x;
    System.out.println(e == f);     // true
}

这是因为缓存了小整数 (details here)。

java 中的 (Integer)y 和 new Integer(y) 有什么区别？

What is the difference between (Integer)y and new Integer(y) in java?

java

autoboxing

unboxing