Guava中關於字串處理以及加強版集合的使用記錄（個人學習筆記）

阿新 • • 發佈：2019-01-26

Guava中關於字串的處理

Strings工具類的使用

// 獲取共同的字首
String commonPrefix = Strings.commonPrefix("fenglang", "fengyue");
System.out.println(commonPrefix);

// 獲取共同的字尾
String commonSuffix = Strings.commonSuffix("fenglang", "fengling");
System.out.println(commonSuffix);

// 判斷字串是否為NULL或空
boolean nullOrEmpty = Strings.isNullOrEmpty("feng" 
);
System.out.println(nullOrEmpty);

// 若字串非空或者非null則返回字串本身,否則返回null;
String emptyToNull = Strings.emptyToNull(null);
System.out.println(emptyToNull);

// 若字串非空或者非null則返回字串本身,否則返回""(空字串)
String nullToEmpty = Strings.nullToEmpty("");
System.out.println("-->" + nullToEmpty);

// 在設定最小長度的情況下,在字串前面增加(最小長度-原字串長度)個字元 

String padStart = Strings.padStart("feng", 6, 'g');
System.out.println(padStart);

// 在設定最小長度的情況下,在字串後面增加(最小長度-原字串長度)個字元
String padEnd = Strings.padEnd("feng", 8, 'g');
System.out.println(padEnd);

// 將字串重複N次返回
String repeat = Strings.repeat("lang", 2);
System.out.println(repeat);

CharMatcher字元字元處理

String sequence = "java12345python678cC++Ruby!-+馮朗sdk" 
;

// JAVA_DIGIT:匹配UNICODE數字
String retain = CharMatcher.JAVA_DIGIT.retainFrom(sequence);
System.out.println(retain);

// JAVA_LETTER:匹配字母
// JAVA_LETTER_OR_DIGET: 匹配數字或字母
// JAVA_LOWER_CASE: 匹配小寫
// JAVA_UPPER_CASE: 匹配大寫
// SINGLE_WIDTH:匹配單字寬字元,如中文字就是雙字寬
String retain2 = CharMatcher.SINGLE_WIDTH.retainFrom(sequence);
System.out.println(retain2);

// matchesAnyOf:sequence中有任意字元能匹配Matcher,返回true
// matchesAllOf:sequence中所有字元都能匹配Matcher,返回true
// matchesNoneOf:sequence中所有字元都不能匹配Matcher,返回true
boolean matchesAnyOf = CharMatcher.is('c').matchesAnyOf(sequence);
System.out.println(matchesAnyOf);

// indexIn(CharSequence sequence):返回sequence中匹配到的第一個字元的座標
// indexIn(CharSequence sequence,int
// start):返回從start開始,在sequence中匹配到的第一個字元的座標
// lastIndexIn(CharSequence sequence):返回sequence中最後一次匹配到的字元的座標
// countIn(CharSequence sequence):返回sequence中匹配到的字元計數
int indexIn = CharMatcher.anyOf("abc").indexIn(sequence);
int countIn = CharMatcher.is('a').countIn(sequence);
System.out.println(indexIn + ":" + countIn);

// removeFrom(CharSequence sequence):刪除sequence中匹配到到的字元並返回
String removeFrom = CharMatcher.anyOf("abc").removeFrom(sequence);
System.out.println(removeFrom);

// retainFrom(CharSequence sequence):保留sequence中匹配到的字元並返回
String retainFrom = CharMatcher.anyOf("abc").retainFrom(sequence);
System.out.println(retainFrom);

// replaceFrom(CharSequence sequence,char
// replacement):替換sequence中匹配到的字元並返回
String replaceFrom = CharMatcher.anyOf("abc").replaceFrom(sequence, "$");
System.out.println(replaceFrom);

// trimFrom(CharSequence sequence):刪除首尾匹配到的字元並返回
String trimFrom = CharMatcher.anyOf("jadk").trimFrom(sequence);
System.out.println("trim:"+trimFrom);

