包装类中Integer类最全详解

---

概述

Integer类继承了Number实现了Comparable
Integer类存在java.lang包下，使用时不需要导包

public final class Integer extends Number implements Comparable<Integer>

Integer类在对象中包装基本类型int的值。 Integer类型的对象包含单个字段，其类型为int 。

---

字段

public static final int BYTES = SIZE / Byte.SIZE;
public static final int   MIN_VALUE = 0x80000000;
public static final int   MAX_VALUE = 0x7fffffff;
public static final int SIZE = 32;
public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

---

构造方法

int x1 = new Integer(2);//x1=2
int y1 = new Integer("5");//y1=5

Integer x2 = 5;
Integer y2 = 10;

Integer x3 = new Integer(20);
Integer y3 = new Integer(30);

---

方法

bitCount(int i)​

返回指定的 int值的二进制补码表示形式中的 int 。

public static int bitCount(int i) {
        // HD, Figure 5-2
        i = i - ((i >>> 1) & 0x55555555);
        i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
        i = (i + (i >>> 4)) & 0x0f0f0f0f;
        i = i + (i >>> 8);
        i = i + (i >>> 16);
        return i & 0x3f;
    }

byteValue()

返回此值 Integer为 byte的基本收缩转换后。

public byte byteValue() {
        return (byte)value;
    }

compare​(int x, int y)

以数字方式比较两个 int值。
返回值是1或-1或 0

1表示传入的参数前面比后面大
-1表示传入的参数后面比前面大
0表示传入的参数两者相等

public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

int x = 10;
int y = 20;
int i = Integer.compare(x,y);
System.out.println(i);
//输出的结果是-1

compareTo​(Integer anotherInteger)

以数字方式比较两个 Integer对象。

compareTo内部其实也是直接调用的compare方法.

public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }

Integer x3 = new Integer(20);
Integer y3 = new Integer(30);

int i2 = y3.compareTo(x3);
System.out.println(i2);
//输出结果是1，证明y3比x3

compareUnsigned​(int x, int y)

public static int compareUnsigned(int x, int y) {
        return compare(x + MIN_VALUE, y + MIN_VALUE);
    }

decode​(String nm)

public static Integer decode​(String nm) throws NumberFormatException

将String解码为Integer 。 接受以下语法给出的十进制，十六进制和八进制数：

参数
nm - 要解码的 String 。
结果
Integer对象，持有 int值，由 nm表示
异常
NumberFormatException - 如果 String不包含可解析的整数。

方法源码：

public static Integer decode(String nm) throws NumberFormatException {
        int radix = 10;
        int index = 0;
        boolean negative = false;
        Integer result;

        if (nm.length() == 0)
            throw new NumberFormatException("Zero length string");
        char firstChar = nm.charAt(0);
        // Handle sign, if present
        if (firstChar == '-') {
            negative = true;
            index++;
        } else if (firstChar == '+')
            index++;

        // Handle radix specifier, if present
        if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
            index += 2;
            radix = 16;
        }
        else if (nm.startsWith("#", index)) {
            index ++;
            radix = 16;
        }
        else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
            index ++;
            radix = 8;
        }

        if (nm.startsWith("-", index) || nm.startsWith("+", index))
            throw new NumberFormatException("Sign character in wrong position");

        try {
            result = Integer.valueOf(nm.substring(index), radix);
            result = negative ? Integer.valueOf(-result.intValue()) : result;
        } catch (NumberFormatException e) {
            // If number is Integer.MIN_VALUE, we'll end up here. The next line
            // handles this case, and causes any genuine format error to be
            // rethrown.
            String constant = negative ? ("-" + nm.substring(index))
                                       : nm.substring(index);
            result = Integer.valueOf(constant, radix);
        }
        return result;
    }

divideUnsigned​(int dividend, int divisor)

public static int divideUnsigned​(int dividend, int divisor)

返回将第一个参数除以第二个参数的无符号商，其中每个参数和结果都被解释为无符号值。

参数
dividend - 要划分的值
divisor - 进行分割的值
结果
第一个参数的无符号商除以第二个参数

