java.lang.IntegerInteger的定义字段摘要方法摘要Integer类的应用

72 阅读 0 评论 48 点赞

我是靠谱客的博主欣慰菠萝，最近开发中收集的这篇文章主要介绍java.lang.IntegerInteger的定义字段摘要方法摘要Integer类的应用，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Integer的定义

public final class Integer extends Number implements Comparable<Integer>

Integer类在对象中包装了一个基本类型int的值。Integer类型的对象包含一个int类型的字段。

此外，该类提供了多个方法，能在int类型和String类型之间互相转换，还提供了处理int类型时非常有用的其他一些常量和方法。

实现注意事项：“bit twiddling”方法（如 highestOneBit 和numberOfTrailingZeros）的实现基于 Henry S. Warren, Jr.撰写的Hacker's Delight（Addison Wesley, 2002）中的一些有关材料。

字段摘要

1、static int MAX_VALUE：保持 int类型的最大值的常量可取的值为 2³¹－1。

2、static int MIN_VALUE：保持 int类型的最小值的常量可取的值为－2³¹。

3、static int SIZE：以二进制补码形式表示 int 值的位数。

4、static Class<Integer> TYPE：表示基本类型 int 的Class 实例。

方法摘要

构造方法

1、Integer(int value)：构造一个新分配的 Integer 对象，它表示指定的 int 值。

2、Integer(Strings)：构造一个新分配的Integer 对象，它表示 String 参数所指示的 int 值。

将Integer类型转换为其他类型

1、byte byteValue()：以 byte 类型返回该Integer 的值。

2、float floatValue()：以 float 类型返回该Integer 的值。

3、int intValue()：以 int 类型返回该Integer 的值。

4、long longValue()：以 long 类型返回该Integer 的值。

5、short shortValue()：以 short 类型返回该Integer 的值。

6、double doubleValue()：以 double 类型返回该Integer 的值。

Integer类型与字符串的相互转换

1、static int parseInt(String s)：将字符串参数作为有符号的十进制整数进行分析。

2、static int parseInt(String s, int radix)：使用第二个参数指定的基数，将字符串参数解析为有符号的整数。

3、static Integer valueOf(int i)：返回一个表示指定的int值的Integer实例。

4、static Integer valueOf(String s)：返回保持指定的 String的值的Integer 对象。

5、static Integer valueOf(Strings, int radix)：返回一个 Integer 对象，该对象中保持了用第二个参数提供的基数进行分析时从指定的 String中提取的值。

6、static String toBinaryString(inti)：以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。

7、static String toHexString(inti)：以十六进制的无符号整数形式返回一个整数参数的字符串表示形式。

8、static String toOctalString(inti)：以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

9、String toString()：返回一个表示该 Integer 值的 String对象。

10、static String toString(int i)：返回一个表示指定整数的 String对象。

11、static String toString(int i, int radix)：用第二个参数指定的基数返回第一个参数的字符串表示形式。

其他方法

1、static int highestOneBit(inti)：返回具有至多单个 1 位的 int 值，在指定的 int值中最高位（最左边）的 1 位的位置。

2、static int lowestOneBit(int i)：返回具有至多单个 1 位的 int 值，在指定的 int值中最低位（最右边）的 1 位的位置。

3、static int numberOfLeadingZeros(int i)：在指定 int 值的二进制补码表示形式中最高位（最左边）的1 位之前，返回零位的数量。

4、static int numberOfTrailingZeros(int i)：返回指定的 int 值的二进制补码表示形式中最低（“最右”）的为1 的位后面的零位个数。

5、static int reverse(int i)：返回通过反转指定 int 值的二进制补码表示形式中位的顺序而获得的值。

6、static int reverseBytes(int i)：返回通过反转指定 int 值的二进制补码表示形式中字节的顺序而获得的值。

7、static int rotateLeft(int i,int distance)：返回根据指定的位数循环左移指定的 int 值的二进制补码表示形式而得到的值。

8、static int rotateRight(int i,int distance)：返回根据指定的位数循环右移指定的 int 值的二进制补码表示形式而得到的值。

9、static int bitCount(int i)：返回指定 int 值的二进制补码表示形式的1 位的数量。

10、int compareTo(Integer anotherInteger)：在数字上比较两个Integer 对象。

11、static Integer decode(String nm)：将 String 解码为Integer。

12、boolean equals(Object obj)：比较此对象与指定对象。

13、int hashCode()：返回此 Integer 的哈希码。

14、static int signum(int i)：返回指定 int 值的符号函数。

15、static Integer getInteger(String nm)：确定具有指定名称的系统属性的整数值。

16、static Integer getInteger(String nm, int val)：确定具有指定名称的系统属性的整数值。

17、static Integer getInteger(String nm, Integer val)：返回具有指定名称的系统属性的整数值。

Integer类的应用

