Guava字符串的部分使用

￡神魔★判官ぃ 2023-06-10 03:21 19阅读 0赞

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()方法限制缓存大小，如果缓存达到上限，最老的项将被驱逐。
             *
             *
             *
             *
             *
             */
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
        }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    }