Google Guava 认识及使用

Guava 是一个 Google开发的基于java的类库集合的扩展项目，包括 collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, 等等. 这些高质量的 API 可以使你的JAVA代码更加优雅，更加简洁，让你工作更加轻松愉悦。下面我们就简单的介绍一下Guava的大致的功能！

Guava项目托管在github上：https://github.com/google/guava.git。

从源码可以看到，Guava主要有下面的几个包：

annotations：普通注解类型
base：基本工具类库和接口
Cache：缓存工具包，非常简单易用且功能强大的JVM内缓存
collect：带泛型的集合接口扩展和实现，以及工具类，这里你会发现很多好玩的集合
eventbus：发布订阅风格的事件总线
hash：哈希工具包
io：IO工具包
math：数学计算工具包
net：网络工具包
primitives：八种原始类型和无符号类型的静态工具包
reflect：反射工具包
concurrent：并发编程工具包
escape：转义工具
graph：处理基于图的数据结构
HTML：Html字符串转义
XML：xml字符串转义

注：本章使用的Google Guava版本是29.0-jre。

一、基本工具类库和接口（base）

com.google.common.base.CaseFormat

com.google.common.base.CaseFormat是一种实用工具类（枚举类），以提供不同的ASCII字符格式之间的转换。

枚举常量：

CaseFormat.LOWER_CAMEL ：Java变量的命名规则，如“lowerCamel”。
CaseFormat.LOWER_HYPHEN ：连字符连接变量的命名规则，如“lower-hyphen”。
CaseFormat.LOWER_UNDERSCORE ：C ++变量命名规则，如“lower_underscore”。
CaseFormat.UPPER_CAMEL ：Java和C++类的命名规则，如“UpperCamel”。
CaseFormat.UPPER_UNDERSCORE ：Java和C++常量的命名规则，如“UPPER_UNDERSCORE”。

方法：

Converter<String,String> converterTo(CaseFormat targetFormat )：返回一个转换，从这个格式转换targetFormat字符串。
String to(CaseFormat format, String str) ：从这一格式指定格式的指定字符串 str 转换。
static CaseFormat valueOf(String name) ：返回此类型具有指定名称的枚举常量。
static CaseFormat[] values() ：返回一个包含该枚举类型的常量数组中的顺序被声明。

示例：

public class CaseFormatTest {
    public static void main(String[] args) {
        //输出 testData
        System.out.println(CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, "test-data"));
        //输出 testData
        System.out.println(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "test_data"));
        //输出 TestData
        System.out.println(CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, "test_data"));
        //输出 testdata
        System.out.println(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, "testdata"));
        //输出 test_data
        System.out.println(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, "TestData"));
        //输出 test-data
        System.out.println(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, "testData"));
    }
}

com.google.common.base.CharMatcher

CharMatcher提供了各种方法来处理各种JAVA char类型值。

-- 静态方法
CharMatcher.any()：返回匹配任意字符串的CharMatcher
CharMatcher.none()：返回不匹配任意字符串的CharMatcher
CharMatcher.whitespace()：返回匹配空白符的CharMatcher
CharMatcher.breakingWhitespace()：返回匹配空格的CharMatcher
CharMatcher.ascii()：返回匹配ASCII码的CharMatcher
CharMatcher.is(char match): 返回匹配指定字符的Matcher
CharMatcher.isNot(char match): 返回不匹配指定字符的Matcher
CharMatcher.anyOf(CharSequence sequence): 返回匹配sequence中任意字符的Matcher
CharMatcher.noneOf(CharSequence sequence): 返回不匹配sequence中任何一个字符的Matcher
CharMatcher.inRange(char startInclusive, char endIncludesive): 返回匹配范围内任意字符的Matcher
CharMatcher.forPredicate(Predicate<? super Charater> predicate): 返回使用predicate的apply()判断匹配的Matcher

-- 实例方法
CharMatcher negate(): 返回以当前Matcher判断规则相反的Matcher（即any()和none()的关系）
CharMatcher and(CharMatcher other): 返回与other匹配条件组合做与来判断的Matcher
CharMatcher or(CharMatcher other): 返回与other匹配条件组合做或来判断的Matcher

--文本匹配方法
boolean matchesAnyOf(CharSequence sequence): 只要sequence中有任意字符能匹配Matcher,返回true
boolean matchesAllOf(CharSequence sequence): sequence中所有字符都能匹配Matcher,返回true
boolean matchesNoneOf(CharSequence sequence): sequence中所有字符都不能匹配Matcher,返回true 
int indexIn(CharSequence sequence): 返回sequence中匹配到的第一个字符的坐标
int indexIn(CharSequence sequence, int start): 返回从start开始,在sequence中匹配到的第一个字符的坐标
int lastIndexIn(CharSequence sequence): 返回sequence中最后一次匹配到的字符的坐标
int countIn(CharSequence sequence): 返回sequence中匹配到的字符计数