// trimLeadingFrom(CharSequence sequence):刪除首部匹配到的字元
String trimLeadingFrom = CharMatcher.anyOf("jdk").trimLeadingFrom(sequence);
System.out.println(trimLeadingFrom);

// trimTrailingFrom(CharSequence sequence):刪除尾部匹配到的字元
String trimTrailingFrom = CharMatcher.anyOf("jdk").trimTrailingFrom(sequence);
System.out.println(trimTrailingFrom);

// collapseFrom(CharSequence sequence,char
// replacement):將匹配到的組(連續匹配的字元)替換成replacement
// 注意:collapseFrom和replaceFrom的區別如下:
// replaceFrom會把匹配到的字元全部替換成replacement;
// collapseFrom則會把連續匹配到的字元替換成單個的replacement!!
// 如'a'在匹配"javaa"時,利用replaceFrom的返回值為[email protected]@@,而collapseFrom的返回值為[email protected]@;
String replace = CharMatcher.anyOf("apydk").replaceFrom(sequence, '@');
System.out.println(replace); // [email protected]@[email protected]@[email protected]!-+馮朗[email protected]@
String collapseFrom = CharMatcher.anyOf("apydk").collapseFrom(sequence, '@');
System.out.println(collapseFrom); // [email protected]@[email protected][email protected]!-+馮朗[email protected]

//trimAndCollapseFrom(CharSequence sequence,char replacement):先trim在replace
String trimAndCollapseFrom = CharMatcher.anyOf("jadk").trimAndCollapseFrom(sequence, '#');
System.out.println(trimAndCollapseFrom);

Joiner拼接字串

//skipNulls():去除null;
String join = Joiner.on("#").skipNulls().join("A",null,"B");
System.out.println(join);

//useForNull("0"):將null用別的字元進行替換
String join2=Joiner.on("#").useForNull("0").join("A",null,"B","C",null,"D");
System.out.println(join2);

StringBuilder sb=new StringBuilder();
StringBuilder appendTo = Joiner.on(";").skipNulls().appendTo(sb,"A","B","C","D");
System.out.println(sb+"-->"+appendTo);

//withKeyValueSeparator:據指定的分隔符連線 Map的 key和value
Map<String,Object> map=Maps.newHashMap();
map.put("河南","鄭州");
map.put("河北","石家莊");
map.put("湖南","長沙");
map.put("湖北","武漢");
String join3 = Joiner.on(",").withKeyValueSeparator("=").join(map);
System.out.println(join3);

Splitter分割字串

//omitEmptyStrings():去除結果為空的資料
//trimResults():去除分隔結果的前後空格;
//splitToList(CharSequence sequence):利用Splitter將String轉化為list;
List<String> list = Splitter.on(",").trimResults().omitEmptyStrings().splitToList(" 1,a,b, ,3,5,6");
for (String str:list) {
    System.out.println(str);
}

//withKeyValueSeparator(String separtor):使用Splitter將String轉化為map;
String sequence="k1=v1;k2=v2;k3=v3;";
Map<String, String> map = Splitter.on(";").trimResults().omitEmptyStrings().withKeyValueSeparator("=").split(sequence);
for(java.util.Map.Entry<String, String> entry:map.entrySet()){
    System.out.println(entry.getKey()+":"+entry.getValue());
}

Guava中的Iterables的使用

List<String> list=Lists.newArrayList("Apple","Pear","Peach","Banana");
List<String> add=Lists.newArrayList("A","B","C","D");

//判斷集合中的資料是否全部滿足條件;
boolean all = Iterables.all(list,new Predicate<String>() {

    @Override
    public boolean apply(String input) {
        return input.startsWith("P");
    }
});
System.out.println(all);

//判斷集合中是否存在滿足條件的資料;
boolean any = Iterables.any(list,new Predicate<String>() {

    @Override
    public boolean apply(String input) {
        return input.startsWith("P");
    }
});
System.out.println(any);

//將集合進行拼接在一起
Iterable<String> concat = Iterables.concat(list,add);
Iterator<String> iterator = concat.iterator();
while(iterator.hasNext()){
    String next=iterator.next();
    System.out.println(next);
}

//contains(Iterable iterable,Object element):判斷迭代器中是否包含指定元素;
boolean contains = Iterables.contains(list,"apple");
System.out.println(contains);

//從集合中過濾出符合條件的元素的集合
Iterable<String> filter = Iterables.filter(list,new Predicate<String>() {

    @Override
    public boolean apply(String input) {
        return input.length()==5;
    }
});
System.out.println(Lists.newArrayList(filter));

//從集合中找出符合條件的第一個元素並返回,若沒有匹配的元素,則返回設定的預設值;
String find = Iterables.find(list,new Predicate<String>() {

    @Override
    public boolean apply(String input) {
        return input.startsWith("C");
    }
},"NONE");
System.out.println(find);

//返回某個元素在集合中的個數
int frequency = Iterables.frequency(Lists.newArrayList(1,2,1,1,2,3,1),1);
System.out.println(frequency);

//返回集合中的某一個、第一個或者最後一個元素;
String last = Iterables.getLast(list);
System.out.println(last);


//返回符合條件的集合的下標,若沒有符合條件的則返回-1;
int indexOf = Iterables.indexOf(list,new Predicate<String>() {

    @Override
    public boolean apply(String input) {
        return input.startsWith("P");
    }
});
System.out.println(indexOf);

//判斷集合是否為空,若為空則返回true,否則false;
boolean empty = Iterables.isEmpty(Lists.newArrayList());
System.out.println(empty);

//將集合按照size的大小分隔為(總大小/size)個集合,最後一個集合中不夠的用null補齊;
Iterable<List<String>> partition = Iterables.paddedPartition(list,3);
System.out.println(partition.toString());

//將集合按照size的大小分隔為(總大小/size)個集合,若最後一個集合不夠size的則只顯示最後剩餘的元素;
Iterable<List<String>> iterable = Iterables.partition(list,3);
System.out.println(iterable.toString());

//是否按照條件從結合中刪除了某個元素,若true代表從集合中刪除元素;
boolean b = Iterables.removeIf(list,new Predicate<String>() {

    @Override
    public boolean apply(String input) {
        return input.startsWith("P");
    }
});
System.out.println(b+"-->"+list.toString());

//將集合轉化為陣列;
String[] array = Iterables.toArray(list,String.class);
System.out.println(array.length);

//將集合中的元素進行轉化;
Iterable<Integer> transform = Iterables.transform(list,new Function<String,Integer>() {

    @Override
    public Integer apply(String input) {
        return input.length();
    }
});
System.out.println(transform.toString());

//retainAll(Iterable removeFrom,Collection elementsToRetain):
//從Iterable迭代器中保留給定Collection集合中的所有元素(在迭代器中存在),其他移除!
//如果給定引數是Collection例項,則使用Collection類的retainAll()方法,否則使用Iterators.retainAll()方法!
//只要任意一個元素被保留,即可返回true,否則返回false
boolean retainAll = Iterables.retainAll(list,Lists.newArrayList("Apple","Banana","CD","Pear","Peach"));
System.out.println(retainAll+"-->"+list.toString());

Guava中的工具類Collections2的使用

List<Integer> list=Lists.newArrayList(1,2,6,8,9,3,4,5);
//filter():過濾符合條件的元素,同Iterables.filter()方法類似;
Collection<Integer> filter = Collections2.filter(list,new Predicate<Integer>() {

    @Override
    public boolean apply(Integer input) {
        return input>=3;
    }
});
System.out.println(filter.toString());

//transform():將集合中的元素進行轉化,同Iterables.transform()方法類似;
Collection<String> transform = Collections2.transform(list,new Function<Integer,String>() {

    @Override
    public String apply(Integer input) {
        return (input+0.1)+"";
    }
});
System.out.println(transform.toString());

List<String> fruits=Lists.newArrayList("Banana","Peach","Apple","Pear","Orange");
//按照預設的規則進行排序,同Collections.sort(List<T> list,Comparator<? extends T> comparator)類似;
Collection<List<String>> permutations = Collections2.orderedPermutations(fruits);
System.out.println(permutations.toString());

//按照自定義的規則進行排序,//按照預設的規則進行排序,同Collections.sort(List<T> list,Comparator<? extends T> comparator)類似;
Collection<List<String>> orderedPermutations = Collections2.orderedPermutations(fruits,new Comparator<String>() {

    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
});
System.out.println(orderedPermutations);

Guava中的加強版集合的使用

HashMultiSet

//Multiset看似是一個Set,但實質上它繼承的是Collection<E>介面,可以向Multiset中新增重複的元素,Multiset會對新增的元素做一個計數.
HashMultiset<String> set = HashMultiset.create();
set.add("A");
set.add("B");
set.add("C");
set.add("A");
set.add("C");
set.add("D");
set.add("B");
set.add("A");

//獲取Set集合中的不重複的資料的總數
int size=set.entrySet().size();
System.out.println(size);

Set<String> elementSet = set.elementSet();
for(String str:elementSet){
    System.out.println(str+"-->"+set.count(str));
}

for(Entry<String> entry:set.entrySet()){
    System.out.println(entry.getElement()+"-->"+entry.getCount());
}

ArrayListMultimap

//Guava中的Multimap的適用場景為需要類似Map<String,Collection<String>>的資料型別.
ArrayListMultimap<String,String> create = ArrayListMultimap.create();
create.put("k1","v1");
create.put("k2","v2");
create.put("k1","v11");
create.put("k2","v22");
create.put("k1","v111");
create.put("k3","v3");
int size=create.keySet().size();
System.out.println(size);

Set<String> set = create.keySet();
for(String key:set){
    List<String> list = create.get(key);
    System.out.println(list);
}

HashBiMap

//BiMap也是一種Map,其特別之處在於既提供鍵到值的對映,也提供值到鍵的對映,其為雙向Map.
HashBiMap<String,String> map = HashBiMap.create();
map.put("星期一","Monday");
map.put("星期二","Tuesday");
map.put("星期三","Wednesday");
map.put("星期四","Thursday");
map.put("星期五","Friday");
map.put("星期六","Saturday");
map.put("星期日","Sunday");
System.out.println(map.get("星期日"));
System.out.println(map.inverse().get("Monday"));

Guava中關於字串處理以及加強版集合的使用記錄（個人學習筆記）

Guava中關於字串的處理 Strings工具類的使用 // 獲取共同的字首 String commonPrefix = Strings.commonPrefix("fenglang", "fengyue"); System.out.printl

VS程式設計，使用替換的方式，將程式碼中字串以某一字元以標誌（常以逗號）進行換行，分行顯示。（相當於按回車鍵）

1、從一行，通過替換變成多行，相當於按回車替換之前：替換之後：步驟： 1，選中要替換的程式碼 2、按ctrl + H 兩個鍵，調出替換視窗， 3、在替換視窗進行如下設定： 4、點選替換所有按鈕

scala中的函式、變數、集合、物件---scala學習筆記(1)

最近正在嘗試接觸spark，那麼不可避免地就要用到scala，雖然spark同時也支援java，但是通過閱讀spark上的例程上發現，往往scala的程式碼相比較java而言更加簡短，而且也更加清晰。所以決定試一試簡單地學習一下scala。使用的書籍

類---中裝飾器的使用（實驗樓學習筆記）

你可能想要更精確的調整控制屬性訪問許可權，你可以使用 @property 裝飾器，@property 裝飾器就是負責把一個方法變成屬性呼叫的。例如： #!/usr/bin/env python3 class Account(object):

Kafka中topic的Partition，Kafka為什麼這麼快,Consumer的負載均衡及consumerGroup的概念（來自學習筆記）

1.1． Kafka中topic的Partition  在Kafka檔案儲存中，同一個topic下有多個不同partition，每個partition為一個目錄，partiton命名規則為topic名稱+有序序號，第一個partiton序號從0開始，序號

自然語言處理資料集免費資源開放（附學習資料）

2.Kafka中topic的Partition，Kafka為什麼這麼快,Consumer的負載均衡及consumerGroup的概念（來自學習筆記）

