Guava元语工具

最新推荐文章于 2022-12-12 10:20:45 发布
最新推荐文章于 2022-12-12 10:20:45 发布
阅读量355 收藏
点赞数
分类专栏： Java Guava Java 基础 文章标签： Java Guava String 元语工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41835612/article/details/83646460
版权
Java 同时被 3 个专栏收录
118 篇文章 6 订阅
订阅专栏
Java 基础
69 篇文章 1 订阅
订阅专栏
Guava
8 篇文章 0 订阅
订阅专栏

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

基本类型Guava工具类
byteBytes, SignedBytes, UnsignedBytes
shortShorts
intInts, UnsignedInteger, UnsignedInts
longLongs, UnsignedLong, UnsignedLongs
charChars
floatFloats
doubleDoubles
booleanBooleans

  • Ints

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

  • Bytes

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

  • Shorts

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

  • Chars

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

  • Floats

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

  • Doubles

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

  • Booleans

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

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

  1. Google Guava Docs
  2. Google Guava User Guide
[Spark版本更新]--2.3.0发行说明
欢迎来到我的博客，一起探索代码里的世界！
03-03 1万+
自从2017年12月1日发布spark-2.2.1以来，已有3个月时间。2018年2月28日，spark官方发布了一个大版本Spark-2.3.0，解决了1399个大大小小的问题。一、DataBricks做了相关说明今天，我们很高兴地宣布Databricks上的Apache Spark 2.3.0作为其Databricks Runtime 4.0的一部分。我们要感谢Apache Spark社区为S...
Guava源码阅读计划:primitives.Ints
ALID
07-29 463
com.google.common.primitives：八种原始类型和无符号类型的静态工具包 //在java8中可以被Integer.BYTES替代，代表字节数bytes public static final int BYTES = Integer.SIZE / Byte.SIZE; //int最大存储值，使用 1&lt;&lt;(Integer.SIZE-2) 计算得到，2是因为...
Google Guava学习之Constraint
I want to go Home Now!!!
06-08 2077
Guava Constraint非常有用。有它，我们可以创建一些受限的容器，如list/set/multiset/map...看看代码实例。import java.util.HashSet;import java.util.Set;import com.google.common.base.Objects;import com.google.common.collect.Con
[Guava]——加入约束
年轻正好
04-03 342
public class test11 {//加入约束 public static void main(String[] args) { Set set=Sets.newHashSet(); Constraint constraint=new Constraint() { @Override public String checkElement(String element)
java guava 创建约束
幻影寒狼
12-11 496
Guava：google的工程师利用传说中的“20%时间”开发的集合库，它是对jdk提供的扩展，提供了很多实用的类来简化代码。 开源地址：https://github.com/google/guava jar包下载：http://maven.outofmemory.cn/com.google.guava/guava/ package com.uwo9.test08;
java guava操作容器时加入约束条件_练习
weixin_45339692的博客
05-10 142
package guava只读函数式编程过滤转换约束集合; import java.util.Set; import com.google.common.base.Preconditions; import com.google.common.collect.Constraint; import com.google.common.collect.Constraints; import com.google.common.collect.Sets; /** 操作容器时加入约束条件:非空,长度验证 类似数据
java Guava工具集学习（强大）
写博客只为学习
09-05 758
[code="java"] import java.util.Iterator; import java.util.List; import java.util.Map; import com.google.common.base.Joiner; import com.google.common.base.Predicate; import com.google.commo...
guava14.0.1jar包及API文档
01-07
Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库，例如：集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency libraries] 、通用注解 [common annotations] ...
Java常用工具类包包含各种常用开发工具
01-04
以上工具类只是Java工具库中的一部分，实际上还有许多其他类库如Apache Commons Lang、Google Guava等，它们提供了更多高级功能和优化的实现。在实际开发中，根据项目需求选择合适的工具类，可以有效提升代码质量和...
【ORM框架与Guava Reflect】：提升数据操作的效率与便捷性
![【ORM框架与Guava Reflect】：提升数据操作的效率与便捷...对象关系映射（Object-Relational Mapping, ORM）框架和Google Guava库中的Reflect工具（Guava Reflect）就是为了解决这些问题而生的。ORM框架将面向对象语
走进JavaWeb技术世界12：从手动编译打包到项目构建工具Maven
AliCoder的博客
11-04 764
本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下Star哈 文章首发于我的个人博客： www.how2playlife.com 本文是微信公众号【Java技术江湖】的《走进JavaWeb技术世界》其中一篇，本文部分内容来源于网络，为了把本文主题...
guava之只读、函数式编程(过滤、转换、组合 ）、约束和集合
quniMdejiangyou的博客
09-21 398
guava之只读import java.util.ArrayList; import java.util.Collections; import java.util.List;import com.google.common.collect.ImmutableList;public class Demo01 { public static void main(String[] args) {
TryParse()方法转换
www.wangpeng.cn
10-18 1万+
TryParse()方法转换，在转换失败的情况下不引发异常，而是返回false，下面代码即使输入无效数据转换失败，也不会引发异常
4.TryParse比Parse好
最新发布
qq_35957970的博客
12-12 268
两者最大的区别是，如果字符串格式不满足转换的要求，Parse方法将会引发一个异常（引发异常这个过程会对性能造成损耗）；TryParse方法则不会引发异常，它会返回false，同时将result置为0。不过，不建议为所有的类型都提供TryParse模式，只有在考虑到Parse方法会带来明显的性能损耗时，才建议使用TryParse。除string外的所有基元类型，它们都有两个将字符串转型为本身的方法：Parse和TryParse。
GUAVA-Ints类
每一次AC都是一种感动
07-15 1192
方法 作用 传参类型 返回类型 实现方法 复杂度 hashCode 返回int型的hash值（直接用溢出当作hash） int int 直接返回int型的value O(1) checkedCast 检查参数是否超过int范围 long int 强转为int，越界则报错 O(1) saturatedCa...
Guava小结之 转变对象的强悍功能
jackyrongvip的专栏
11-18 2327
在之前的博文中介绍了guava强大的filter和transform，能转变各类东西，下面继续深入学习下，废话少说： 1） 将string转换为enum: 在guava 16中，可以将string转换为enum, [code="java"] public enum Day { SUNDAY, MONDAY, TUESDAY, WEDNESDA...
guava之Lists常用示例及newArrayListWithExpectedSize()和newArrayListWithCapacity()详细对比
热门推荐
请叫我大师兄
11-10 1万+
谷歌提供了guava包里面有很多的工具类，现在先看Lists这个集合工具，对list集合操作做了些优化提升。 现提供如下使用实例。 package com.lxk.guavaTest; import com.google.common.collect.Lists; import java.util.List; /** * Created by lxk on 2016/11/7 */
Guava学习笔记之排序
slyser的博客
03-31 1463
排序器[Ordering]是Guava流畅风格比较器[Comparator]的实现，它可以用来为构建复杂的比较器，以完成集合排序的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值