--字符串使用方法
String removeFrom(CharSequence sequence): 删除sequence中匹配到到的字符并返回
String retainFrom(CharSequence sequence): 保留sequence中匹配到的字符并返回
String replaceFrom(CharSequence sequence, char replacement): 替换sequence中匹配到的字符并返回
String trimFrom(CharSequence sequence): 删除首尾匹配到的字符并返回
String trimLeadingFrom(CharSequence sequence): 删除首部匹配到的字符
String trimTrailingFrom(CharSequence sequence): 删除尾部匹配到的字符
String collapseFrom(CharSequence sequence, char replacement): 将匹配到的组(连续匹配的字符)替换成replacement
String trimAndCollapseFrom(CharSequence sequence, char replacement): 先trim在replace

示例：

// 匹配所有字符
String str = "love23next234csdn3423javaeye";
System.out.println(CharMatcher.any().retainFrom(str));

str="love23next234csdn34数学2 3jav aey\ne";
System.out.println(CharMatcher.inRange('a','z').retainFrom(str));
System.out.println(CharMatcher.breakingWhitespace().countIn(str));

com.google.common.base.Charsets

字符编码。

Charsets.US_ASCII
Charsets.ISO_8859_1
Charsets.UTF_8
Charsets.UTF_16BE
Charsets.UTF_16LE
Charsets.UTF_16

com.google.common.base.Joiner

主要用于字符串的拼接。

方法：

A<A extends Appendable> appendTo(A appendable, Iterable<?> parts)
用来存在放通过解析预先配置的分隔符后与Iterable类型parts解析后的字符串
 
A <A extends Appendable> appendTo(A appendable, Iterator<?> parts)
用来存在放通过解析预先配置的分隔符后与Iterator类型parts解析后的字符串
 
A <A extends Appendable> appendTo(A appendable, Object[] parts)
用来存在放通过解析预先配置的分隔符后与Object[]类型parts解析后的字符串
 
A <A extends Appendable> appendTo(A appendable, Object first, Object second, Object... rest)
用来存在放通过解析预先配置的分隔符后与Object...类型parts解析后的字符串
 
StringBuilder appendTo(StringBuilder builder, Iterable<?> parts)
用来存在放通过解析预先配置的分隔符后与Iterable类型parts解析后的字符串
 
StringBuilder appendTo(StringBuilder builder, Iterator<?> parts)
用来存在放通过解析预先配置的分隔符后与Iterator类型parts解析后的字符串
 
StringBuilder appendTo(StringBuilder builder, Object[] parts)
用来存在放通过解析预先配置的分隔符后与Object[]类型parts解析后的字符串
 
StringBuilder appendTo(StringBuilder builder, Object first, Object second, Object... rest)
用来存在放通过解析预先配置的分隔符后与Object...类型parts解析后的字符串
 
String	join(Iterable<?> parts)
返回一个String在Iterable<?> parts每个数据中间添加上基于之前配置的分隔符
 
String	join(Iterator<?> parts)
返回一个String在Iterator<?> parts每个数据中间添加上基于之前配置的分隔符
 
String	join(Object[] parts)
返回一个String在Object[] parts每个数据中间添加上基于之前配置的分隔符
 
String	join(Object first, Object second, Object... rest)
返回一个String在Object... parts每个数据中间添加上基于之前配置的分隔符
 
static Joiner on(char separator)
返回一个Joiner对象用来自己替换在连接的元素中char类型分隔符
 
static Joiner on(String separator)
返回一个Joiner对象用来自己替换在连接的元素中String类型分隔符
 
Joiner	skipNulls()
返回一个Joiner对象但是会跳过连接元素中为null的元素
 
Joiner	useForNull(String nullText)
返回一个Joiner对象但是会把为null的元素替换为String类型的nullText
 
Joiner.MapJoiner withKeyValueSeparator(String keyValueSeparator)
返回一个MapJoiner对象,用于添加到间隔Map中的Entity(而on()方法是替换key与value之间)。是Splitter.withKeyValueSeparator()的逆运算。

示例：

public class JoinerTest {

    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("str");
        list.add("abc");
        list.add("");
        list.add("123");

        System.out.println(concatString(list, "|"));
        // 使用 Joiner工具类，一句话搞定
        // list不能包含null
        System.out.println(Joiner.on("|").join(list));

        // 使用指定字符串替换null,空字符串不起作用
        System.out.println(Joiner.on("|").useForNull("没有").join(list));
        // 忽略null
        System.out.println(Joiner.on("|").skipNulls().join(list));
    }
    // 将List的元素用分割符连接
    public static String concatString(List<String> lists, String delimiter) {
        StringBuilder builder = new StringBuilder();
        for (String s : lists) {
            if (s != null) {
                builder.append(s).append(delimiter);
            }
        }
        builder.setLength(builder.length() - delimiter.length());
        return builder.toString();
    }
}

