整理一波Guava的使用技巧-六虎

Guava简介

Guava是Google发布的一个开源库，首要供给了一些在Java开发中非常有用的东西类和API，比方字符串处理、调集操作、函数式编程、缓存等等。不管是工作仍是学习都是非常值得咱们去熟悉的，一同来看看吧。

字符串（Strings）

Strings是Guava供给的一组字符串东西，它供给了许多有用的办法来处理字符串。以下是Strings的首要办法：

isNullOrEmpty(String string)：判别字符串是否为空或null。
padEnd(String string, int minLength, char padChar)：在字符串结尾填充指定字符，直到字符串到达指定长度。
padStart(String string, int minLength, char padChar)：在字符串开头填充指定字符，直到字符串到达指定长度。
repeat(String string, int count)：重复指定字符串指定次数。
commonPrefix(CharSequence a, CharSequence b)：获取两个字符串的最长公共前缀。
commonSuffix(CharSequence a, CharSequence b)：获取两个字符串的最长公共后缀。

以下是Strings的运用示例：

public class StringsDemo {
    public static void main(String[] args) {
        // 判别字符串是否为空或null
        String str1 = null;
        String str2 = "";
        System.out.println(Strings.isNullOrEmpty(str1));
        System.out.println(Strings.isNullOrEmpty(str2));
        // 在字符串结尾填充指定字符，直到字符串到达指定长度
        String str3 = "abc";
        String paddedStr1 = Strings.padEnd(str3, 6, '*');
        System.out.println(paddedStr1);
        // 在字符串开头填充指定字符，直到字符串到达指定长度
        String str4 = "abc";
        String paddedStr2 = Strings.padStart(str4, 6, '*');
        System.out.println(paddedStr2);
        // 重复指定字符串指定次数
        String str5 = "abc";
        String repeatedStr = Strings.repeat(str5, 3);
        System.out.println(repeatedStr);
        // 获取两个字符串的最长公共前缀
        String str6 = "abcdefg";
        String str7 = "abcdxyz";
        String commonPrefix = Strings.commonPrefix(str6, str7);
        System.out.println(commonPrefix);
        // 获取两个字符串的最长公共后缀
        String str8 = "abcdefg";
        String str9 = "xyzdefg";
    String commonSuffix = Strings.commonSuffix(str8, str9);
    System.out.println(commonSuffix);
}

调集操作（Collections）

Guava供给了一些非常有用的调集操作API，如下所示：

1. ImmutableList

不可变调集是Guava的一个重要特性，它能够确保调集不被修改，从而防止并发拜访的问题。ImmutabelList是不可变List的实现，下面是一个示例代码：

List<String> list = Lists.newArrayList("a", "b", "c");
ImmutableList<String> immutableList = ImmutableList.copyOf(list);

1. Iterables

Iterables类供给了一些有用的办法来操作调集，如下所示：

Iterable<String> iterable = Lists.newArrayList("a", "b", "c");
// 判别调集是否为空
boolean isEmpty = Iterables.isEmpty(iterable);
// 获取第一个元素，假如调集为空回来null
String first = Iterables.getFirst(iterable, null);
// 获取最终一个元素，假如调集为空回来null
String last = Iterables.getLast(iterable, null);
// 获取一切契合条件的元素
Iterable<String> filtered = Iterables.filter(iterable, new Predicate<String>() {
    @Override
    public boolean apply(String input) {
        return input.startsWith("a");
    }
});
// 转换调集类型
List<String> newList = Lists.newArrayList(Iterables.transform(iterable, new Function<String, String>() {
    @Override
    public String apply(String input) {
        return input + input;
    }
}));

1. Multimaps

Multimaps供给了一个非常有用的数据结构，它允许一个键对应多个值，下面是一个示例代码：

ListMultimap<Integer, String> map = ArrayListMultimap.create();
map.put(1, "a");
map.put(1, "b");
map.put(2, "c");
List<String> values = map.get(1); // 回来[a, b]

4.Maps

Maps供给了一些有用的办法来操作Map，如下所示：

Map<Integer, String> map = ImmutableMap.of(1, "a", 2, "b", 3, "c");
// 判别Map是否为空
boolean isEmpty = Maps.isEmpty(map);
// 获取Map中的一切键
Set<Integer> keys = map.keySet();
// 获取Map中的一切值
Collection<String> values = map.values();
// 获取Map中的一切键值对
Set<Map.Entry<Integer, String>> entries = map.entrySet();
// 根据键获取值，假如不存在则回来null
String value = Maps.getIfPresent(map, 1);

条件查看（Preconditions）

Preconditions是Guava供给的一组前置条件查看东西，它供给了一些查看参数是否契合预期的办法。以下是Preconditions的首要办法：

checkArgument(boolean expression, String errorMessageTemplate, Object... errorMessageArgs)：查看参数是否契合预期，并抛出IllegalArgumentException反常，能够包括错误信息模板和占位符。
checkNotNull(T reference, String errorMessageTemplate, Object... errorMessageArgs)：查看参数是否为null，并抛出NullPointerException反常，能够包括错误信息模板和占位符。
checkState(boolean expression, String errorMessageTemplate, Object... errorMessageArgs)：查看目标状况是否契合预期，并抛出IllegalStateException反常，能够包括错误信息模板和占位符。
checkElementIndex(int index, int size, String errorMessageTemplate, Object... errorMessageArgs)：查看下标是否在调集的范围内，并抛出IndexOutOfBoundsException反常，能够包括错误信息模板和占位符。
checkPositionIndex(int index, int size, String errorMessageTemplate, Object... errorMessageArgs)：查看下标是否在调集的范围内，能够等于调集的大小，并抛出IndexOutOfBoundsException反常，能够包括错误信息模板和占位符。
checkPositionIndexes(int start, int end, int size)：查看开端下标和完毕下标是否在调集的范围内，并抛出IndexOutOfBoundsException反常。

以下是Preconditions的运用示例：

public class PreconditionsDemo {
    public static void main(String[] args) {
        // 查看参数是否契合预期，并抛出IllegalArgumentException反常，能够包括错误信息模板和占位符
        String str1 = "abc";
        Preconditions.checkArgument(str1.length() < 3, "字符串长度有必要小于3");
        // 查看参数是否为null，并抛出NullPointerException反常，能够包括错误信息模板和占位符
        String str2 = null;
        Preconditions.checkNotNull(str2, "字符串不能为空");
        // 查看目标状况是否契合预期，并抛出IllegalStateException反常，能够包括错误信息模板和占位符
        boolean flag1 = false;
        Preconditions.checkState(flag1, "状况不正确");
        // 查看下标是否在调集的范围内，并抛出IndexOutOfBoundsException反常，能够包括错误信息模板和占位符
        List<Integer> list1 = Lists.newArrayList(1, 2, 3, 4, 5);
        Preconditions.checkElementIndex(6, list1.size(), "下标越界");
        // 查看下标是否在调集的范围内，能够等于调集的大小，并抛出IndexOutOfBoundsException反常，能够包括错误信息模板和占位符
        List<Integer> list2 = Lists.newArrayList(1, 2, 3, 4, 5);
        Preconditions.checkPositionIndex(5, list2.size(), "下标越界");
        // 查看开端下标和完毕下标是否在调集的范围内，并抛出IndexOutOfBoundsException反常
        List<Integer> list3 = Lists.newArrayList(1, 2, 3, 4, 5);
        Preconditions.checkPositionIndexes(2, 6, list3.size());
        // 能够在错误信息中运用占位符
        int value1 = 101;
        Preconditions.checkArgument(value1 <= 100, "值有必要小于等于 %s", 100);
        // 能够运用Supplier来防止核算开销
        int value2 = 101;
        Preconditions.checkArgument(value2 <= 100, () -> "值有必要小于等于 " + 100);
}

能够设置过期时刻的本地缓存(CacheBuilder)

Cache是Guava供给的一个缓存东西类，它能够帮助咱们在内存中缓存数据，提高程序的性能。以下是Cache的首要办法：

get(K key, Callable<? extends V> valueLoader)：获取指定key的缓存值，假如缓存中没有，则调用valueLoader加载数据并存入缓存。
getIfPresent(Object key)：获取指定key的缓存值，假如缓存中没有，则回来null。
getAllPresent(Iterable<?> keys)：获取指定keys的缓存值，假如缓存中没有，则回来null。
put(K key, V value)：将指定key的缓存值存入缓存。
putAll(Map<? extends K, ? extends V> m)：将指定Map的缓存值存入缓存。
invalidate(Object key)：将指定key的缓存值从缓存中删去。
invalidateAll(Iterable<?> keys)：将指定keys的缓存值从缓存中删去。
invalidateAll()：将一切缓存值从缓存中删去。
size()：获取缓存中缓存值的数量。
asMap()：将缓存转换成Map。

public class CacheDemo {
    public static void main(String[] args) {
        Cache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(100)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build();
        cache.put("key", "value");
        String value = cache.getIfPresent("key");
    }
}

以上是Guava的首要东西类介绍及其运用场景,当然不止这些了，Guava还有Throwables（反常东西类），EventBus（事情总线）等等，它们能够大大提高咱们程序的开发功率，一起也为咱们供给了很多便利的东西办法。

整理一波Guava的使用技巧

Guava简介

字符串（Strings）

调集操作（Collections）

条件查看（Preconditions）

能够设置过期时刻的本地缓存(CacheBuilder)

相关文章

🎉 dumi 2，它来了它来了它来了

iOS 可以在网页上安装应用了？来看看 iOS 17.5 Beta 发布了什么

初识 Swift：字符串示例

【iOS】JPMovieWriter 基于GPUImageMovieWriter改造的录制器

作者信息