这里使用java8的stream来进行转化，详细步骤如下所示：
//初始化int数组
int[] nums = {1,2,3,4,5,6};
//将int数组转换为数值流
IntStream stream = Arrays.stream(nums);
//流中的元素全部装箱，转换为Integer流
Stream<Integer> integerStream = stream.boxed();
//将流转换为数组
Integer[] integers = integerStream.toArray(Integer[]::new);上面是分解步骤，实际应用中一行代码即可解决
Integer newNums[] = Arrays.stream(nums).boxed().toArray(Integer[]::new);
Autoboxing is the automatic conversion that the Java compiler makes between the primitive types and their corresponding object wrapper classes. For example, converting an int to an Integer, a double to a Double, and so on. If the conversion goes the other way, this is called unboxing.
自动装箱（拆箱也是）是 Java 编译器提供的原始类型和它的包装类之间转化的功能。
注意，自动装箱和拆箱是 Java 编译器的功能，并不是运行时的。
int 转 Integer：
List<Integer> li = new ArrayList<>(); for (int i = 1; i < 50; i += 2) li.add(i); // Java 编译器把上面的代码转换成了下面的样子 List<Integer> li = new ArrayList<>(); for (int i = 1; i < 50; i += 2) li.add(Integer.valueOf(i));
反过来，Integer 转 int：
public static int sumEven(List<Integer> li) {
int sum = 0;
for (Integer i: li)
if (i % 2 == 0)
sum += i;
return sum;
}
// 编译器把上面的代码转化成了下面的样子
public static int sumEven(List<Integer> li) {
int sum = 0;
for (Integer i : li)
if (i.intValue() % 2 == 0)
sum += i.intValue();
return sum;
}Java 中 int 和I nteger 互转，原理是 Java 编译器帮你调用了包装类的 valueOf() 和 intValue() 两个方法。
所有整型包装类对象之间的比较全部使用 equals 方法比较。
对于 Integer var = ? 在 -128 至 127 范围内的赋值，Integer 对象是在 IntegerCache.cache 产生，会复用已有对象，这个区间内的 Integer 值可以直接使用 == 进行判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象，所以推荐使用 equals 方法进行判断。
IntegerCache 为 Integer 类的缓存类，默认缓存了 -128~127 的 Integer 值，如遇到 [-128,127] 范围的值需要转换为 Integer 时会直接从 IntegerCache 中获取，具体如以下源码：
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}当大于这个范围的时候，直接 new Integer 来创建 Integer 对象。
new Integer(1) 和 Integer a = 1 ，前者创建对象，存储在堆中，而后者是从 IntegerCache 中获取的。那么 Integer a = 128, 直接通过 new Integer（128）创建对象，进行装箱。
Integer i = new Integer(128); Integer j = 128; // 自动装箱 i == j; // false // == 比较对象的地址是不是相同 i.equals(j); // true Integer i = new Integer(127); Integer j = 127; i == j; // false i.equals(j); // true Integer i = 128; Integer j = 128; i == j; // false i.equals(j); // true Integer i = 127; Integer j = 127; i == j; // true i.equals(j); // true
当你需要产生一个整形的包装类的实例的时候（比如整数10），有两种方式：
Integer i = new Integer（10）；// 已过时，且标记为待删除。 Integer i = Integer.valueOf(10);
当你用第一种方式时每次都会产生一个新的实例，而当你使用静态工厂方法时，你产生的数是 -128 到127时，不会 new 一个新的对象，超过这个范围时，同样是 new 一个新的对象。
java.lang.Integer @Deprecated(since = “9”) @Contract(pure = true)
It is rarely appropriate to use this constructor. The static factory valueOf(int) is generally a better choice, as it is likely to yield significantly better space and time performance.
最后一句不是说了吗，有更好的空间和时间性能，你用 new 也没事。
@HotSpotIntrinsicCandidate
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}上面是 valueOf, 当你传入小于 128 的值时，返回的是内置的缓存值，节省空间和效率。
java 提供了两种类型：int 是 java 的原始数据类型，Integer 是 java 为 int 提供的封装类（引用类型）。
1、Integer 默认值是 null，而 int 默认值是 0；
2、声明为 Integer 的变量需要实例化，而声明为 int 的变量不需要实例化；
3、Integer 是对象，用一个引用指向这个对象；而 int 是基本类型，直接存储数值。
4、Int 类型是放在栈空间的，Integer 是作为对象放在堆空间的。
int 到 Integer:
int a = 66; // Integer A = new Integer(a); Integer A = Integer.valueOf(a); Integer 到 int: Integer A = Integer.valueOf(66); int a = A.intValue();
String 类型转为 int 类型:
Integer.parseInt(String str) // String 类型转为 int 类型。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持。