com.google.common.base.Objects

public final class Objects extends ExtraObjectsMethodsForWeb {
    private Objects() {
    }

    public static boolean equal(@Nullable Object a, @Nullable Object b) {
        return a == b || a != null && a.equals(b);
    }

    public static int hashCode(@Nullable Object... objects) {
        return Arrays.hashCode(objects);
    }
}

注意：

ObjectsJDK 7中新引入的类提供了等效 Objects.equals方法。

ObjectsJDK 7中新引入的类提供了等效的 Objects.hash(Object...)。

com.google.common.base.Optional

Optional用于包含非空对象的不可变对象。 Optional对象，用于不存在值表示null。这个类有各种实用的方法，以方便代码来处理为可用或不可用，而不是检查null值。

com.google.common.base.Preconditions

Guava提供了许多前置条件检查实用程序。

checkArgument(boolean)：检查boolean是否为true，传入false抛出异常。异常类型IllegalArgumentException
checkNotNull(T)：检查<T> value为null直接抛出异常，否则直接返回value。异常类型NullPointerException
checkState(boolean)：用来检查对象的某些状态。异常类型IllegalStateException
checkElementIndex(int index, int size)：检查index作为索引值对某个列表、字符串或数组是否有效。index>=0 && index<size。异常类型IndexOutOfBoundsException
checkPositionIndex(int index, int size)：检查index作为位置值对某个列表、字符串或数组是否有效。index>=0 && index<=size。异常类型IndexOutOfBoundsException
checkPositionIndexes(int start, int end, int size)：检查[start, end]表示的位置范围对某个列表、字符串或数组是否有效。异常类型IndexOutOfBoundsException

public class PreconditionsTest {

    public static void main(String[] args) {
        Preconditions.checkArgument(false);
        Preconditions.checkArgument(false,"this is a test!"); //this is a test!
        Preconditions.checkArgument(false,"%s is a %s","hjh","pig"); //hjh is a pig
        Preconditions.checkElementIndex(20, 10); //java.lang.IndexOutOfBoundsException: index (20) must be less than size (10)
        Preconditions.checkPositionIndex(20, 10, "desc !!!!"); //java.lang.IndexOutOfBoundsException: desc !!!! (20) must not be greater than size (10)
        Preconditions.checkPositionIndex(20, 10); //java.lang.IndexOutOfBoundsException: index (20) must not be greater than size (10)
        Preconditions.checkState(false); // java.lang.IllegalStateException
        Preconditions.checkNotNull(1);//1
        Preconditions.checkNotNull(null,"is null");  //java.lang.NullPointerException: is null
        Preconditions.checkNotNull(null, "%s is null !", "object"); //java.lang.NullPointerException: object is null !
    }

}

com.google.common.base.Splitter

方法：

static Splitter	fixedLength(int length)
返回一个splitter对象把目标字符串按字符长度分隔
 
Splitter limit(int limit)
返回一个splitter对象,但它停止分隔当它到达limit的时候。
Returns a splitter that behaves equivalently to this splitter but stops splitting after it reaches the limit.
 
Splitter omitEmptyStrings()
返回一个splitter对象,但是返回结果会删除空字符
 
static Splitter	on(char separator)
返回一个splitter对象,通过给定的单个字符进行分隔
 
static Splitter	on(CharMatcher separatorMatcher)
返回一个splitter对象,通过给定的CharMatcher进行分隔
 
static Splitter	on(Pattern separatorPattern)
返回一个splitter对象,通过给定的Pattern进行分隔
 
static Splitter	on(String separator)
返回一个splitter对象,通过给定的字符串进行分隔
 
static Splitter	onPattern(String separatorPattern)
返回一个splitter对象,认为任何子序列匹配一个给定的模式(正则表达式)是一个分隔符。
 
Iterable<String> split(CharSequence sequence)
将序列分为字符串组件和使他们可以通过迭代器
 
List<String> splitToList(CharSequence sequence)
将序列分为字符串组件作为一个不可变的list
 
Splitter trimResults()
返回一个splitter对象，但是为移除返回list对象中每个对象前后的空白，相当于trimResults(CharMatcher.WHITESPACE)
 
Splitter trimResults(CharMatcher trimmer)
返回一个splitter对象，但是为移除返回list对象中每个对象前后与给定的CharMatcher对应的字符
 
Splitter.MapSplitter withKeyValueSeparator(char separator)
返回一个MapSplitterce,通过指定单个的cahr分解成entries，然后再通过entry中的特定字符分隔成key-value形式Map。是Join.withKeyValueSeparator()的逆运算
 
