【读码JDK】- java.lang.Integer类Api介绍及测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
package lang;

import org.junit.Test;

/**
 * https://blog.csdn.net/yvonne8_5/article/details/50956016
 *
 * @author jujun chen
 * @date 2020/03/26
 */
public class IntegerTest {


    /**
     * 将第一个参数转换为第二个参数指定的进制，输出字符串
     */
    @Test
    public void toString1() {
        System.out.println(Integer.toString(0x21, 10));
        System.out.println(Integer.toString(-0x21, 10));
        /**
         * 33
         * -33
         */
    }

    /**
     * 返回第一个参数的字符串表示形式，作为第二个参数指定的基数中的无符号整数值
     *
     * 正值，映射为等值的Long型，负值为输入的值加上2<sup>32</sup>
     */
    @Test
    public void toUnsignedString() {
        System.out.println(Integer.toUnsignedString(0x21, 10));
        System.out.println(Integer.toUnsignedString(-0x21, 10));

        /**
         * 33
         * 4294967263
         */
    }

    /**
     * 返回整数参数的字符串表示形式，作为基数为16进制无符号整数。
     * <p>
     * 如果参数为负，则无符号整数值是参数加2的32次方 ; 否则，它等于参数。
     * <p>
     * 此值将转换为十六进制（基数为16）的ASCII数字字符串，没有额外的前导0 。
     * <p>
     * 可以通过调用Integer.parseUnsignedInt(s, 16)从返回的字符串s恢复参数的值。
     * <p>
     * 如果无符号幅度为零，则由单个零字符'0' （ 'u0030' ）表示; 否则，无符号幅度表示的第一个字符将不是零字符
     */
    @Test
    public void toHexString() {
        System.out.println(Integer.toHexString(33));
        System.out.println(Integer.toHexString(-33));
        System.out.println(Integer.parseUnsignedInt("21", 16));
        /**
         * 21
         * ffffffdf
         * 33
         */
    }

    /**
     * 返回整数参数的字符串表示形式，作为基数为8进制无符号整数。
     * <p>
     * 如果参数为负，则无符号整数值是参数加2的32次方 ; 否则，它等于参数。
     * <p>
     * 此值将转换为八进制（基数为8）的ASCII数字字符串，没有额外的前导0 。
     * <p>
     * 可以通过调用Integer.parseUnsignedInt(s, 8)从返回的字符串s恢复参数的值。
     * <p>
     * 如果无符号幅度为零，则由单个零字符'0'（ 'u0030' ）表示; 否则，无符号幅度表示的第一个字符将不是零字符。
     */
    @Test
    public void toOctalString() {
        System.out.println(Integer.toOctalString(33));
        System.out.println(Integer.parseUnsignedInt("41", 8));
    }

    /**
     * 返回整数参数的字符串表示形式，作为基于2进制中的无符号整数。
     * <p>
     * 如果参数为负，则无符号整数值是参数加2的32次方  ; 否则它等于参数。
     * <p>
     * 此值将转换为二进制（基数2）中的ASCII数字字符串，没有额外的前导0 。
     * <p>
     * 可以通过调用Integer.parseUnsignedInt(s, 2)从返回的字符串s恢复参数的值。
     * <p>
     * 如果无符号幅度为零，则由单个零字符'0' （ 'u0030' ）表示; 否则，无符号幅度表示的第一个字符将不是零字符。
     * <p>
     * 字符'0' （ 'u0030' ）和'1' （ 'u0031' ）用作二进制数字。
     */
    @Test
    public void toBinaryString() {
        System.out.println(Integer.toBinaryString(33));
        System.out.println(Integer.toBinaryString(-33));
    }


    @Test
    public void parseInt() {
        /*
         * 将字符串参数解析为第二个参数指定基数的有符号整数。
         *
         * 字符串中的字符必须全部是指定基数的数字（由Character.digit(char, int)是否返回非负值确定），但第一个字符可能是ASCII减号'-' （ 'u002D' ）以指示负值或ASCII加号'+'
         *  （ 'u002B' ）表示正值。
         *
         * 返回结果整数值。
         */
        System.out.println(Integer.parseInt("21", 16));

        /*
         * 将字符串参数解析为带符号的十进制整数。字符串中的字符必须全部为十进制数字
         */
        System.out.println(Integer.parseInt("21"));
        //NumberFormatException
//        System.out.println(Integer.parseInt("0x21"));


        /*
        解析CharSequence参数作为有符号int指定radix ，在指定的开始beginIndex并延伸到endIndex - 1
        参数
            s -所述 CharSequence含有 int表示被解析
            beginIndex - 起始索引，包括。
            endIndex - 结束索引，不包括。
            radix - 解析 s使用的基数。
        结果
            签名的 int由指定基数中的子 int表示。
         */
        System.out.println(Integer.parseInt("abc", 1, 3, 16));

        /**
         * 33
         * 21
         * 188
         */

    }

    /**
     * 解析为无符号整数
     * 用法同parseInt
     */
    @Test
    public void parseUnsignedInt() {

    }


    @Test
    public void valueOf() {
        /*
         * 使用第二个参数给出的基数进行解析时，返回一个Integer对象
         *
         * 此方法等同于：
         *
         * new Integer(Integer.parseInt(s, radix))
         */
        Integer integer = Integer.valueOf("21", 16); //33

        /*
        返回一个Integer，指定的值String 。

        该参数被解析为表示带符号的十进制整数
         */
        Integer integer1 = Integer.valueOf("33");

        Integer integer2 = Integer.valueOf(33);
    }

