//八大基本数据类型：byte、int、short、long、double、float、boolean、char
//八大包装类型：Byte、Integer、Short、Long、Double、Float、Boolean、Character
//包装类都是被final修饰的,不可以被继承(由于被final修饰)
//继承Number
//实现了比较接口(需要重写compareTo方法)
//继承于Number类(该类继承了Serializable(序列化)接口),需要重写各种xxxValue方法
//Number类是java.lang包下的一个抽象类,提供了将包装类型拆箱成基本类型的方法，所有基本类型的包装类型都继承了该抽象类，并且包装类都用final修饰为不可继承类
//xxxValue方法就是转换成对应的类型
//自动装箱也就是调用了Integer类的一个静态方法valueOf方法(该方法返回Integer对象)
public final class Integer extends Number implements Comparable<java.lang.Integer> {
//最小值常量(十六进制补码形式表示):-2<sup>31</sup>
@Native
public static final int MIN_VALUE = 0x80000000;
//最大值常量(十六进制补码形式表示):2<sup>31</sup>-1
@Native
public static final int MAX_VALUE = 0x7fffffff;
//常量TYPE保存了当前包装类的对应的基本数据类型的Class实例
//getPrimitiveClass----native方法
@SuppressWarnings("unchecked")
public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
//digits数组常量：表示数字的所有可能的字符，int支持二进制到三十六进制(故需要36个字符)
final static char[] digits = {
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'a', 'b',
'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z'
};
/**
* 静态toString方法转化对应进制的数字为十进制
* @param i 整型的数字
* @param radix 该数字的进制
* @return 返回一个字符串
*/
public static String toString(int i, int radix) {
//若输入的进制不在二到三十六进制之间，则直接当十进制处理
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
radix = 10;
//为十进制时,调用另一个静态方法直接输出
if (radix == 10) {
return toString(i);
}
//创建一个33位的字符数组(负数时:1位符号位+32位数字；正数时,32位数字)
char buf[] = new char[33];
//判断当前数字的正负性
boolean negative = (i < 0);
int charPos = 32;
//将正数转为负数进行运算，防止负数转为正数的溢出情况
if (!negative) {
i = -i;
}
//循环到i小于进制的负数
//根据余数通过digits数组取到对应的字符，然后存到char数组即可。
while (i <= -radix) {
//
buf[charPos--] = digits[-(i % radix)];
i = i / radix;
}
buf[charPos] = digits[-i];
//若是负数，加上'-'符
if (negative) {
buf[--charPos] = '-';
}
//创建一个字符串 char数组、起始位置、字符总数
return new String(buf, charPos, (33 - charPos));
}
//将某进制的int类型数字转为long类型数字，最后转为String类型返回
public static String toUnsignedString(int i, int radix) {
return Long.toUnsignedString(toUnsignedLong(i), radix);
}
//转为十六进制字符串
//底层采用toUnsignedString()方法
public static String toHexString(int i) {
//shift为2的多少次方
return toUnsignedString0(i, 4);
}
//转为八进制字符串
//底层采用toUnsignedString()方法
public static String toOctalString(int i) {
return toUnsignedString0(i, 3);
}
//转为二进制字符串
//底层采用toUnsignedString()方法
public static String toBinaryString(int i) {
return toUnsignedString0(i, 1);
}
/**
* 将整型对象转为一个无符号的数字
* @param val
* @param shift
* @return
*/
private static String toUnsignedString0(int val, int shift) {
// assert shift > 0 && shift <=5 : "Illegal shift value";
//
int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
int chars = Math.max(((mag + (shift - 1)) / shift), 1);
char[] buf = new char[chars];
formatUnsignedInt(val, shift, buf, 0, chars);
// Use special constructor which takes over "buf".
return new String(buf, true);
}
/**
*填充字符数组
* @param val
* @param shift
* @param buf
* @param offset
* @param len
* @return
*/
static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
int charPos = len;
int radix = 1 << shift;
int mask = radix - 1;
do {
buf[offset + --charPos] = java.lang.Integer.digits[val & mask];
val >>>= shift;
} while (val != 0 && charPos > 0);
return charPos;
}
/**
* DigitTens和DigitOnes这两个常量数组主要是为了获取0到99之间某个数的十位和个位。
*/
//取十位数
final static char[] DigitTens = {
'0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
'1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
'2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
'3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
'4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
'5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
'6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
'7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
'8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
'9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
};
//取个位数
final static char[] DigitOnes = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
};
/**
* 静态toString方法
* @param i 一个被转化的int值
* @return
*/
public static String toString(int i) {
//如果最小的情况
if (i == Integer.MIN_VALUE)
//返回-2^31
return "-2147483648";
//将负数取反为正数，然后计算数字是多少位的
int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
//创建对应数字位数的char数组
char[] buf = new char[size];
//将数字分成一个个char，保存到buf数组中
getChars(i, size, buf);
//该String构造函数,直接将传入的参数数组的引用给了内部数组，节省时间，共享内部数组节约内存，不像String(char [] buf)构造函数，使用Arrays.copyOf()方法重新创建一个char数组对象
return new String(buf, true);
}
//将int类型的数字转为Long无符号类型，然后将Long类型转为String类型
public static String toUnsignedString(int i) {
return Long.toString(toUnsignedLong(i));
}
//将某个int型数值写入到字符数组中（若i等于Integer.MIN_VALUE,则为失败）
//该方法将int进行高两字节、低两字节分开处理
//几种运算的耗时长短:除法运算>乘法运算>移位结合加法的运算
//index一般为数的长度
static void getChars(int i, int index, char[] buf) {
int q, r;
//字符的位置
int charPos = index;
char sign = 0;
//如果i为负数,则将负数标志置为-
//然后将i取反，将负号去掉，取数值部分
if (i < 0) {
sign = '-';
i = -i;
}
// Generate two digits per iteration
//处理高两字节
while (i >= 65536) {
//处理两位
q = i / 100;
// really: r = i - (q * 100);
r = i - ((q << 6) + (q << 5) + (q << 2));
//将商赋给i，继续循环，直到小于65536
i = q;
//取DigitOnes[r]的值其实取数字r%10的结果
buf[--charPos] = DigitOnes[r];
//取DigitTens[r]的值其实取数字r/10的结果
buf[--charPos] = DigitTens[r];
}
// Fall thru to fast mode for smaller numbers
// assert(i <= 65536, i);
//循环存放低两字节的数字存放到字符数组中空余位置
for (; ; ) {
//右移19位
/**
* >>>: 无符号的右移
* >>: 有符号的右移
*/
//q=i/10
q = (i * 52429) >>> (16 + 3);
//r = i-(q*10)
r = i - ((q << 3) + (q << 1));
//从digit数组中取数
buf[--charPos] = digits[r];
i = q;
//整数写入字符数组完成
if (i == 0) break;
}
//若整数是负数，需要在字符数组中加上'-'字符
if (sign != 0) {
buf[--charPos] = sign;
}
}
//用在判断一个int类型数字对应字符串的长度
final static int[] sizeTable = {9, 99, 999, 9999, 99999, 999999, 9999999,
99999999, 999999999, java.lang.Integer.MAX_VALUE}; //最大值位数为10位
// Requires positive x
//判断int型数字对应字符串的长度(不使用除法或求余等操作,和对应值来比较得到具体的位数)
static int stringSize(int x) {
for (int i = 0; ; i++)
if (x <= sizeTable[i])
return i + 1;
}
/**
*
* @param s 待转换的字符串
* @param radix 当前字符串的数字部分的进制数(也就是s的进制)
* @return 返回十进制的数
* @throws NumberFormatException
* 该方法使用负数进行运算(原因：Integer.MIN_VALUE变为正数时大于Integer.MAX_VALUE，会导致数值溢出)
*/
public static int parseInt(String s, int radix)
throws NumberFormatException {
/*
* WARNING: This method may be invoked early during VM initialization
* before IntegerCache is initialized. Care must be taken to not use
* the valueOf method.
*/
//NumberFormatException:将一个字符串转为数字类型，该字符串不能有一个适当地转化结果，而抛出该异常
//字符串不为空
if (s == null) {
throw new NumberFormatException("null");
}
//字符串的进制最少为二进制
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
//字符串的进制最大为36进制
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
//保存转化结果
int result = 0;
//当前数是否为负数
boolean negative = false;
//i表示当前的转化的字符串的下标
int i = 0, len = s.length();
//判断值----正数情况下使用(默认情况)
int limit = -java.lang.Integer.MAX_VALUE;
int multmin;
int digit;
//字符串长度大于0
if (len > 0) {
//根据第一个字符判断当前字符串的正负
//获取字符串的第一个字符
char firstChar = s.charAt(0);
//第一个字符小于0的情况
if (firstChar < '0') { // Possible leading "+" or "-"
//负数
if (firstChar == '-') {
negative = true;
//限制值
limit = java.lang.Integer.MIN_VALUE;
} else if (firstChar != '+') //不为正数
throw NumberFormatException.forInputString(s);
//输入的转化字符串只有一个"+"或"-"
if (len == 1) // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
i++;
}
//限制的最小值(在对应进制的)
multmin = limit / radix;
//将字符串的数字部分转为十进制的数字(从左到右)
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
//将字符串的数字部分的一个数字(对应进制)，通过Character类转为十进制的数
//若字符串中的某一个字符，在字符串进制下(radix)是无效的，则返回-1
digit = Character.digit(s.charAt(i++), radix);
//若返回-1(无效)
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
//结果小于最小的值(目标进制下)
if (result < multmin) {
throw NumberFormatException.forInputString(s);
}
//结果：将结果乘上字符串进制数
result *= radix;
//若结果小于最小值加上当前最字符值
if (result < limit + digit) {
throw NumberFormatException.forInputString(s);
}
//将结果减去当前字符的值
result -= digit;
}
} else {
throw NumberFormatException.forInputString(s);
}
//若是负数，则直接返回，若是正数，先取反结果再输出
return negative ? result : -result;
}
//默认情况下字符串中的数字是十进制的(也就是radix是十进制)
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s, 10);
}
/**
* 字符串转为无符号的整型数
* @param s 原字符串
* @param radix 原字符串的进制
* @return 返回int类型的数字
* @throws NumberFormatException
*/
public static int parseUnsignedInt(String s, int radix)
throws NumberFormatException {
//不能为空
if (s == null) {
throw new NumberFormatException("null");
}
int len = s.length();
//字符串长度得大于0
if (len > 0) {
char firstChar = s.charAt(0);
//若是负数，则抛出数字转化异常(无符号字符串上的非法前置减号)
if (firstChar == '-') {
throw new
NumberFormatException(String.format("Illegal leading minus sign " +
"on unsigned string %s.", s));
} else { //
if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
(radix == 10 && len <= 9)) { // Integer.MAX_VALUE in base 10 is 10 digits
return parseInt(s, radix);
} else {
//将字符串转为long类型数据(radix进制)
long ell = Long.parseLong(s, radix);
//只有低4字节有数,则强转为4字节的int类型，然后输出
if ((ell & 0xffff_ffff_0000_0000L) == 0) {
return (int) ell;
} else { //否则抛出字符串的值超过了无符号整型的范围
throw new
NumberFormatException(String.format("String value %s exceeds " +
"range of unsigned int.", s));
}
}
}
} else {
throw NumberFormatException.forInputString(s);
}
}
//径字符串转为无符号整数，该方法默认字符串中数字为十进制
public static int parseUnsignedInt(String s) throws NumberFormatException {
return parseUnsignedInt(s, 10);
}
//将某进制的字符串转为int类型的数字
public static java.lang.Integer valueOf(String s, int radix) throws NumberFormatException {
return java.lang.Integer.valueOf(parseInt(s, radix));
}
public static java.lang.Integer valueOf(String s) throws NumberFormatException {
//将传入的字符串按照十进制转化为int类型数字，然后调用valueOf(int i)静态方法获得
return java.lang.Integer.valueOf(parseInt(s, 10));
}
//代码执行优先级：静态代码块(一个类)>代码块>构造函数
//内部类IntegerCache类 ------ 包含了int可能值的Integer数组,默认范围是-128到127，所以这里就默认只实例化256个Integer对象(在该范围内时,则直接从缓存中获取对应的Integer对象，不必重新实例化)
//
private static class IntegerCache {
static final int low = -128;
//高值可以通过属性配置:启动JVM时通过 -Djava.lang.Integer.IntegerCache,high=xxx进行设置
static final int high;
static final java.lang.Integer cache[];
//
static {
// high value may be configured by property
int h = 127;
//读取JVM启动时的缓存值的最大值配置
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, java.lang.Integer.MAX_VALUE - (-low) - 1);
} catch (NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
//未配置则为默认最高值127
high = h;
//创建一个大小为(最大值-最小值+1)的数组
cache = new java.lang.Integer[(high - low) + 1];
int j = low;
//创建对应大小的Integer对象,放入缓存的数组中
for (int k = 0; k < cache.length; k++)
cache[k] = new java.lang.Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
//保证Integer缓存最大值必须大于等于127(该断言在发现缓存最大值小于127时，会抛出AssertionError)
assert java.lang.Integer.IntegerCache.high >= 127;
}
private IntegerCache() {
}
}
//该方法直接获得在[low,high]范围内的IntegerCache缓存的Integer对象，不在该范围则重新实例化Integer对象
public static java.lang.Integer valueOf(int i) {
if (i >= java.lang.Integer.IntegerCache.low && i <= java.lang.Integer.IntegerCache.high)
return java.lang.Integer.IntegerCache.cache[i + (-java.lang.Integer.IntegerCache.low)];
return new java.lang.Integer(i);
}
//保存Integer类中的真实基本数据类型的值
private final int value;
//参数为int类型的构造函数
public Integer(int value) {
this.value = value;
}
//参数为String类型(其中包含的数字必须是十进制的)构造函数
public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);
}
//将int类型的值强转为byte类型
public byte byteValue() {
return (byte) value;
}
//将int类型的值强转为short类型
public short shortValue() {
return (short) value;
}
//输出Integer类对应的基本数据类型int值(Integer类中有个int value专门保存其基本类型的值)
public int intValue() {
return value;
}
//将int类型的值强转为long类型
public long longValue() {
return (long) value;
}
//将int类型的值强转为float类型
public float floatValue() {
return (float) value;
}
//将int类型的值强转为double类型
public double doubleValue() {
return (double) value;
}
//输出Integer类中存放基本数据类型真实值的value变量。
public String toString() {
return toString(value);
}
//返回int类型的值
@Override
public int hashCode() {
return Integer.hashCode(value);
}
//返回int类型的值(自己的静泰方法)
public static int hashCode(int value) {
return value;
}
public boolean equals(Object obj) {
//先比较是不是Integer类型，不是,则直接返回false，否则再比较值,
if (obj instanceof java.lang.Integer) {
return value == ((java.lang.Integer) obj).intValue();
}
return false;
}
/**
* 返回系统常量的int值,类似System.getProperty(str);
* @param nm 系统变量名(类似于key)
* @return
*/
public static Integer getInteger(String nm) {
return getInteger(nm, null);
}
/**
*
* @param nm 系统常量名(也即是key)
* @param val 若为该名字的系统常量的值为null，则返回该值的Integer对象
* @return
*/
public static Integer getInteger(String nm, int val) {
Integer result = getInteger(nm, null);
return (result == null) ? Integer.valueOf(val) : result;
}
/**
*
* @param nm
* @param val
* @return
*/
public static Integer getInteger(String nm, Integer val) {
String v = null;
try {
//获取对应系统变量名的值
v = System.getProperty(nm);
} catch (IllegalArgumentException | NullPointerException e) {
}
if (v != null) {
try {
//返回字符串中的数字
return Integer.decode(v);
} catch (NumberFormatException e) {
}
}
//该系统变量名对应的值为null,则返回默认值
return val;
}
//作用：解码字符串转成Integer型对象
public static Integer decode(String nm) throws NumberFormatException {
//十进制
int radix = 10;
//当前判断完的字符数
int index = 0;
//非负标志
boolean negative = false;
//返回结果
java.lang.Integer result;
//字符串长度为0，则抛出数字转化异常
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
//然后剩下的字符串以0x或0X开头，表示十六进制
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) { //若以0开头，且字符串长度大于当前判断字符数+1,,则为8进制
index++;
radix = 8;
}
//再存在"-"/"+"这两字符，则抛出数字转化异常
if (nm.startsWith("-", index) || nm.startsWith("+", index))
throw new NumberFormatException("Sign character in wrong position");
try {
//将剩下的字符串从某进制转为十进制的数的包装类对象
result = java.lang.Integer.valueOf(nm.substring(index), radix);
//若是负数,取反包装类Integer中的value的值,再进行获取该基本数据类型的包装对象实例
result = negative ? java.lang.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.
//使用int类型参数转化出现异常，转而使用String类型参数进行转化
String constant = negative ? ("-" + nm.substring(index))
: nm.substring(index);
//转化字符串成对应的包装类的实例对象
result = java.lang.Integer.valueOf(constant, radix);
}
return result;
}
/**
* 比较两个包装类(Integer)对象中保存基本数据类型值的value是否相等
* 小于 返回-1
* 等于 返回0
* 大于 返回1
*/
public int compareTo(java.lang.Integer anotherInteger) {
return compare(this.value, anotherInteger.value);
}
/**
* 比较两个int类型的数据
* 小于 返回-1
* 等于 返回0
* 大于 返回1
*/
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
//将两个整数转换为无符号整数后比较大小
public static int compareUnsigned(int x, int y) {
return compare(x + MIN_VALUE, y + MIN_VALUE);
}
//将int型数据转成无符号long类型数
public static long toUnsignedLong(int x) {
return ((long) x) & 0xffffffffL;
}
/**
*求无符号数的商
* @param dividend 除数
* @param divisor 被除数
* @return
*/
public static int divideUnsigned(int dividend, int divisor) {
//为了避免复杂的代码，将int型的除数和被除数转为对应的无符号的Long类型并得到商
return (int) (toUnsignedLong(dividend) / toUnsignedLong(divisor));
}
/**
* 求无符号数的余数
* @param dividend 除数
* @param divisor 被除数
* @return
*/
public static int remainderUnsigned(int dividend, int divisor) {
//为了避免复杂的代码，将int型的除数和被除数转为对应的无符号的Long类型并进行求余
return (int) (toUnsignedLong(dividend) % toUnsignedLong(divisor));
}
//静态常量SIZE用来表四二进制补码形式的int值的比特数，值为32
@Native
public static final int SIZE = 32;
//静态常量BYTES表示二进制补码形式的int值得字节数
//Byte.SIZE=8 也就是8位等于一字节
//BYTES=4 也就是4字节
public static final int BYTES = SIZE / Byte.SIZE;
//返回在二进制情况下，i的最高位为1，其他全为0的值。
//将31位都置为1,然后将该值减去该值右移一位的值
public static int highestOneBit(int i) {
//右移一位或上原值
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
//i值减去i右移一位的值
return i - (i >>> 1);
}
//获取最低位为1，其他位都为0的值
//具体操作：①先取负数(对正数的i取反码然后加1)，得到的结果和i进行与操作。
public static int lowestOneBit(int i) {
// HD, Section 2-1
return i & -i;
}
//返回i的二进制从头开始有多少个0
public static int numberOfLeadingZeros(int i) {
// HD, Figure 5-6
//i为0，则有32个0
if (i == 0)
return 32;
int n = 1;
//使用二分查找(也就是折半查找)思想，看右移16、24、28、30、31位的结果是否为0
if (i >>> 16 == 0) {
n += 16;
i <<= 16;
}
if (i >>> 24 == 0) {
n += 8;
i <<= 8;
}
if (i >>> 28 == 0) {
n += 4;
i <<= 4;
}
if (i >>> 30 == 0) {
n += 2;
i <<= 2;
}
n -= i >>> 31;
return n;
}
// 返回i的二进制从尾开始有多少个0
//基于二分查找
public static int numberOfTrailingZeros(int i) {
int y;
if (i == 0) return 32;
int n = 31;
y = i << 16;
if (y != 0) {
n = n - 16;
i = y;
}
y = i << 8;
if (y != 0) {
n = n - 8;
i = y;
}
y = i << 4;
if (y != 0) {
n = n - 4;
i = y;
}
y = i << 2;
if (y != 0) {
n = n - 2;
i = y;
}
return n - ((i << 1) >>> 31);
}
//计算二进制数中1的个数
public static int bitCount(int i) {
//每两位一组统计看有多少个1
//0x55555555也就是01010101010101010101010101010101
i = i - ((i >>> 1) & 0x55555555);
//每四位一组统计看有多少个1
//0x33333333也就是110011001100110011001100110011
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
//每八位的1的个数
//0x0f0f0f0f也就是00001111000011110000111100001111
i = (i + (i >>> 4)) & 0x0f0f0f0f;
//每16位
i = i + (i >>> 8);
//每32位
i = i + (i >>> 16);
//最终与0x3f进行与运算，得到的结果，就是1的个数
return i & 0x3f;
}
//返回根据指定的位数循环左移指定的 int 值的二进制补码表示形式而得到的值。
public static int rotateLeft(int i, int distance) {
return (i << distance) | (i >>> -distance);
}
//返回根据指定的位数循环右移指定的 int 值的二进制补码表示形式而得到的值
public static int rotateRight(int i, int distance) {
return (i >>> distance) | (i << -distance);
}
//对i进行反转,反转也就是第1位和第32位对调，第2位和第31位对调等
public static int reverse(int i) {
//将相邻两位进行对调
i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
//将相邻四位进行对调
i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
//将相邻的八位进行对调
i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
//32位中的中间16对调,最高八位和最低八位对调
i = (i << 24) | ((i & 0xff00) << 8) |
((i >>> 8) & 0xff00) | (i >>> 24);
return i;
}
// 返回指定 int 值的符号函数
public static int signum(int i) {
/**
* 指定值i,为负数 返回-1
* 为零 返回0
* 为正数 返回1
*/
//也就是返回最高位
return (i >> 31) | (-i >>> 31);
}
//按位进行反转
public static int reverseBytes(int i) {
return ((i >>> 24)) | //第1字节
((i >> 8) & 0xFF00) | //第二字节
((i << 8) & 0xFF0000) | //第三字节
((i << 24)); //第四字节
}
/**
* 加法
* @param a 加数1
* @param b 加数2
* @return 和
*/
public static int sum(int a, int b) {
return a + b;
}
/**
* 最大值
* @param a 参数1
* @param b 参数2
* @return 两个参数中大的那个
*/
public static int max(int a, int b) {
return Math.max(a, b);
}
/**
* 最小值
* @param a 参数1
* @param b 参数2
* @return 两个参数中小的那个
*/
public static int min(int a, int b) {
return Math.min(a, b);
}
@Native
//序列号
private static final long serialVersionUID = 1360826667806852920L;
}
}
226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