Splitter.MapSplitter withKeyValueSeparator(Splitter keyValueSplitter)
返回一个MapSplitterce,通过指定Splitter分解成entries，然后再通过entry中的特定字符分隔成key-value形式的Map。是Join.withKeyValueSeparator()的逆运算
 
Splitter.MapSplitter withKeyValueSeparator(String separator)
返回一个MapSplitterce,通过指定String分解成entries，然后再通过entry中的特定字符分隔成key-value形式的Map。是Join.withKeyValueSeparator()的逆运算

示例：

public class SplitterTest {

    /**
     * 1. 把(字符串)分割为(集合). <Result>
     */
    @Test
    public void test_Splitter_OnSplitter() {
        List<String> list = Splitter.on("|").splitToList("Hello|Java");
    }

    /**
     * 1. 把(字符串)分割为(集合). <Result>
     * 2. 若字符串分割之后, 含有空字符串, 使用omitEmptyStrings过滤掉.
     */
    @Test
    public void test_Splitter_Omit() {
        List<String> list = Splitter.on("|").splitToList("Hello|Java|||");
    }

    /**
     * 1. 把(字符串)分割为(集合). <Result>
     * 2. 若字符串分割之后, 含有空字符串, 使用omitEmptyStrings过滤掉.
     * 3. 若subString左右还有空格时, 可以使用trimResults去除.
     */
    @Test
    public void test_Splitter_Trim_Omit() {
        List<String> list = Splitter.on("|").splitToList("Hello | Java |||");
        list = Splitter.on("|").trimResults()
                .omitEmptyStrings()
                .splitToList("Hello|Java|||");
    }

    /**
     * 1. 把(字符串)分割为(集合). <Result>
     * 2. 固定长度切割字符串：fixedLength.
     */
    @Test
    public void test_Splitter_FixedLength() {
        List<String> list = Splitter.fixedLength(4).splitToList("aaaabbbbcccc");
    }

    /**
     * 1. 把(字符串)分割为(集合). <Result>
     * 2. limit: 只根据分隔符, 分割几次字符串.
     */
    @Test
    public void test_Splitter_Limit() {
        List<String> list = Splitter.on("#").limit(3).splitToList("Java#C++#C#Shell");
    }

    /**
     * 1. 把(字符串)分割为(集合). <Result>
     * 2. 使用正则表达式, 作为分隔符.
     */
    @Test
    public void test_Splitter_OnPattern() {
        List<String> list = Splitter.onPattern("\\#").limit(3).splitToList("Java#C++#C#Shell");
        // List<String> list = Splitter.on(Pattern.compile("#")).limit(3).splitToList("Java#C++#C#Shell");
    }

    /**
     * 1. 把(字符串)分割为(集合). <Result>
     * 2. 字符串转换为Map.
     * 3. withKeyValueSeparator: 指定key和value通过什么进行分割.
     */
    @Test
    public void test_Splitter_ToMap() {
        Map<String, String> map = Splitter.on("#").withKeyValueSeparator("=").split("Java=1#C++=2#C=3#Shell=4");
    }
}

com.google.common.base.StandardSystemProperty

标准系统的属性枚举类。

JAVA_VERSION("java.version"),
JAVA_VENDOR("java.vendor"),
JAVA_VENDOR_URL("java.vendor.url"),
JAVA_HOME("java.home"),
JAVA_VM_SPECIFICATION_VERSION("java.vm.specification.version"),
JAVA_VM_SPECIFICATION_VENDOR("java.vm.specification.vendor"),
JAVA_VM_SPECIFICATION_NAME("java.vm.specification.name"),
JAVA_VM_VERSION("java.vm.version"),
JAVA_VM_VENDOR("java.vm.vendor"),
JAVA_VM_NAME("java.vm.name"),
JAVA_SPECIFICATION_VERSION("java.specification.version"),
JAVA_SPECIFICATION_VENDOR("java.specification.vendor"),
JAVA_SPECIFICATION_NAME("java.specification.name"),
JAVA_CLASS_VERSION("java.class.version"),
JAVA_CLASS_PATH("java.class.path"),
JAVA_LIBRARY_PATH("java.library.path"),
JAVA_IO_TMPDIR("java.io.tmpdir"),
JAVA_COMPILER("java.compiler"),
JAVA_EXT_DIRS("java.ext.dirs"),
OS_NAME("os.name"),
OS_ARCH("os.arch"),
OS_VERSION("os.version"),
FILE_SEPARATOR("file.separator"),
PATH_SEPARATOR("path.separator"),
LINE_SEPARATOR("line.separator"),
USER_NAME("user.name"),
USER_HOME("user.home"),
USER_DIR("user.dir");

com.google.common.base.Strings

posted @ 2020-07-28 20:58 codedot 阅读(1725) 评论(0) 编辑收藏举报

刷新页面返回顶部

袖子

一点一滴的记录，都是成功路上的垫脚石