The first thing to be clear about is that since Integer is a wrapper for int, it must be possible to store Integer values just like int. Interested students can look at the source code.

The Integer class defines a private field value that holds an Integer value. The wrapper class encapsulates various operations around this value:

Create an object

Integer i1 = 21;
Integer i2 = Integer.valueOf("21");
Copy the code

Automatic unpacking The so-called “unpacking” refers to the process that the packaging type is converted to the basic type, and the so-called “packing” is the process that the basic type is converted to the packaging type.

Integer integer = new Integer(21);/ / packing
int num = integer.intValue();/ / split open a case
Copy the code

Since the introduction of auto-unboxing in JDK1.5, the above code can be simplified as follows:

Integer integer = 21;/ / packing
int num = integer;/ / split open a case
Copy the code

So let’s analyze it.

Automatic packing Integer Integer = 21; An object of type Integer cannot be assigned a primitive value directly. An Integer holds a memory address. 21 automatically encapsulates an object and assigns the address of this object to integer. This object is automatically created and automatically boxed. Integer Integer = integer.valueof (21);

Int num = integer; Define a variable of type int. Num should store a value directly. Integer holds a memory address. Integer automatically fetches the value from the object and assigns the value to NUM. Int num = integer.intValue();

Unboxing requires method calls and consumes resources, so we should try to avoid a lot of unboxing operations in our programs.

Be careful of null values for automatic unpacking

Let’s look at the following procedure:

public class Main {
    public static void main(String[] args) {
        int j = 0;
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(null);
        for (inti : list) { j += i; } System.out.println(j); }}Copy the code

A null pointer is reported at runtime



So when the value may be empty to box, must be added to the null value of the check. So you can change the program to:

The program results are as follows:

3

The interview questions 1

		Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;

        System.out.println(i1==i2);
        System.out.println(i3==i4);
Copy the code

Output result:

true
false
Copy the code

The Integer class contains an Integer instance cache array ranging from -128-127. If the int value given to the local variable is in the range above when autoboxing, if it is in the range, use the existing cache object; If the value is not in the range, the new object is created.

The interview questions 2

		Integer i1 = new Integer(21);
        Integer i2 = new Integer(21);
        System.out.println(i1 == i2);
        System.out.println(i1.equals(i2));
Copy the code

Output result:

false
true
Copy the code

If new creates space in the heap, it creates two Spaces twice, and the addresses of the two Spaces must be different. I don’t recommend it. It’s out of date.

ByteValue (), shortValue(), intValue(), longValue(), floatValue(), doubleValue()

Int integer.parseint (“255”); ParseInt (“11111111”, 2); parseInt(“377”,8); parseInt(“377”,8); ParseInt (“ff”, 16); Integer. ToBinaryString (255); // Convert the number to binary and parse it into “11111111” integer.tooctalString (255); // Convert digits to octal and parse to “377” integer.tohexString (255); // Convert the number to hexadecimal and parse to “ff”

Complete the program

		System.out.println("i1:" + Integer.parseInt("255"));
        System.out.println("i2:" + Integer.parseInt("11111111".2));
        System.out.println("i3:" + Integer.parseInt("377".8));
        System.out.println("i4:" + Integer.parseInt("ff".16));

        System.out.println("s1:" + Integer.toBinaryString(255));
        System.out.println("s2:" + Integer.toOctalString(255));
        System.out.println("s3:" + Integer.toHexString(255));
Copy the code

The output

255
255
255
255
11111111
377
ff
Copy the code

Floating-point operations are imprecise. Let’s look at the following operations

System.out.println(2 - 1.9);
System.out.println(4.35 * 100);
Copy the code

Operation results:



So why does this happen?

Because both floats and doubles are floating-point numbers, and computers are binary, floating-point numbers lose some precision. The root cause is that decimal values usually do not have exactly the same binary representation, and the binary representation of decimal numbers can be imprecise. You can only get infinitely close to that value.

The purpose of BigDecimal is to do precise floating-point arithmetic

A constructor

public BigDecimal(double val)    将doubleRepresentation conversion to BigDecimal * is not recommendedpublic BigDecimal(int val)willintThe representation is converted to BigDecimalpublic BigDecimal(String val)Converting the String representation to BigDecimal * is recommendedCopy the code

The results of constructors with arguments of type double are somewhat unpredictable. So it’s usually not used.

The String constructor is completely predictable: writing newBigDecimal(” 0.1 “) creates a BigDecimal that is exactly equal to the expected 0.1. Therefore, it is generally recommended to use the String constructor in preference.

When double must be used as a source for BigDecimal, convert toString using double.tostring (double) and then use the String constructor. Or use BigDecimal’s static method, valueOf.

Bd1 shows the unpredictability of the double constructor, DB2 shows the String constructor, and Bd3 and Bd4 show the correct double constructor.

		BigDecimal bd1 = new BigDecimal(1.9);
        BigDecimal bd2 = new BigDecimal("1.9");
        BigDecimal bd3 = BigDecimal.valueOf(1.9);
        BigDecimal bd4 = new BigDecimal(Double.toString(1.9));


        System.out.println("db1:" + bd1);
        System.out.println("db2:" + bd2);
        System.out.println("db3:" + bd3);
        System.out.println("db4:" + bd4);
Copy the code

Running results:

Subtract (BigDecimal BD)+ Subtract (BigDecimal BD) -multiply (BigDecimal BD)* divide(BigDecimal BD)/ divide(BigDecimal (bd, reserved digits, rounded) setScale(reserved digits, rounded) round operation, the result of the operation is returned as a new large number object

Example: Implement the exact calculation at the beginning of this section

		BigDecimal bd1 = new BigDecimal("2");
        BigDecimal bd2 = new BigDecimal("1.9");
        System.out.println("2-1.9 =" + bd1.subtract(bd2));

        BigDecimal bd3 = new BigDecimal("4.35");
        BigDecimal bd4 = new BigDecimal("100");
        System.out.println("4.35 * 100 =" + bd3.multiply(bd4));
Copy the code

Running results:



Example: Round

BigDecimal bd = BigDecimal.valueOf(2.345);
double result = bd.setScale(2, RoundingMode.HALF_UP).doubleValue();
System.out.println("result:" + result);
Copy the code

Running results:



Example: Calculate the landing distance

		System.out.println("Enter time of descent.");
        double t = new Scanner(System.in).nextDouble();
        / / 1/2 * 9.8 * t * t
        BigDecimal a = BigDecimal.valueOf(0.5);
        BigDecimal b = BigDecimal.valueOf(9.8);
        BigDecimal c = BigDecimal.valueOf(t);

        double result = a.multiply(b).multiply(c.pow(2)).doubleValue();

        System.out.println("Landing distance:" + result + "米");
Copy the code

Running results: