Guava字符串的部分使用

package com.sinosoft.web.controller.test.GuavaTest;


import com.google.common.base.CharMatcher;
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableSet;
import org.junit.Assert;
import org.junit.Test;

import java.awt.*;
import java.io.FileWriter;

//Guava的使用
public class GuavaTestController {


    /**
     * 字符串处理
     */

    /**
     * splitter(分割字符串）
     */
    @Test
    public void splitter() {
        Iterable<String> split = Splitter.on(",").trimResults()//移除结果字符串的前导空白和尾部空白
                .omitEmptyStrings()//从结果集中自动忽略空字符串
                .limit(2).//限制拆分出的字符串数量
                split("     aa,bb   cc ,,,,sdd");

        //拆分器返回的是Iterable<String>
        //如果想直接返回list 可以直接使用 Lists.newArrayList(splitter.split(string))或类似方法
        for (String aa : split) {
            System.out.println(aa);
        }
        //重点：splitter实例总是不可变的。
        //用来定义splitter目标语义的 配置方法总会返回一个新的splitter实例。
        //这使得splitter实例都是线程安全的，可以将其定义为static final常量（也就是说 可以把split函数之前的代码定义成一个全局静态变量，到处使用）

    }

    /**
     * 连接(Joiner)
     */
    @Test
    public void joinerTest() throws Exception {

        //一般用法
        Joiner joiner = Joiner.on("123").skipNulls();//参数是拼接的字符串
        String join = joiner.join("123", null, "foo", "bar");
        System.out.println(join);// 123123foo123bar


        //appendTo到实现了Appendable接口的类中

        Joiner joineR = Joiner.on("++").skipNulls();

        // 1, append到StringBuilder
        StringBuilder stringBuilder = new StringBuilder();
        StringBuilder builder = joineR.appendTo(stringBuilder, " foo ", " bar ");
        System.out.println(builder); //  foo ++ bar

        //2. append到输出流
        FileWriter fileWriter = new FileWriter("append.txt");
        joineR.appendTo(fileWriter, " foo ", " bar "); //会将  foo ++ bar输出打印到append.txt文档中
        fileWriter.close();
    }


    // CharMatcher(字符匹配处理)


    @Test
    public void charMatcherTest() {
        //他是一个简化版的正则工具
        //按照定义的匹配规则，对字符串进行替换 保留 移除等操作
        String lettersAndNumber = "foo999sadfas32q1432";
        // 保留数字
        String retained = CharMatcher.JAVA_DIGIT.retainFrom(lettersAndNumber);
        System.out.println("保留数字" + retained);//保留数字999321432

        //移除数字
        String removeFrom = CharMatcher.JAVA_DIGIT.removeFrom(lettersAndNumber);
        System.out.println("移除数字" + removeFrom);//移除数字foosadfasq

        //通过Or组合多个匹配规则
        CharMatcher charMatcher = CharMatcher.JAVA_DIGIT.or(CharMatcher.WHITESPACE);
        String retainFromWithOr = charMatcher.retainFrom("foo9 89y bar xda 234");
        System.out.println("or: " + retainFromWithOr);//or: 9 89   234  保留了数字和空格


        /**
         * CharMatcher的用法总结
         * 1 定义匹配字符的规则
         * 2 使用了内置函数对字符进行处理（移除 保留等）
         *
         *
         * 各处理函数：
         * collapseFrom:连续的匹配字符替换为特定字符。比如把多个空格替换成一个
         * removeFrom:移除所有匹配的字符
         * retainFrom:保留匹配字符，移除其他字符
         * trimFrom:移除字符序列的前导匹配字符和尾部匹配字符
         * replaceFrom:用特定字符序列替代匹配字符
         * matchesAllof:测试是否字符序列中的所有字符都匹配
         */
    }

    //集合：
    //不可变集合

    /**
     * 不可变集合是不可被修改的集合。集合的数据是在创建的时候提供，并且在整个生命周期中都不可改变。
     * 不可变集合是及其有益的一种存储数据的形式，把一次创建多次读取的数据用不可变集合来承载。
     * 好处是：
     * 不可变集合不用考虑变化，因此可以节省时间和空间。所有不可变的集合都比他们的可变形式有更好的内存利用率
     * 不可变对象被多个线程调用时，不存在竞态条件问题。
     * 不可变对象因为有固定不变，可以作为常量来安全使用
     * 创建对象的不可变拷贝是一项很好的防御性编程技巧
     * <p>
     * 重要提示：Guava不可变集合的实现是都不接受null值
     */


    //不可变集合
    @Test
    public void copytest() {
        //不可变集合的三种方式创建：
        //1 copyOf方法   如ImmutableSet.copyOf(set)
        //2 of方法  如ImmutableMap.of("a",2,"b",3);
        //3 Builder工具

    }


    /**
     * Guava缓存
     */

    @Test
    public void guavaTest() throws  Exception{

        //guava缓存有两种创建方式：
        //创建CacheLoader
        //LoadingCache是附带CacheLoader构建而成的缓存实现。创建自己的CacheLoader通常只需要简单的实现 V load(K key) throws Exception 方法。
        // 代码


        CacheLoader<String,String> loader = new CacheLoader<String, String>() {
            @Override
            public String load(String s) throws Exception {
                return s.toUpperCase();
            }
        };


        LoadingCache<String,String> cache = CacheBuilder.newBuilder().build(loader);

        System.out.println(cache.size());
        cache.getUnchecked("hello");
        System.out.println(cache.size());
        System.out.println(cache.get("hello"));
        System.out.println(cache.size());
        cache.cleanUp();
        System.out.println("--------------");
        System.out.println(cache.size());
        /**
         * 因为hello键对应值在缓存中没有，所以值被计算并被缓存。注意，我们使用getUnchecked()方法，如果对应的值不存在，则计算并缓存值到缓存中。
         *
         *
         * 驱逐策略：
         * 每个缓存需要在必要时删除内容，从缓存中清楚值机制，使用会有不同的标准。
         *
         *     大小驱逐：
         *          通过maxmmSize()方法限制缓存大小，如果缓存达到上限，最老的项将被驱逐。
         *
         *
         *
         *
         *
         */















    }



















}