    /**
     * 此对象的哈希码值，等于原始 int由该表示值 Integer对象
     */
    @Test
    public void hashCode1() {
        Integer integer2 = Integer.valueOf(33);
        System.out.println(integer2.hashCode());
    }

    /**
     * 确定具有指定名称的系统属性的整数值。
     * 第一个参数被视为系统属性的名称。 可以通过System.getProperty(java.lang.String)方法访问系统属性。
     * 然后，使用decode支持的语法将此属性的字符串值解释为整数值，并返回表示此值的Integer对象。
     * <p>
     * 如果没有具有指定名称的属性，如果指定的名称为空或null ，或者属性没有正确的数字格式，则返回第二个参数提供的默认值 。
     * <p>
     * 换句话说，此方法返回一个等于值的Integer对象：
     * <p>
     * getInteger(nm, null)
     * 参数
     * nm - 属性名称。
     * 结果
     * Integer类型的值。
     */
    @Test
    public void getInteger() {
        Integer integer = Integer.getInteger("path", 123);
        System.out.println(integer); //123
    }

    /**
     * 将String解码为Integer 。
     * <p>
     * 接受以下语法给出的十进制，十六进制和八进制数：
     * DecodableString:
     * Signopt DecimalNumeral
     * Signopt 0x HexDigits
     * Signopt 0X HexDigits
     * Signopt # HexDigits
     * Signopt 0 OctalDigits
     * Sign:
     * -
     * +
     * DecimalNumeral ， HexDigits和OctalDigits在The Java™ Language Specification的 3.10.1节中定义 ，但数字之间不接受下划线。
     * 可选符号和/或基数说明符（“ 0x ”，“ 0X ”，“ # ”或前导零）后面的字符序列由Integer.parseInt方法用指示的基数（10,16或8）进行解析。
     * 此字符序列必须表示正值或将抛出NumberFormatException 。 如果指定的String第一个字符是减号，则结果为否定。 String中不允许使用空格字符
     */
    @Test
    public void decode() {
        System.out.println(Integer.decode("0x21"));
    }


    /**
     * 比较两个 int值，以数值方式将值视为无符号。
     * 参数
     * x - 第一个 int进行比较
     * y - 第二个 int进行比较
     * 结果
     * 值0如果x == y ; 如果x < y为无符号值，则值小于0 ; 如果x > y为无符号值，则值大于0
     */
    @Test
    public void compareUnsigned() {
        System.out.println(Integer.compareUnsigned(-10, 10)); //1
    }


    /**
     * 返回将第一个参数除以第二个参数的无符号商，其中每个参数和结果都被解释为无符号值。
     * <p>
     * 注意，在二进制补码算法中，如果两个操作数被认为是有符号的或两者都是无符号的，
     * <p>
     * 则加，减和乘法的其他三个基本算术运算是逐位相同的。 因此，未提供单独的addUnsigned等方法。
     * <p>
     * 参数
     * dividend - 要划分的值
     * divisor - 进行分割的值
     * 结果
     * 第一个参数除以第二个参数的无符号商
     */
    @Test
    public void divideUnsigned() {

        System.out.println(Integer.divideUnsigned(10, 2)); //5
        //转换为无符号的long类型的数值，再相除
        System.out.println(Integer.divideUnsigned(10, -2)); //0
    }


    /**
     * 返回将第一个参数除以第二个参数的无符号余数，其中每个参数和结果都被解释为无符号值。
     * 参数
     * dividend - 要划分的值
     * divisor - 进行分割的价值
     * 结果
     * 返回将第一个参数除以第二个参数的无符号余数
     */
    @Test
    public void remainderUnsigned() {
        System.out.println(Integer.remainderUnsigned(10, 2)); //0
        System.out.println(Integer.remainderUnsigned(3, 10)); //3
        System.out.println(Integer.remainderUnsigned(10, -2)); //10
        System.out.println(10%-2); //0
    }

    /**
     * 返回一个int值，最多只有一个一位，位于指定int值中最低位（“最右边”）一位的位置。如果指定的值在其二进制补码表示中没有一位，即等于零，则返回零。
     * 参形：
     * i – 要计算其最低一位的值
     * 返回值：
     * 具有单个一位的int值，位于指定值中最低位的位置，如果指定值本身等于 0，则为 0。
     */
    @Test
    public void lowestOneBit() {
        //负数补码 = 原码 取反 +1
        //所以负数最低位的1之前的所有二进制数会因为 a & -a = 0，全部消去，只留下最低位的1
        System.out.println(Integer.lowestOneBit(1213));
    }

    //https://www.jianshu.com/p/2c1be41f6e59

    /**
     * 返回无符号整型i的最高非零位前面的0的个数
     */
    @Test
    public void numberOfLeadingZeros() {

    }


    /**
     * 返回参数的正负数
     * <p>
     * 如果指定的值是负的，返回值是-1; 如果指定的值是零，返回0; 如果指定的值是正的，返回1
     */
    @Test
    public void signumTest() {
        System.out.println(Integer.signum(3)); //1
        System.out.println(Integer.signum(-1)); //-1
        System.out.println(Integer.signum(-0));//0
    }

}