20210309 java.lang.Integer

java.lang.Integer

基本信息

• public final class Integer extends Number implements Comparable<Integer>
• rt.jar
• 引入版本：1.0
• 相关类：java.util.Comparator

使用说明

• Integer 类将原始类型 int 的值包装在对象中。类型为 Integer 的对象包含一个类型为 int 的字段。
• 此类提供了几种将 int 转换为 String 并将 String 转换为 int 的方法，以及其他在处理 int 时有用的常量和方法。
• Integer 的默认基数是 10，默认是十进制
• 需要重点理解其中的 无符号值（ Unsigned ）
• 需要从字节、位层面上理解其中的一些方法

静态常量

静态常量

int MIN_VALUE
int 能够表示的最小值，-2 的 31 次方

int MAX_VALUE
int 能够表示的最小值，2 的 31 次方减 1

Class<Integer> TYPE
原始类型 int 的 Class 实例

int SIZE
32，用于表示二进制补码二进制形式的 int 值的 bit 数。

int BYTES
4，用于表示二进制补码二进制形式的 byte 的 bit 数。

构造方法

构造方法

Integer(int value)

Integer(String s)
转为 10 进制的整数，不能超过大小限制

公共方法

重写父类方法

java.lang.Number

重写父类方法

byte byteValue()

short shortValue()

java.lang.Number

重写父类方法

String toString()

int hashCode()
Integer 类型的 hashCode 是本身的十进制值

boolean equals(Object obj)

实现抽象方法

java.lang.Number

实现抽象方法

int intValue()

long longValue()

float floatValue()

double doubleValue()

实现接口方法

java.lang.Comparable

实现接口方法

int compareTo(Integer anotherInteger)

静态方法

静态方法

String toString(int i)
String toString(int i, int radix)
返回第二个参数指定的基数中第一个参数的字符串表示形式。（如果不指定是 10 进制）
如果基数小于 2 Character.MIN_RADIX 或大于 36 Character.MAX_RADIX，则使用基数 10。

int parseInt(String s)
int parseInt(String s, int radix)
将字符串参数解析为第二个参数指定的基数（默认为 10）中的有符号整数

Integer valueOf(int i)
Integer valueOf(String s)
Integer valueOf(String s, int radix)
返回新的 Integer 对象
内部使用 parseInt 方法

String toUnsignedString(int i)
String toUnsignedString(int i, int radix)
将整数转为一个无符号数
返回指定基数中参数的无符号字符串表示形式。

int parseUnsignedInt(String s)
int parseUnsignedInt(String s, int radix)
将字符串参数解析为第二个参数指定的基数（默认是 10）中的无符号整数。
无符号整数将通常与负数关联的值映射为大于 MAX_VALUE 的正数。

long toUnsignedLong(int x)
通过无符号转换将参数转换为 long

String toBinaryString(int i)
返回整数参数的字符串表示形式，以 2 为底的无符号整数。
可以通过调用 Integer.parseUnsignedInt(s，2)从返回的字符串s中恢复参数的值。

String toOctalString(int i)
转为 8 进制表示的字符串

String toHexString(int i)
转为 16 进制表示的字符串

int hashCode(int value)
返回十进制值作为 hash 码

Integer getInteger(String nm)
Integer getInteger(String nm, int val)
Integer getInteger(String nm, Integer val)
从 System.getProperties() 中的属性获取整型值，如果没有该属性或者属性值不是整型，返回 null 或默认值参数

Integer decode(String nm)
将字符串解码为整数。 接受十进制，十六进制和八进制数字的 Java 表示

int compare(int x, int y)
比较两个整型值，返回 -1，0，1（x > y）

int compareUnsigned(int x, int y)
将两个整型值作为无符号值比较

int divideUnsigned(int dividend, int divisor)
将两个整型值作为无符号值进行除法操作

int remainderUnsigned(int dividend, int divisor)
将两个整型值作为无符号值进行取余操作