getInteger​(String nm)

public static Integer getInteger​(String nm)

确定具有指定名称的系统属性的整数值。
第一个参数被视为系统属性的名称。 可以通过System.getProperty(java.lang.String)方法访问系统属性。 然后，使用decode支持的语法将此属性的字符串值解释为整数值，并返回表示此值的Integer对象。

如果没有具有指定名称的属性，如果指定的名称为空或null ，或者属性没有正确的数字格式，则返回null 。

换句话说，此方法返回一个等于值的Integer对象：

getInteger(nm, null)

参数
nm - 属性名称。
结果
Integer该物业的价值。

getInteger​(String nm, int val)

public static Integer getInteger​(String nm, int val)

确定具有指定名称的系统属性的整数值。
第一个参数被视为系统属性的名称。 可以通过System.getProperty(java.lang.String)方法访问系统属性。 然后，使用decode支持的语法将此属性的字符串值解释为整数值，并返回表示此值的Integer对象。

第二个参数是默认值。 如果没有指定名称的属性，如果属性没有正确的数字格式，或者指定的名称为空或null ，则返回表示第二个参数值的Integer对象。

换句话说，此方法返回一个等于值的Integer对象：

getInteger(nm, new Integer(val))

参数
nm - 财产名称。
val - 默认值。
结果
Integer该物业的价值。

highestOneBit​(int i)

public static int highestOneBit​(int i)

返回int值，最多只有一位，位于指定int值中最高位（“最左侧”）的一位。 如果指定的值在其二进制补码表示中没有一位，即，如果它等于零，则返回零。

参数
i - 要计算其最高位的值
结果
int具有单个一位的值，位于指定值中最高位一位的位置，如果指定值本身等于零，则为零。

lowestOneBit​(int i)

public static int lowestOneBit​(int i)

返回一个int值，最多只有一位，位于指定int值中最低位（“最右侧”）一位的位置。 如果指定的值在其二进制补码表示中没有一位，即，如果它等于零，则返回零。

参数
i - 要计算其最低一位的值
结果
int具有单个一位的值，位于指定值中最低位一位的位置，如果指定值本身等于零，则为零。

max​(int a, int b)

public static int max​(int a, int b)

返回两个 int值中较大的一个， int调用 Math.max一样 。

参数
a - 第一个操作数
b - 第二个操作数
结果
a和 b的较大者

min​(int a, int b)

public static int min​(int a, int b)

返回两个 int值中较小的一个， int调用 Math.min一样 。

参数
a - 第一个操作数
b - 第二个操作数
结果
较小的 a和 b

reverse​(int i)

public static int reverse​(int i)

返回通过反转指定的 int值的二进制补码表达式中的位顺序获得的值。
参数
i - 要反转的值
结果
通过反转指定的 int值中的位顺序获得的值。

reverseBytes​(int i)

public static int reverseBytes​(int i)

返回通过反转指定的 int值的二进制补码表示中的字节顺序获得的值。
参数
i - 要反转其字节的值
结果
通过反转指定的 int值中的字节获得的值。

signum​(int i)

public static int signum​(int i)

返回指定的int值的signum函数。 （如果指定的值为负，则返回值为-1;如果指定的值为零，则返回0;如果指定的值为正，则返回1。）
参数
i - 要计算其signum的值
结果
指定 int值的signum函数。

sum​(int a, int b)

public static int sum​(int a, int b)

根据+运算符将两个整数相加。
参数
a - 第一个操作数
b - 第二个操作数
结果
总和 a和 b

parse方法

parseInt​(CharSequence s, int beginIndex, int endIndex, int radix)

public static int parseInt​(CharSequence s, int beginIndex, int endIndex, int radix) throws NumberFormatException

参数
s -所述 CharSequence含有 int表示被解析
beginIndex - 起始索引，包括。
endIndex - 结束索引，不包括。
radix - 解析 s使用的基数。
结果
签名的 int由指定基数中的子 int表示。
异常
NullPointerException - 如果 s为空。
IndexOutOfBoundsException - 如果 beginIndex为负数，或者 beginIndex大于 endIndex或者 endIndex大于 s.length() 。
NumberFormatException - 如果 int在指定的 CharSequence中不包含可解析的 radix ，或者 radix小于 Character.MIN_RADIX或大于 Character.MAX_RADIX 。