1.1． Kafka中topic的Partition  在Kafka檔案儲存中，同一個topic下有多個不同partition，每個partition為一個目錄，partiton命名規則為topic名稱+有序序號，第一個partiton序號從0開始，序號最大值為parti

python中字串處理

日常程式碼中經常要對字串做各種各樣的處理，python也有很多字串處理方法 #首字母大寫使用capitalizs = 'im OK's1 = s.capitalize() #全字母大寫使用upper s2 = s.upper() #全字母小寫 s3 = s.lower() #大小寫翻轉 s4 =

[Google Guava] 6-字串處理：分割，連線，填充

原文連結譯文連結譯者：沈義揚，校對：丁一聯結器[Joiner] 用分隔符把字串序列連線起來也可能會遇上不必要的麻煩。如果字串序列中含有null，那連線操作會更難。Fluent風格的Joiner讓連線字串更簡單。 Joiner joiner = Joiner.on("; ").skipNu

Mysql中字串處理的幾種處理方法concat、concat_ws、group_concat

Mysql中字串處理的幾種處理方法concat、concat_ws、group_concat以下詳情： 1.MySQL中concat函式使用方法： CONCAT(str1,str2,…) 返回結果為連線引數產生的字串。

Java集合中List,Set以及Map等集合體系詳解(史上最全)

概述: List , Set, Map都是介面，前兩個繼承至Collection介面，Map為獨立介面 Set下有HashSet，LinkedHashSet，TreeSet List下有ArrayList，Vector，LinkedList Map下有Ha

C++中字串處理函式

一、C++中substr函式的用法#include<string> #include<iostream> using namespace std; main() { string s("12345asdf"); string a=s.substr(0

day16作用域和字串處理以及內建函式

import osname='alex'def foo(): name='lihaig' def bar(): print(name) return barfoo()匿名函式lambda x:x+1def calc(x) return x+1res=calc(10)pri

c，c++中字串處理函式strtok，strstr，strchr，strsub

函式原型：char *strtok(char *s, char *delim); 函式功能：把字串s按照字串delim進行分割，然後返回分割的結果。函式使用說： 1.strtok函式的實質上的處理是，strtok在s中查詢包含在delim中的字元並用NULL(’/0′)來替換,直到找遍整個字串。這句

pat乙級1009說反話以及加強版

#include<iostream> #include<string.h> using namespace std; int main() { char st[81]; char

區間統計類guava中RangeSet使用以及注意

引入包：com.google.common.collect.RangeSet 主要方法有以下：區間段的統計，例如視訊觀看統計等計算，離散統計使用注意事項： 1、RangeSet 、Set<Range> 空構造方法沒外部暴露，所以Serializable序

R 中字串處理函式

字元完全匹配grep() 字元不完全匹配agrep() 字元替換gsub()#以上這些函式均可以通過perl=TRUE來使用正則表示式。 grep(pattern, x, ignore.case = FALSE, extended = TRUE, perl = FALSE, val

Highcharts中字串處理方式(3)

簡化節點賦值當圖表中存在多個數據列，並且每個資料列的節點的x值都是相同的，也可以直接在x軸的設定中，直接指定由name構成的刻度。其程式碼如下： xAxis:[{type:’category’,categories:[‘第一次’,’第二次’,’第三次’,’第四次’,’第五次’]}] 這樣做的結果就是將節

Java集合中List,Set以及Map等集合體系簡述

概述: List , Set, Map都是介面，前兩個繼承至collection介面，Map為獨立介面 Set下有HashSet，

轉：【Java並發編程】之八：多線程環境中安全使用集合API（含代碼）

控制 and clas ron com lan 創建 pri 基本上轉載請註明出處：http://blog.csdn.net/ns_code/article/details/17200509 在集合API中，最初設計的Vector和Hashtable是多線程安

Guava中關於字串處理以及加強版集合的使用記錄（個人學習筆記）

Guava中關於字串的處理

Guava中的Iterables的使用

Guava中的工具類Collections2的使用

Guava中的加強版集合的使用

相關推薦