com.google.common.primitives:八种原始类型和无符号类型的静态工具包
//在java8中可以被Integer.BYTES替代,代表字节数bytes
public static final int BYTES = Integer.SIZE / Byte.SIZE;
//int最大存储值,使用 1<<(Integer.SIZE-2) 计算得到,2是因为一位代表正负,1同时占一位
public static final int MAX_POWER_OF_TWO = 1 << (Integer.SIZE - 2);
public static int hashCode(int value) {
//int类型的hashcode是其本身
return value;
}
public static int indexOf(int[] array, int[] target) {
//这里进行了入参校验 可能是因为两个入参 如果报空指针则不知道是哪个参数引起的
checkNotNull(array, "array");
checkNotNull(target, "target");
if (target.length == 0) {
return 0;
}
//...
}
public static int indexOf(int[] array, int target) {
return indexOf(array, target, 0, array.length);
}
//这两个方法都没有进行入参校验 可能因为入参格式不同 可以清楚的知道是哪个参数的问题
private static int indexOf(int[] array, int target, int start, int end) {
for (int i = start; i < end; i++) {
if (array[i] == target) {
return i;
}
}
return -1;
}
public static byte[] toByteArray(int value) {
return new byte[] {
//将Int数据按照大端拆成4个字节的数组
(byte) (value >> 24), (byte) (value >> 16), (byte) (value >> 8), (byte) value
};
}
public static int fromByteArray(byte[] bytes) {
//int类型4字节 如果不够4字节不能转成int
checkArgument(bytes.length >= BYTES, "array too small: %s < %s", bytes.length, BYTES);
return fromBytes(bytes[0], bytes[1], bytes[2], bytes[3]);
}
public static int fromBytes(byte b1, byte b2, byte b3, byte b4) {
//使用大端拼接,每一个&0xff是为了清除额外数据(特殊情况),保证数据的正确。再使用 | 拼接。
return b1 << 24 | (b2 & 0xFF) << 16 | (b3 & 0xFF) << 8 | (b4 & 0xFF);
}
public static String join(String separator, int... array) {
checkNotNull(separator);
if (array.length == 0) {
return "";
}
// 相对于预先确定StringBuilder的准确大小而言,只需获得正确的数量级就可以了 (Guava注释)
// 原因是:int数组转换成String的时候位数不能直接对数组进行.length()
// 需要遍历数组中的每一个元素,并计算其中数字的长度,时间复杂度比较高.所以大概估计一个5倍的长度.
StringBuilder builder = new StringBuilder(array.length * 5);
builder.append(array[0]);
for (int i = 1; i < array.length; i++) {
builder.append(separator).append(array[i]);
}
return builder.toString();
}
public static List<Integer> asList(int... backingArray) {
if (backingArray.length == 0) {
return Collections.emptyList();
}
return new IntArrayAsList(backingArray);
}
//主要关注IntArrayAsList
private static class IntArrayAsList extends AbstractList<Integer>
implements RandomAccess, Serializable {
final int[] array;
final int start;
final int end;
IntArrayAsList(int[] array) {
this(array, 0, array.length);
}
//通过其构造方法发现其是一个视图类,并没有进行数据的拷贝,而仅仅是做了一个包装
IntArrayAsList(int[] array, int start, int end) {
this.array = array;
this.start = start;
this.end = end;
}
}
//数组间比较器 比较条件:将数组元素anindex一一对应比较,直到某个index的元素按字典序较大即为对应数组较大,如果两数组前缀相同则比较长度
public static Comparator<int[]> lexicographicalComparator() {
return LexicographicalComparator.INSTANCE;
}
private enum LexicographicalComparator implements Comparator<int[]> {
//使用枚举类实现单例,调用LexicographicalComparator.INSTANCE就可以进行访问。
//相比较于返回new对象,更快。相比全局变量,不影响全局空间。
INSTANCE;
@Override
public int compare(int[] left, int[] right) {
int minLength = Math.min(left.length, right.length);
for (int i = 0; i < minLength; i++) {
int result = Ints.compare(left[i], right[i]);
if (result != 0) {
return result;
}
}
return left.length - right.length;
}
@Override
public String toString() {
return "Ints.lexicographicalComparator()";
}
}