package com.zxt.integer;
public class IntegerTest {
public static void main(String[] args) {
// highestOneBit：返回具有至多单个 1 位的 int 值，在指定的 int 值中最高位（最左边）的 1 位的位置。
// 意思就是保留改数的最高位的1，其余数字置为0。即获得一个跟它最靠近的比它小的2的N次方（若参数为负数，返回-2147483648）
// 0001 0001 ---> 0001 0000
System.out.println(Integer.highestOneBit(17));
// 1111 ---> 1000
System.out.println(Integer.highestOneBit(15));
System.out.println(Integer.highestOneBit(32));
System.out.println(Integer.highestOneBit(63));
System.out.println(Integer.highestOneBit(0));
System.out.println(Integer.highestOneBit(-1));
// lowestOneBit(int i)：返回具有至多单个 1 位的 int 值，在指定的 int 值中最低位（最右边）的 1 位的位置。
// 即最低一位1保留，其余位置为0.
// 0001 0001 ---> 0000 0001
System.out.println(Integer.lowestOneBit(17));
// 1100 ---> 0100
System.out.println(Integer.lowestOneBit(12));
// rotateLeft(int i, int distance)：返回根据指定的位数循环左移指定的 int 值的二进制补码表示形式而得到的值。
// 二进制左移一位相当于乘以2，左移distance相当于乘以2^distance
System.out.println(Integer.rotateLeft(12, 3));
System.out.println(Integer.rotateLeft(3, 2));
// rotateRight(int i, int distance)：返回根据指定的位数循环右移指定的 int 值的二进制补码表示形式而得到的值。
// 二进制右移一位相当于除以2，左移distance相当于除以2^distance
System.out.println(Integer.rotateRight(12, 2));
// 不同进制之间互相转换
// 字符串十进制转成二进制
System.out.println(Integer.toBinaryString(14));
System.out.println(Integer.toString(14, 2));
// 字符串十进制转成八进制
System.out.println(Integer.toOctalString(14));
System.out.println(Integer.toString(14, 8));
// 字符串十进制转成十六进制
System.out.println(Integer.toHexString(14));
System.out.println(Integer.toString(14, 16));
// toString可以方便得将Integer转换为任意进制
System.out.println(Integer.toString(14, 7));
// valueOf以及parseInt可将任意进制表示的字符串转换为Integer
// 提供的进制参数表示用该进制基数来解析字符串，转换为10进制的int值
System.out.println(Integer.valueOf("0110", 2));
System.out.println(Integer.valueOf("A6", 16));
System.out.println(Integer.parseInt("0110", 2));
System.out.println(Integer.parseInt("A6", 16));
}
}

package com.zxt.integer;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* 问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
输入格式： 输入的第一行为一个正整数n （1<=n<=10）。
接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式： 输出n行，每行为输入对应的八进制正整数。
注意： 输入的十六进制数不会有前导0，比如012A。 输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
提示： 先将十六进制数转换成某进制数，再由某进制数转换成八进制。
*/
public class Main14 {
public static void main(String args[]) throws NumberFormatException, IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
int n = Integer.parseInt(br.readLine());
String[] str = new String[n];
for (int i = 0; i < n; i++) {
str[i] = br.readLine();
}
for (int j = 0; j < n; j++) {
transform(str[j]);
}
// 可以直接使用Integer类的方法实现转化
// valueOf(String s, int radix) 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。
for (int j = 0; j < n; j++) {
// 输入的是16进制的字符串，先将其转换为整数
int int_16 = Integer.valueOf(str[j], 16);
// toOctalString(int i)：以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
String str_8 = Integer.toOctalString(int_16);
System.out.println(str_8);
}
}
public static void transform(String s) {
StringBuffer st = new StringBuffer();
char c[] = s.toCharArray();
// 将十六进制转化为二进制字符串
for (int i = 0; i < c.length; i++) {
switch (c[i]) {
case '0': {
st.append("0000");
break;
}
case '1': {
st.append("0001");
break;
}
case '2': {
st.append("0010");
break;
}
case '3': {
st.append("0011");
break;
}
case '4': {
st.append("0100");
break;
}
case '5': {
st.append("0101");
break;
}
case '6': {
st.append("0110");
break;
}
case '7': {
st.append("0111");
break;
}
case '8': {
st.append("1000");
break;
}
case '9': {
st.append("1001");
break;
}
case 'A': {
st.append("1010");
break;
}
case 'B': {
st.append("1011");
break;
}
case 'C': {
st.append("1100");
break;
}
case 'D': {
st.append("1101");
break;
}
case 'E': {
st.append("1110");
break;
}
case 'F': {
st.append("1111");
break;
}
}
}
// 将二进制转化为8进制
transform_02(st);
}
public static void transform_02(StringBuffer s) {
int i = s.length();
// 3位二进制是一位8进制，所以需要补齐二进制字符串为3的倍数
if (i % 3 == 0) {
if (s.substring(0, 3).equals("000")) {
s.delete(0, 3);
}
}
if (i % 3 == 1) {
if (s.substring(0, 1).equals("0")) {
s.delete(0, 1);
} else {
s.insert(0, "00");
}
}
if (i % 3 == 2) {
if (s.substring(0, 2).equals("00")) {
s.delete(0, 2);
} else {
s.insert(0, "0");
}
}
int n = s.length() / 3;
String[] s1 = new String[n];
StringBuffer sbf = new StringBuffer();
for (int j = 0; j < n; j++) {
// 3位二进制
s1[j] = s.substring(j * 3, j * 3 + 3);
if (s1[j].equals("000")) {
sbf.append("0");
}
if (s1[j].equals("001")) {
sbf.append("1");
}
if (s1[j].equals("010")) {
sbf.append("2");
}
if (s1[j].equals("011")) {
sbf.append("3");
}
if (s1[j].equals("100")) {
sbf.append("4");
}
if (s1[j].equals("101")) {
sbf.append("5");
}
if (s1[j].equals("110")) {
sbf.append("6");
}
if (s1[j].equals("111")) {
sbf.append("7");
}
}
String s2 = sbf.toString();
System.out.println(s2);
}
}