coding……
但行好事 莫问前程

Guava元语工具

Java中存在八中基本类型byte、short、int、long、float、double、char和boolean,基本类型不能当作对象或泛型的类型参数使用,这意味着许多通用方法都不能应用于它们。Guava提供了若干通用工具,包括基本类型数组与集合API的交互,基本类型和字节数组的相互转换,以及对某些基本类型的无符号形式的支持。

基本类型 Guava工具类
byte Bytes, SignedBytes, UnsignedBytes
short Shorts
int Ints, UnsignedInteger, UnsignedInts
long Longs, UnsignedLong, UnsignedLongs
char Chars
float Floats
double Doubles
boolean Booleans
  • Ints

S.N. 方法及说明
1 static List<Integer> asList(int… backingArray)
基本类型数组转化为包装类List
2 static int checkedCast(long value)
long转int,如果long值超出int范围抛IllegalArgumentException
3 static int compare(int a, int b)
比较两个int值的大小
4 static int[] concat(int[]… arrays)
将多个int数组拼接成一个数组
5 static int constrainToRange(int value, int min, int max)
如果一个数字在某个范围内则输出该数字,否则输出范围的最大值或最小值
6 static boolean contains(int[] array, int target)
判断一个int数是否在int数组内
7 static int[] ensureCapacity(int[] array, int minLength, int padding)
确保数组拥有一个最小的长度,如果array长度小于minLength,则会返回一个元素值与array相同,但是length = minLength + padding的数组
8 static int fromByteArray(byte[] bytes)
通过byte数组前四个元素转int值
9 static int fromBytes(byte b1, byte b2, byte b3, byte b4)
通过四个byte元素转int值
10 static int hashCode(int value)
返回int值的hashCode(hashCode等于元素值)
11 static int indexOf(int[] array, int target)
返回一个int值在数组中的第一个index,没匹配到返回-1
static int indexOf(int[] array, int[] target)
返回int数组在另一个数组中的第一个index,没匹配到返回-1
12 static String join(String separator, int… array)
通过连接符连接数组转成String
13 static int lastIndexOf(int[] array, int target)
返回一个int值在数组中的最后一个index,没匹配到返回-1
14 static Comparator<int[]> lexicographicalComparator()
返回一个int[]比较器,比较规则是从index0开始比较两个数组对应index上的元素大小,返回比较结果到其中一个数组结束都完全一致,则通过长度比较,长度大的那个数组大
15 static int max(int… array)
返回一个int数组的最大元素
16 static int min(int… array)
返回一个int数组的最小元素
17 static void reverse(int[] array)
将数组反转
static void reverse(int[] array, int fromIndex, int toIndex)
将数组指定范围的元素反转(范围左闭右开)
18 static int saturatedCast(long value)
将long转化为int,与checkedCast不通的是超出int范围不会抛IllegalArgumentException异常,会转化为int最大值2147483647
19 static void sortDescending(int[] array)
数组按逆序排序
static void sortDescending(int[] array, int fromIndex, int toIndex)
将一定范围内的数组按照逆序排序(范围左闭右开)
20 static Converter<String, Integer> stringConverter()
返回String与Integer的转换器
21 static int[] toArray(Collection<? extends Number> collection)
List转数组
22 static byte[] toByteArray(int value)
int值转byte数组(byte数组长度为4)
23 static Integer tryParse(String string)
十进制String转Integer, 如果String值存在非法字符,转为null
static Integer tryParse(String string, int radix)
radix进制String转Integer, 如果String值存在非法字符,转为null

实例代码:

public class IntsTest {
    @Test
    public void asListTest() {
        /*基本类型数组转化为包装类List*/
        int[] intArray = {1, 2, 3, 4, 5};

        List<Integer> result = Ints.asList(intArray);
        assertThat(result, contains(1, 2, 3, 4, 5));
    }

    @Test
    public void checkedCastTest() {
        /*long转int,如果long值超出int范围抛IllegalArgumentException*/
        long input = 9998L;
        int result = Ints.checkedCast(input);
        assertEquals(9998, result);

        long input1 = 2147483648L;
        assertThatThrownBy(() -> Ints.checkedCast(input1)).isInstanceOf(IllegalArgumentException.class)
                .hasMessage("Out of range: 2147483648").hasNoCause();
    }

    @Test
    public void compareTest() {
        /*比较两个int值的大小*/
        assertEquals(-1, Ints.compare(1, 2));
        assertEquals(0, Ints.compare(1, 1));
        assertEquals(1, Ints.compare(2, 1));
    }