parseInt​(String s)

public static int parseInt​(String s) throws NumberFormatException

将字符串参数解析为带符号的十进制整数。 字符串中的字符必须全部为十进制数字，除了第一个字符可以是ASCII减号’-’ （ ‘\u002D’ ）以指示负值或ASCII加号’+’ （ ‘\u002B’ ）以指示正值。 返回结果整数值，就像参数和基数10作为parseInt(java.lang.String, int)方法的参数一样 。

参数
s -一个 String含有 int表示被解析
结果
十进制参数表示的整数值。
异常
NumberFormatException - 如果字符串不包含可解析的整数。

parseInt​(String s, int radix)

public static int parseInt​(String s, int radix) throws NumberFormatException

参数
s - 包含要解析的整数表示的 String
radix - 解析 s使用的基数。
结果
指定基数中字符串参数表示的整数。
异常
NumberFormatException - 如果 String不包含可解析的 int 。

Value方法

byteValue()

public byte byteValue()

返回此值 Integer为 byte的基本收缩转换后。
结果
转换为类型 byte后此对象表示的数值。

shortValue()

public short shortValue()

返回此值 Integer为 short的基本收缩转换后。
结果
转换为类型 short后此对象表示的数值。

doubleValue()

public double doubleValue()

返回此值 Integer为 double一个宽元转换后。
结果
转换为类型 double后此对象表示的数值。

floatValue()

public float floatValue()

返回此值 Integer为 float一个宽元转换后。
结果
转换为类型 float后此对象表示的数值。

intValue()

public int intValue()

返回此值 Integer为 int 。
结果
转换为类型 int后此对象表示的数值。

longValue()

public long longValue()

返回此值 Integer为 long一个宽元转换后。
结果
转换为类型 long后此对象表示的数值。

ValueOf方法

valueOf​(int i)

返回表示指定的int值的Integer实例。 ==如果不需要新的Integer实例，则通常应优先使用此方法，而不是构造函数Integer(int) ==，因为此方法可能通过缓存频繁请求的值来显着提高空间和时间性能。 此方法将始终缓存-128到127（包括端点）范围内的值，并可以缓存此范围之外的其他值。

public static Integer valueOf​(int i)

参数
i - 一个 int值。
结果
Integer实例，代表 i 。

方法源码：

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

Integer o = Integer.valueOf(233);
System.out.println(o);//输出233

valueOf​(String s)

返回一个Integer物体保持在指定的值String 。 该参数被解释为表示带符号的十进制整数，就像该参数被赋予parseInt(java.lang.String)方法一样。 结果是Integer对象，表示字符串指定的整数值。

换句话说，此方法返回一个等于值的Integer对象：

new Integer(Integer.parseInt(s))

public static Integer valueOf​(String s) throws NumberFormatException

参数
s - 要解析的字符串。
结果
Integer对象，保存字符串参数表示的值。
异常
NumberFormatException - 如果字符串无法解析为整数。

方法源码：

public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
    }

Integer o = Integer.valueOf("233");
System.out.println(o);//输出的是233

valueOf​(String s, int radix)

当使用第二个参数给出的基数进行解析时，返回一个Integer对象，其中String从指定的String提取的值。 第一个参数被解释为表示由第二个参数指定的基数中的有符号整数，就像将参数赋予parseInt(java.lang.String, int)方法一样。 结果是Integer对象，表示字符串指定的整数值。

public static Integer valueOf​(String s, int radix) throws NumberFormatException

参数
s - 要解析的字符串。
radix - 用于解释 s的基数
结果
Integer对象，保存指定基数中字符串参数表示的值。
异常
NumberFormatException - 如果 String不包含可解析的 int 。

方法源码：

public static Integer valueOf(String s, int radix) throws NumberFormatException {
        return Integer.valueOf(parseInt(s,radix));
    }