Java中Integer和int的区别

在Java中，int是基本数据类型，而Integer是一个Wrapper类。

作为一种原始数据类型，Int的灵活性较低。我们只能存储整数的二进制值。
由于Integer是int数据类型的包装类，因此它在存储、转换和操作int数据方面提供了更大的灵活性。
Integer是一个类，因此它可以调用类中定义的各种内置方法。与其他引用(对象)类型一样，Integer类型的变量存储对Integer对象的引用。

示例:

// Valid
int n = 20;
//valid
Integer n = 45;

// Valid
Integer.parseInt("10");
// Not Valid
int.parseInt("10");

重要的不同点:

强制转换为String变量:不能直接或甚至通过强制转换将String值(只包含整数)赋给int变量。但是，可以使用Integer(String)构造函数将String赋值给Integer类型的对象。我们甚至可以使用parseInt(String)将String字面值转换为int值。

// Java program to illustrate 
    // difference between
    // int and Integer 
      
    public class Main {
        public static void main(String args[])
        {
      
            Integer a = new Integer("123");
            // Casting not possible
            // int a = (int)"123";
            // Casting not possible
            // int c="123";
      
            // Casting possible using methods
            // from Integer Wrapper class
            int b = Integer.parseInt("123");
            System.out.print(a + new Float("10.1"));
        }
    }

输出:

133.1

直接将值转换为其他基数:可以分别使用toBinaryString()、toOctalString()或toHexString()将存储在integer类中的整型值直接转换为二进制、八进制或十六进制格式。这在int类型的变量中是不可能的。

// Java program to illustrate 
    // difference between
    // int and Integer 
      
    public class Main {
        public static void main(String args[])
        {
            String bin = Integer.toBinaryString(123);
            String oct = Integer.toOctalString(123);
            String hex = Integer.toHexString(123);
            System.out.print(bin + "\n" + oct + "\n" + hex);
        }
    }

输出:

1111011
173
7b

对数据执行操作:Integer类还允许我们分别使用reverse()、rotateLeft()和rotateRight()来反转数字或向左或向右旋转。我们需要定义自己的逻辑来对int变量执行这些操作，因为它不是一个内置类。

// Java program to illustrate 
    // difference between
    // int and Integer 
      
    public class Main {
        public static void main(String args[])
        {
            // mainethods convert integer to its binary form,
            // apply the desired operation 
            // and then returns the decimal form
            // of the newly formed binary number
            // (12)10->(1100)2 -> 
            // rotate left by 2 units -> (110000)2->(48)10
            int rL = Integer.rotateLeft(12, 2);
      
            // (12)10->(1100)2 -> 
            // rotate right by 2 units -> (0011)2->(3)10
            int rR = Integer.rotateRight(12, 2);
      
            //(12)10 -> (00000000000000000000000000001100)2 
            // -> reverse ->(00110000000000000000000000000000)2
            // -> (805306368)10
              
            // int is of 32 bits
            int rev = Integer.reverse(12);
            System.out.print("Left Rotate : " + rL 
              + "\nRight rotate : " + rR + "\nReverse : " + rev);
        }
    }

输出:

    Left Rotate : 48
    Right rotate : 3
    Reverse : 805306368

灵活性:整数包装器类为我们提供了对现有int数据类型的更多灵活性。除了预定义的操作符外，还可以对整型值执行许多操作。当需要像对待对象一样对待int变量时，使用Integer类。因为Wrapper类继承Object类，所以它们可以在带有Object引用或泛型的集合中使用。因此，我们将nullability属性添加到现有的int数据类型中。
从Java 5开始，我们就有了自动装箱的概念，其中原始数据类型自动转换为包装器类，反之亦然。因此，我们可以在任何基本数据类型和任何Wrapper类之间执行任何算术或逻辑操作。

// Java program to illustrate
    // auto-boxing
    import java.util.function.Function;
    import java.util.function.Function;
    public class Main {
        public static void main(String args[])
        {
      
            Integer a = new Integer("12");
            Integer d = new Integer("13");
            int b = 2;
            double c = 3.1;
            Double f = new Double("12.1");
            int d2 = a + d;
            System.out.println("Sum of 2 Integer objects :" 
                + (a + d));
            System.out.println("Sum of an Integer object 
                and int value :" + (a + b));
            System.out.println("Sum of an Integer object 
                and double value :" + (a + c));
            System.out.println("Sum of an Integer object 
                and Double object :" + (a + f));
        }
    }

输出:

    Sum of 2 Integer objects :25
    Sum of an Integer object and int value :14
    Sum of an Integer object and double value :15.1
    Sum of an Integer object and Double object :24.1