    @Test
    public void concatTest() {
        /*将多个int数组拼接成一个数组*/
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};
        int[] array3 = {7, 8};
        int[] result = Ints.concat(array1, array2, array3);
        assertEquals(8, result.length);
    }

    @Test
    public void constrainToRangeTest() {
        /*如果一个数字在某个范围内则输出该数字,否则输出范围的最大值或最小值*/
        int result = Ints.constrainToRange(5, 0, 9);
        assertEquals(5, result);
        assertEquals(9, Ints.constrainToRange(10, 0, 9));
        assertEquals(0, Ints.constrainToRange(-1, 0, 9));
    }

    @Test
    public void containsTest() {
        /*判断一个int数是否在int数组内*/
        int[] array = {1, 2, 3, 4};
        assertTrue(Ints.contains(array, 3));
    }

    @Test
    public void ensureCapacityTest() {
        /*确保数组拥有一个最小的长度*/
        int[] array = {1, 2, 3, 4};
        int[] result = Ints.ensureCapacity(array, 6, 3);
        assertEquals(9, result.length);

        int[] result1 = Ints.ensureCapacity(array, 3, 3);
        assertEquals(4, result1.length);
    }

    @Test
    public void fromByteArrayTest() {
        /*通过byte数组前四个元素转int值*/
        byte[] byteArray = {1, 1, 1, 1};
        int result = Ints.fromByteArray(byteArray);
        assertEquals(16843009, result);
    }

    @Test
    public void fromBytesTest() {
        /*通过四个byte元素转int值*/
        int result = Ints.fromBytes((byte) 1, (byte) 1, (byte) 1, (byte) 1);
        assertEquals(16843009, result);
    }

    @Test
    public void hashCodeTest() {
        /*返回int值的hashCode(元素值)*/
        int hashCode = Ints.hashCode(1);
        assertEquals(1, hashCode);
    }

    @Test
    public void indexOfTest() {
        /*返回一个int值在数组中的第一个index,没匹配到返回-1*/
        int[] array = {1, 2, 3, 4, 3};
        assertEquals(2, Ints.indexOf(array, 3));
        assertEquals(-1, Ints.indexOf(array, 5));
    }

    @Test
    public void arrayIndexOf() {
        /*返回int数组在另一个数组中的第一个index,没匹配到返回-1*/
        int[] array = {1, 2, 3, 4, 6, 5, 8};
        int[] target = {6, 5};
        assertEquals(4, Ints.indexOf(array, target));
    }

    @Test
    public void joinTest() {
        /*通过连接符连接数组转成String*/
        String str = "-";
        assertEquals("1-2-3", Ints.join(str, 1, 2, 3));
    }

    @Test
    public void lastIndexOfTest() {
        /*返回一个int值在数组中的最后一个index,没匹配到返回-1*/
        int[] array = {1, 2, 3, 4, 3};
        assertEquals(4, Ints.lastIndexOf(array, 3));
        assertEquals(-1, Ints.lastIndexOf(array, 5));
    }

    @Test
    public void lexicographicalComparatorTest() {
        /*返回一个int[]比较器,比较规则是从index0开始比较两个数组对应index上的元素大小,返回比较结果
         * 到其中一个数组结束都完全一致,则通过长度比较,长度大的那个数组大*/
        Comparator<int[]> comparator = Ints.lexicographicalComparator();
        int[] array1 = {1, 2, 3};
        int[] array2 = {1, 3, 3};
        int result = comparator.compare(array1, array2);
        assertEquals(-1, result);
    }

    @Test
    public void maxMinTest() {
        /*返回一个数组的最大元素*/
        int[] array = {1, 16, 3, 5, 3};
        int max = Ints.max(array);
        assertEquals(16, max);

        int min = Ints.min(array);
        assertEquals(1, min);
    }

    @Test
    public void reverseTest() {
        /*将数组反转*/
        int[] array = {1, 16, 3, 5, 3};
        Ints.reverse(array);
        List<Integer> reverseList = Ints.asList(array);
        assertThat(reverseList, contains(3, 5, 3, 16, 1));

        /*将数组指定范围的元素反转(范围左闭右开)*/
        int[] array1 = {1, 16, 8, 5, 3};
        Ints.reverse(array1, 0, 2);
        List<Integer> reverseList1 = Ints.asList(array1);
        System.out.println(reverseList1);
        assertThat(reverseList1, contains(16, 1, 8, 5, 3));
    }

    @Test
    public void saturatedCastTest() {
        /*将long转化为int,超出int范围转化为2147483647*/
        long input = 9998L;
        int result = Ints.saturatedCast(input);
        assertEquals(9998, result);

        long input1 = 2147483648L;
        int result1 = Ints.saturatedCast(input1);
        assertEquals(2147483647, result1);
    }

    @Test
    public void sortDescendingTest() {
        /*数组按逆序排序*/
        int[] array = {1, 16, 8, 5, 3};
        Ints.sortDescending(array);
        List<Integer> sortList = Ints.asList(array);
        assertThat(sortList, contains(16, 8, 5, 3, 1));

        int[] array1 = {1, 16, 8, 5, 3};
        /*将一定范围内的数组按照逆序排序(范围左闭右开)*/
        Ints.sortDescending(array1, 0, 3);
        List<Integer> sortList1 = Ints.asList(array1);
        assertThat(sortList1, contains(16, 8, 1, 5, 3));
    }

    @Test
    public void stringConverterTest() {
        /*返回String与Integer的转换器*/
        Converter<String, Integer> converter = Ints.stringConverter();
        int num = converter.convert("123");
        assertEquals(123, num);
    }

    @Test
    public void toArrayTest() {
        /*List转数组*/
        List<Integer> list = Lists.newArrayList(1, 2, 3, 4);
        int[] arr = Ints.toArray(list);
        assertEquals(1, arr[0]);
    }

    @Test
    public void toByteArrayTest() {
        /*int值转byte数组*/
        byte[] byteArray = Ints.toByteArray(1);
        assertEquals(1, byteArray[3]);
    }

    @Test
    public void tryParseTest(){
        /*十进制String转Integer, 如果String值存在非法字符,转为null*/
        Integer result = Ints.tryParse("1234");
        assertEquals(1234, result.intValue());
        assertEquals(null, Ints.tryParse("1234ahd"));

        /*radix进制String转Integer, 如果String值存在非法字符,转为null*/
        Integer result1 = Ints.tryParse("0110", 2);
        assertEquals(6, result1.intValue());
    }
}
  • Longs

