碼上快樂

相關內容    簡體    繁體

Google Guava 認識及使用

本文轉載自   查看原文   2020-07-28 20:58   544 

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

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Google guava工具類的介紹和使用 使用 Google Guava 美化你的 Java 代碼 Google Guava -緩存cache簡單使用 Google Guava學習筆記——基礎工具類Joiner的使用 Google guava 中的Monitor Google guava和Apache commons Google Guava之--cache Google Guava之CacheBuilder Google Guava入門（一） google Guava 快速入門
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM