Guava源码阅读计划:primitives.Ints

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()";
    }
}

Guava源码阅读计划:primitives.Ints

猜你喜欢