S.N. 方法及说明
1 static List<Long> asList(long… backingArray)
基本类型数组转化为包装类List
2 static int compare(long a, long b)
比较两个long值的大小
3 static long[] concat(long[]… arrays)
将多个long数组拼接成一个数组
4 static long constrainToRange(long value, long min, long max)
如果一个数字在某个范围内则输出该数字,否则输出范围的最大值或最小值
5 static boolean contains(long[] array, long target)
判断一个long值是否在long数组内
6 static long[] ensureCapacity(long[] array, int minLength, int padding)
确保数组拥有一个最小的长度,如果array长度小于minLength,则会返回一个元素值与array相同,但是length = minLength + padding的数组
7 static long fromByteArray(byte[] bytes)
通过byte数组前八个元素转long值
8 static long fromBytes(byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8)
通过八个byte元素转long值
9 static int hashCode(long value)
返回long值的hashCode(hashCode = (int)(value ^ value >>> 32))
10 static int indexOf(long[] array, long target)
返回一个long值在数组中的第一个index,没匹配到返回-1
static int indexOf(long[] array, long target, int start, int end)
返回long数组在另一个数组中的第一个index,没匹配到返回-1
11 static String join(String separator, long… array)
通过连接符连接数组转成String
12 static int lastIndexOf(long[] array, long target)
返回一个long值在数组中的最后一个index,没匹配到返回-1
13 static Comparator<long[]> lexicographicalComparator()
返回一个long[]比较器,比较规则是从index0开始比较两个数组对应index上的元素大小,返回比较结果到其中一个数组结束都完全一致,则通过长度比较,长度大的那个数组大
14 static long max(long… array)
返回一个long数组的最大元素
15 static long min(long… array)
返回一个long数组的最小元素
16 static void reverse(long[] array)
将数组反转
static void reverse(long[] array, int fromIndex, int toIndex)
将数组指定范围的元素反转(范围左闭右开)
17 static void sortDescending(long[] array)
数组按逆序排序
static void sortDescending(long[] array, int fromIndex, int toIndex)
将一定范围内的数组按照逆序排序(范围左闭右开)
18 static Converter<String, Long> stringConverter()
返回String与Long的转换器
19 static long[] toArray(Collection<? extends Number> collection
List转数组
20 static byte[] toByteArray(long value)
long值转byte数组(byte数组长度为8)
21 static Long tryParse(String string)
十进制String转Long , 如果String值存在非法字符,转为null
static Long tryParse(String string, int radix)
radix进制String转Long , 如果String值存在非法字符,转为null
  • Bytes

S.N. 方法及说明
1 static List<Byte> asList(byte… backingArray)
基本类型数组转化为包装类List
2 static byte[] concat(byte[]… arrays)
将多个byte数组拼接成一个数组
3 static boolean contains(byte[] array, byte target)
判断一个byte数是否在byte数组内
4 static byte[] ensureCapacity(byte[] array, int minLength, int padding)
确保数组拥有一个最小的长度,如果array长度小于minLength,则会返回一个元素值与array相同,但是length = minLength + padding的数组
5 static int hashCode(byte value)
返回int值的hashCode(hashCode等于元素值)
6 static int indexOf(byte[] array, byte target)
返回一个byte值在数组中的第一个index,没匹配到返回-1
static int indexOf(byte[] array, byte[] target)
返回byte数组在另一个数组中的第一个index,没匹配到返回-1
7 static int lastIndexOf(byte[] array, byte target)
返回一个byte值在数组中的最后一个index,没匹配到返回-1
8 static void reverse(byte[] array)
将数组反转
static void reverse(byte[] array, int fromIndex, int toIndex)
将数组指定范围的元素反转(范围左闭右开)
9 static byte[] toArray(Collection<? extends Number> collection)
List转数组
  • Shorts

S.N. 方法及说明
1 static List<Short> asList(short… backingArray)
基本类型数组转化为包装类List
2 static short checkedCast(long value)
long转short,如果long值超出short范围抛IllegalArgumentException
3 static int compare(short a, short b)
比较两个short值的大小
4 static short[] concat(short[]… arrays)
将多个short数组拼接成一个数组
5 static short constrainToRange(short value, short min, short max)
如果一个数字在某个范围内则输出该数字,否则输出范围的最大值或最小值
6 static boolean contains([] array, short target)
判断一个short数是否在short数组内
7 static short[] ensureCapacity(short[] array, int minLength, int padding)
确保数组拥有一个最小的长度,如果array长度小于minLength,则会返回一个元素值与array相同,但是length = minLength + padding的数组
8 static short fromByteArray(byte[] bytes)
通过byte数组前两个元素转short值
9 public static short fromBytes(byte b1, byte b2)
通过两个byte元素转short值
10 static int hashCode(short value)
返回int值的hashCode(hashCode等于元素值)
11 static int indexOf(short[] array, short target)
返回一个short值在数组中的第一个index,没匹配到返回-1
static int indexOf(short[] array, short[] target)
返回short数组在另一个数组中的第一个index,没匹配到返回-1
12 static String join(String separator, short… array)
通过连接符连接数组转成String
13 static int lastIndexOf(short[] array, short target)
返回一个short值在数组中的最后一个index,没匹配到返回-1
14 static Comparator<short[]> lexicographicalComparator()
返回一个short[]比较器,比较规则是从index0开始比较两个数组对应index上的元素大小,返回比较结果到其中一个数组结束都完全一致,则通过长度比较,长度大的那个数组大
15 static short max(short… array)
返回一个short数组的最大元素
16 static short min(short… array)
返回一个short数组的最小元素
17 static void reverse(short[] array)
将数组反转
static void reverse(short[] array, int fromIndex, int toIndex)
将数组指定范围的元素反转(范围左闭右开)
18 static short saturatedCast(long value)
将long转化为short,与checkedCast不通的是超出short范围不会抛IllegalArgumentException异常,会转化为int最大值32767
19 static void sortDescending(short[] array)
数组按逆序排序
static void sortDescending(short[] array, int fromIndex, int toIndex)
将一定范围内的数组按照逆序排序(范围左闭右开)
20 static Converter<String, Short> stringConverter()
返回String与Short的转换器
21 static short[] toArray(Collection<? extends Number> collection)
List转数组
22 static byte[] toByteArray(short value)
short值转byte数组
  • Chars

S.N. 方法及说明
1 static List<Character> asList(char… backingArray)
基本类型数组转化为包装类List
2 static char checkedCast(long value)
long转char,如果long值超出char范围抛IllegalArgumentException
3 static int compare(char a, char b)
比较两个char值的大小
4 static char[] concat(char[]… arrays)
将多个char数组拼接成一个数组
5 static char constrainToRange(char value, char min, char max)
如果一个数字在某个范围内则输出该数字,否则输出范围的最大值或最小值
6 static boolean contains(char[] array, char target)
判断一个char数是否在int数组内
7 static char[] ensureCapacity(char[] array, int minLength, int padding)
确保数组拥有一个最小的长度,如果array长度小于minLength,则会返回一个元素值与array相同,但是length = minLength + padding的数组
8 static char fromByteArray(byte[] bytes)
通过byte数组前两个元素转char值
9 static char fromBytes(byte b1, byte b2)
通过两个byte元素转char值
10 static int hashCode(char value)
返回int值的hashCode(hashCode等于元素值)
11 static int indexOf(char[] array, char target)
返回一个char值在数组中的第一个index,没匹配到返回-1
static int indexOf(char[] array, char[] target)
返回char数组在另一个数组中的第一个index,没匹配到返回-1
12 static String join(String separator, char… array)
通过连接符连接数组转成String
13 static int lastIndexOf(char[] array, char target)
返回一个char值在数组中的最后一个index,没匹配到返回-1
14 static Comparator<char[]> lexicographicalComparator()
返回一个char[]比较器,比较规则是从index0开始比较两个数组对应index上的元素大小,返回比较结果到其中一个数组结束都完全一致,则通过长度比较,长度大的那个数组大
15 static char max(char… array)
返回一个int数组的最大元素
16 static char min(char… array)
返回一个int数组的最小元素
17 static void reverse(char[] array)
将数组反转
static void reverse(char[] array, int fromIndex, int toIndex)
将数组指定范围的元素反转(范围左闭右开)
18 static char saturatedCast(long value)
将long转化为char,与checkedCast不通的是超出char范围不会抛IllegalArgumentException异常,会转化为char最大值\uffff,value小于0,会转化为\u0000
19 static void sortDescending(char[] array)
数组按逆序排序
static void sortDescending(char[] array, int fromIndex, int toIndex)
将一定范围内的数组按照逆序排序(范围左闭右开)
20 static char[] toArray(Collection<Character> collection)
List转数组
21 static byte[] toByteArray(char value)
char值转byte数组
  • Floats

S.N. 方法及说明
1 static List<Float> asList(float… backingArray)
基本类型数组转化为包装类List
2 static int compare(float a, float b)
比较两个float值的大小
3 static float[] concat(float[]… arrays)
将多个float数组拼接成一个数组
4 static float constrainToRange(float value, float min, float max)
如果一个数字在某个范围内则输出该数字,否则输出范围的最大值或最小值
5 static boolean contains(float[] array, float target)
判断一个float数是否在float数组内
6 static float[] ensureCapacity(float[] array, int minLength, int padding)
确保数组拥有一个最小的长度,如果array长度小于minLength,则会返回一个元素值与array相同,但是length = minLength + padding的数组
7 static int hashCode(float value)
返回float值的hashCode(hashCode对应包装类型Float对象的hashCode)
8 static int indexOf(float[] array, float target)
返回一个float值在数组中的第一个index,没匹配到返回-1
static int indexOf(float[] array, float[] target)
返回float数组在另一个数组中的第一个index,没匹配到返回-1
9 static boolean isFinite(float value)
判断一个float值是否是有限的(-1.0F / 0.0 < value < 1.0F / 0.0)
10 static String join(String separator, float… array)
通过连接符连接数组转成String
11 static int lastIndexOf(float[] array, float target)
返回一个int值在数组中的最后一个index,没匹配到返回-1
12 static Comparator<float[]> lexicographicalComparator()
返回一个float[]比较器,比较规则是从index0开始比较两个数组对应index上的元素大小,返回比较结果到其中一个数组结束都完全一致,则通过长度比较,长度大的那个数组大
13 static float max(float… array)
返回一个float数组的最大元素
14 static float min(float… array)
返回一个int数组的最小元素
15 static void reverse(float[] array)
将数组反转
static void reverse(float[] array, int fromIndex, int toIndex)
将数组指定范围的元素反转(范围左闭右开)
16 static void sortDescending(float[] array)
数组按逆序排序
static void sortDescending(float[] array, int fromIndex, int toIndex)
将一定范围内的数组按照逆序排序(范围左闭右开)
17 static Converter<String, Float> stringConverter()
返回String与Float的转换器
18 static float[] toArray(Collection<? extends Number> collection)
List转数组
19 static Float tryParse(String string)
如果String符合Float规范,将String转化为Float,否则返回null
  • Doubles

S.N. 方法及说明
1 static List<Double> asList(double… backingArray)
基本类型数组转化为包装类List
2 static int compare(double a, double b)
比较两个double值的大小
3 static double[] concat(double[]… arrays)
将多个double数组拼接成一个数组
4 static double constrainToRange(double value, double min, double max)
如果一个数字在某个范围内则输出该数字,否则输出范围的最大值或最小值
5 static boolean contains(double[] array, double target)
判断一个double数是否在double数组内
6 static double[] ensureCapacity(double[] array, int minLength, int padding)
确保数组拥有一个最小的长度,如果array长度小于minLength,则会返回一个元素值与array相同,但是length = minLength + padding的数组
7 static int hashCode(double value)
返回double值的hashCode(hashCode对应包装类型Double对象的hashCode)
8 static int indexOf(double[] array, double target)
返回一个double值在数组中的第一个index,没匹配到返回-1
static int indexOf(double[] array, double[] target)
返回double数组在另一个数组中的第一个index,没匹配到返回-1
9 static boolean isFinite(double value)
判断一个double值是否是有限的(-1.0F / 0.0 < value < 1.0F / 0.0)
10 static String join(String separator, double… array)
通过连接符连接数组转成String
11 static int lastIndexOf(double[] array, double target)
返回一个double值在数组中的最后一个index,没匹配到返回-1
12 static Comparator<double[]> lexicographicalComparator()
返回一个double[]比较器,比较规则是从index0开始比较两个数组对应index上的元素大小,返回比较结果到其中一个数组结束都完全一致,则通过长度比较,长度大的那个数组大
13 static double max(double… array)
返回一个double数组的最大元素
14 static double min(double… array)
返回一个double数组的最小元素
15 static void reverse(double[] array)
将数组反转
static void reverse(double[] array, int fromIndex, int toIndex)
将数组指定范围的元素反转(范围左闭右开)
16 static void sortDescending(double[] array)
数组按逆序排序
static void sortDescending(double[] array, int fromIndex, int toIndex)
将一定范围内的数组按照逆序排序(范围左闭右开)
17 static Converter<String, Double> stringConverter()
返回String与Double的转换器
18 static double[] toArray(Collection<? extends Number> collection)
List转数组
19 static Double tryParse(String string)
如果String符合Double规范,将String转化为Double,否则返回null
  • Booleans

S.N. 方法及说明
1 static List<Boolean> asList(boolean… backingArray)
基本类型数组转化为包装类List
2 static int compare(boolean a, boolean b)
比较两个boolean值的大小
3 static boolean[] concat(boolean[]… arrays)
将多个boolean数组拼接成一个数组
4 static boolean contains(boolean[] array, boolean target)
判断一个boolean数是否在boolean数组内
5 static int countTrue(boolean… values)
返回一个boolean数组中true元素的个数
6 static boolean[] ensureCapacity(boolean[] array, int minLength, int padding)
确保数组拥有一个最小的长度,如果array长度小于minLength,则会返回一个元素值与array相同,但是length = minLength + padding的数组
7 static Comparator<Boolean> falseFirst()
返回一个Boolean比较器,false元素小于true元素,用比较器排序false元素排在true元素前面
8 static int hashCode(boolean value)
返回boolean元素的hashCode,true为1231,false为1237
9 static int indexOf(boolean[] array, boolean target)
返回一个boolean值在数组中的第一个index,没匹配到返回-1
static int indexOf(boolean[] array, boolean[] target)
返回boolean数组在另一个数组中的第一个index,没匹配到返回-1
10 static String join(String separator, boolean… array)
通过连接符连接数组转成String
11 static int lastIndexOf(boolean[] array, boolean target)
返回一个boolean值在数组中的最后一个index,没匹配到返回-1
12 static Comparator<boolean[]> lexicographicalComparator()
返回一个boolean[]比较器,比较规则是从index0开始比较两个数组对应index上的元素大小,返回比较结果到其中一个数组结束都完全一致,则通过长度比较,长度大的那个数组大
13 static void reverse(boolean[] array)
将数组反转
static void reverse(boolean[] array, int fromIndex, int toIndex)
将数组指定范围的元素反转(范围左闭右开)
14 static boolean[] toArray(Collection<Boolean> collection)
List转数组
15 static Comparator<Boolean> trueFirst()
返回一个Boolean比较器,true元素小于false元素,用比较器排序true元素排在false元素前面

测试代码:码云 – 卓立 – Guava测试Ints

  1. Google Guava Docs
  2. Google Guava User Guide

赞(0) 打赏
Zhuoli's Blog » Guava元语工具
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

zhuoli's blog

联系我关于我

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