int highestOneBit(int i)
返回二进制表示法中最高一位 1 表示的整数值

int lowestOneBit(int i)
返回二进制表示法中最低一位 1 表示的整数值

int numberOfLeadingZeros(int i)
32 位二进制表示法前面 0 的个数

int numberOfTrailingZeros(int i)
32 位二进制表示法后面 0 的个数

int bitCount(int i)
32 位二进制表示法中 1 的个数

int rotateLeft(int i, int distance)
32 位二进制表示法左移，最左的位被移到最右

int rotateRight(int i, int distance)
32 位二进制表示法右移，最右的位被移到最左

int reverse(int i)
按位反转

int reverseBytes(int i)
按照字节（8位）进行反转

int signum(int i)
返回符号位，1（正数）、0（0）、-1（负数）

int sum(int a, int b)
求和

int max(int a, int b)
求较大值

int min(int a, int b)
求较小值

示例代码

public class IntegerTest {
    @Test
    public void test() {
        Integer integer1 = new Integer(20);
        Integer integer2 = new Integer(-20);

        System.out.println(Integer.TYPE);   // int
        System.out.println(Integer.SIZE);   // 32
        System.out.println(Integer.BYTES);  // 4
        System.out.println(Integer.MIN_VALUE);  // -2147483648
        System.out.println(Integer.MAX_VALUE);  // 2147483647

        BigDecimal bigDecimal = new BigDecimal(Math.pow(2, 31));
        System.out.println(bigDecimal.intValue());  // -2147483648
        bigDecimal = bigDecimal.subtract(new BigDecimal(1));
        System.out.println(bigDecimal.intValue());  // 2147483647

        System.out.println(integer1.byteValue());    // 20
        System.out.println(integer2.byteValue());    // -20

        System.out.println(integer1.hashCode());    // 20
        System.out.println(integer2.hashCode());    // -20


        System.out.println(Integer.toString(integer1, 2));  // 10100
        System.out.println(Integer.toString(integer1, 0));  // 20
        System.out.println(Integer.toString(0, 2));  // 0
        System.out.println(Integer.toString(integer2, 2));  // -10100

        System.out.println(Integer.parseInt("-20"));    // -20
        System.out.println(Integer.parseInt("20")); // 20

        System.out.println(Integer.toUnsignedString(integer1, 2));  // 10100
        System.out.println(Integer.toUnsignedString(integer2));  // 4294967276
        System.out.println(Integer.toUnsignedString(integer2, 2));  // 11111111111111111111111111101100

        System.out.println(Integer.parseUnsignedInt("4294967276"));     // -20
        System.out.println(Integer.parseUnsignedInt("11111111111111111111111111101100", 2));    // -20

        System.out.println(Integer.toBinaryString(integer1));   // 10100
        System.out.println(Integer.toBinaryString(integer2));   // 11111111111111111111111111101100

        System.out.println(Integer.toOctalString(100));    // 144
        System.out.println(Integer.toHexString(100));    // 64

        System.out.println(Integer.hashCode(Integer.parseUnsignedInt("4294967276")));   // -20

        System.out.println(System.getProperty("sun.arch.data.model"));  // 64
        System.out.println(Integer.getInteger("sun.arch.data.model"));   // 64
        // System.getenv() 中的
        System.out.println(Integer.getInteger("PROCESSOR_LEVEL"));   // null
        System.out.println(Integer.getInteger("user.country", 55)); // 55

        System.out.println(Integer.decode("100"));    // 100
        System.out.println(Integer.decode("0144")); // 100
        System.out.println(Integer.decode("0x64")); // 100
        System.out.println(Integer.decode("0X64")); // 100
        System.out.println(Integer.decode("#64")); // 100


        System.out.println(Integer.compare(10, 9));     // 1
        System.out.println(Integer.compare(10, 10));     // 0
        System.out.println(Integer.compare(9, 10));     // -1

        System.out.println(Integer.toUnsignedString(-10));  // 4294967286

        System.out.println(Integer.compareUnsigned(-10, 9));     // 1
        System.out.println(Integer.compareUnsigned(-10, 10));     // 1
        System.out.println(Integer.compareUnsigned(10, -10));     // -1
        System.out.println(Integer.compareUnsigned(9, -10));     // -1

        System.out.println(Integer.MIN_VALUE);  // -2^31
        System.out.println(Integer.MAX_VALUE);  // 2^31-1
        System.out.println(4294967286L + 10);   // 4294967296
        System.out.println(Math.pow(2, 32));     // 4294967296


        System.out.println(Integer.divideUnsigned(-10, 10));    // 429496728
        System.out.println(4294967286L / 10);   // 429496728


        System.out.println(Integer.remainderUnsigned(-10, 10)); // 6
        System.out.println(4294967286L % 10); // 6


        System.out.println(Integer.toBinaryString(10)); // 1010
        System.out.println(Integer.toBinaryString(-10)); // 11111111111111111111111111110110

        System.out.println(Integer.highestOneBit(10));  // 8 = 2^3
        System.out.println(Integer.toBinaryString(100)); // 1100100
        System.out.println(Integer.highestOneBit(100));  // 64 = 2^6
        System.out.println(Integer.highestOneBit(-10)); // -2147483648


        System.out.println(Integer.lowestOneBit(10));  // 2 = 2^1
        System.out.println(Integer.toBinaryString(100)); // 1100100
        System.out.println(Integer.lowestOneBit(100));  // 4 = 2^2
        System.out.println(Integer.lowestOneBit(-10)); // 2 = 2^1

        System.out.println(Math.floor(Math.log(10)));   // 2.0
        System.out.println(Math.ceil(Math.log(10)));    // 3.0
        System.out.println(Integer.numberOfLeadingZeros(10));   // 28
        System.out.println(Integer.numberOfLeadingZeros(9));   // 28
        System.out.println(Integer.numberOfLeadingZeros(100));   // 25
        System.out.println(Integer.numberOfTrailingZeros(10));  // 1
        System.out.println(Integer.numberOfTrailingZeros(100));  // 2


        System.out.println(Integer.bitCount(10));   // 2
        System.out.println(Integer.bitCount(100));   // 3


        System.out.println(Integer.parseUnsignedInt("00000000000000000000000000001010", 2));    // 10
        System.out.println(Integer.rotateLeft(10, 1));  // 20
        System.out.println(Integer.rotateLeft(10, 2));  // 40
        System.out.println(Integer.rotateRight(10, 1));  // 5
        System.out.println(Integer.parseUnsignedInt("10000000000000000000000000000010", 2)); // -2147483646
        System.out.println(Integer.rotateRight(10, 2));  // -2147483646
        System.out.println(Integer.parseUnsignedInt("01000000000000000000000000000001", 2)); // 1073741825
        System.out.println(Integer.rotateRight(10, 3));  // 1073741825


        System.out.println(Integer.reverse(10));    // 1342177280
        System.out.println(Integer.toUnsignedString(1342177280, 2));     // 1010000000000000000000000000000

        System.out.println(Integer.reverse(100));    // 637534208
        System.out.println(Integer.toUnsignedString(637534208, 2));     // 100110000000000000000000000000


        System.out.println(Integer.signum(10));     // 1
        System.out.println(Integer.signum(0));     // 0
        System.out.println(Integer.signum(-10));    // -1


        System.out.println(Integer.reverseBytes(10));   // 167772160
        System.out.println(Integer.toUnsignedString(167772160, 2)); // 1010000000000000000000000000
        System.out.println(Integer.reverseBytes(100));  // 1677721600
        System.out.println(Integer.toUnsignedString(1677721600, 2));    // 1100100000000000000000000000000
    }
}