Guava基本用法

一、只读设置

package Guava;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import com.google.common.collect.ImmutableList;
/**
 * 只读设置
 */
public class Demo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        //对原有的List进行包装，相当于原有List的视图，快照,不够安全.
        List<String> readList = Collections.unmodifiableList(list);
        //java.lang.UnsupportedOperationException
        //readList.add("d");//报错
        list.add("d");//改变原有List   视图也一起改变  不报错
        System.out.println(readList);

        //Guava
        //对比查看  初始化List guava对只读设置安全可靠 并且相对简单
        List<String> immutableList = ImmutableList.of("a","b","c");
        //java.lang.UnsupportedOperationException
        //immutableList.add("d");//报错
        System.out.println(immutableList);
    }
}

运行结果：

[a, b, c, d]
[a, b, c]

二、函数式编程

package Guava;

import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;

/**
 * 函数式编程：解耦
 * 1、Predicate 断言
 * 2、Function
 * 函数的组合式编程
 * Functions.compose(f1, f2);
 * 工具： Collections2.filter   过滤器
 *      Collections2.transform 转换
 */
public class Demo02 {
    public static void main(String[] args) {
        test1();//过滤器
        System.out.println("----------------");
        test2();
        System.out.println("----------------");
        test3();

    }

    //过滤器
    public static void test1()
    {
        //创建List 静态初始化
        List<String> list = Lists.newArrayList("SDF","SDAF","FASD","MOOM","ESDSE");
        //找出回文
        //匿名内部类对象：匿名内部类，同时创建类对象
        Collection<String> palindroomList = Collections2.filter(list, new Predicate<String>() {
            public boolean apply(String input)
            {
                //业务逻辑
                return new StringBuilder(input).reverse().toString().equals(input);
            }
        });

        for(String temp:palindroomList)
        {
            System.out.println(temp);
        }
    }

    //转换
    public static void test2()
    {
        //类型转换
        Set<Long> timeSet = Sets.newHashSet();
        timeSet.add(1000000L);
        timeSet.add(999999999999L);
        timeSet.add(20000000L);

        Collection<String> timeStrCol = Collections2.transform(timeSet, new Function<Long, String>() {
            @Override
            public String apply(Long input) {
                return new SimpleDateFormat("yyyy-MM-dd").format(input);
            }
        });

        for(String temp:timeStrCol)
        {
            System.out.println(temp);
        }
    }

    //组合式函数编程
    public static void test3(){
        //确保容器中的字符串长度不超过5，超过进行截取，后全部大写
        List<String> list = Lists.newArrayList("lovebaby","good","happiness");

        //确保容器中的字符串长度不超过5，超过进行截取
        Function<String, String> f1 = new Function<String, String>() {
            @Override
            public String apply(String input) {
                return input.length()>5?input.substring(0,5):input;
            }
        };

        //全部大写
        Function<String, String> f2 = new Function<String, String>() {
            @Override
            public String apply(String input) {
                return input.toUpperCase();
            }
        };

        //组合使用
        //String = f2(f1(String))
        Function<String, String> f = Functions.compose(f1, f2);

        Collection<String> resultCol = Collections2.transform(list,f);

        for(String temp:resultCol)
        {
            System.out.println(temp);
        }
    }
}

运行结果：

MOOM
ESDSE
----------------
1970-01-01
1970-01-01
2001-09-09
----------------
LOVEB
GOOD
HAPPI

三、约束条件

package Guava;

import static com.google.common.base.Preconditions.checkNotNull;

import java.util.Collection;
import java.util.Set;

import com.google.common.collect.ForwardingSet;
import com.google.common.collect.Lists;

/**
 * 解决guava-18.0.jar不能使用
 * com.google.common.collect.Constraints、
 * com.google.common.collect.Constraint 的问题。
 * @author liguodong
 * @param <E>
 */
interface Constraint<E>{
    //public String checkElement(String element);
    E checkElement(E element);
}

class Constraints<E>{
    public static <E> Set<E> constrainedSet(
              Set<E> set, Constraint<? super E> constraint) {
            return new ConstrainedSet<E>(set, constraint);
          }
     private static <E> Collection<E> checkElements(
              Collection<E> elements, Constraint<? super E> constraint) {
            Collection<E> copy = Lists.newArrayList(elements);
            for (E element : copy) {
              constraint.checkElement(element);
            }
            return copy;
          }
     /** @see Constraints#constrainedSet */
     static class ConstrainedSet<E> extends ForwardingSet<E> {
       private final Set<E> delegate;
       private final Constraint<? super E> constraint;

       public ConstrainedSet(Set<E> delegate, Constraint<? super E> constraint) {
         this.delegate = checkNotNull(delegate);
         this.constraint = checkNotNull(constraint);
       }
       @Override protected Set<E> delegate() {
         return delegate;
       }
       @Override public boolean add(E element) {
         constraint.checkElement(element);
         return delegate.add(element);
       }
       @Override public boolean addAll(Collection<? extends E> elements) {
         return delegate.addAll(checkElements(elements, constraint));
       }
     }
}
package Guava;

import java.util.Set;

import com.google.common.base.Preconditions;
//import com.google.common.collect.Constraint;
//import com.google.common.collect.Constraints;
import com.google.common.collect.Sets;

/**
 * 加入约束条件：非空，长度验证
 * Constraint
 * Precondiotions
 * Constrains
 */
public class Demo03 {
    public static void main(String[] args) {
        Set<String> sets = Sets.newHashSet();
        //创建约束
        Constraint<String> constraint = new Constraint<String>() {
            @Override
            public String checkElement(String element) {
                //非空验证
                Preconditions.checkNotNull(element);
                //长度验证5-20
                Preconditions.checkArgument(element.length()>=5&&element.length()<=20);
                return element;
            }
        };
        Set<String> cs = Constraints.constrainedSet(sets, constraint);
        //cs.add(null);// java.lang.NullPointerException
        //cs.add("doog");//java.lang.IllegalArgumentException
        cs.add("liguodong");
        for(String temp:cs)
        {
            System.out.println(temp);
        }
    }
}

运行结果：

liguodong

四、集合的操作

package Guava;

import java.util.Set;
import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;

/**
 * 集合的操作：交集，差集，并集
 * Sets.intersection()
 * Sets.difference()
 * Sets.union()
 */

public class Demo04 {
    public static void main(String[] args) {
        Set<Integer> sets = Sets.newHashSet(1,2,3,4,5,6);
        Set<Integer> sets2 = Sets.newHashSet(3,4,5,6,7,8,9);

        //交集
        System.out.println("交集为：");
        SetView<Integer> intersection = Sets.intersection(sets, sets2);
        for(Integer temp:intersection)
        {
            System.out.print(temp+" ");
        }
        System.out.println();
        //差集
        System.out.println("差集为：");
        SetView<Integer> diff = Sets.difference(sets, sets2);
        for(Integer temp:diff)
        {
            System.out.print(temp+" ");
        }
        System.out.println();
        //并集
        System.out.println("并集为：");
        SetView<Integer> union = Sets.union(sets, sets2);
        for(Integer temp:union)
        {
            System.out.print(temp+" ");
        }
        System.out.println();
    }
}

运行结果：

交集为：
3 4 5 6
差集为：
1 2
并集为：
1 2 3 4 5 6 7 8 9

五、MultiSet

package Guava;

import java.util.Set;
import com.google.common.collect.HashMultiset;
import com.google.common.collect.Multiset;

/**
 * 统计单词出现的次数
 * 1.HashMap 分拣存储+面向对象思维-->判断
 * 2.MultiSet:无序+可重复   count()方法获取单词的次数  增强了可读性+操作简单
 */

public class Demo05 {
    public static void main(String[] args) {
        String str = "this is a cat that is a mice where is the food";
        //分割字符串
        String[] strArray = str.split(" ");
        //存储到Multiset中
        Multiset<String> set = HashMultiset.create();
        for(String temp :strArray)
        {
            set.add(temp);
        }
        //获取所有的单词Set
        Set<String> letters = set.elementSet();
        for(String temp:letters)
        {
            System.out.println(temp+"-->"+set.count(temp));
        }
    }
}

运行结果：

mice-->1
that-->1
cat-->1
is-->3
food-->1
a-->2
the-->1
where-->1
this-->1

六、Multimap

package Guava;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;

/**
 * 分析查看 教师 教授 的每门课程
 * Multimap：key-value  key可以重复
 */
public class Demo06 {
    public static void main(String[] args) {
        Map<String,String> cours = new HashMap<>();
        //加入测试数据
        cours.put("改革开放","邓小平");
        cours.put("三个代表","江泽民");
        cours.put("和谐社会","胡锦涛");
        cours.put("八荣八耻","胡锦涛");
        cours.put("互联网+","李克强");
        //Multimap
        Multimap<String, String> teachers = ArrayListMultimap.create();
        //迭代器
        Iterator<Map.Entry<String, String>> it = cours.entrySet().iterator();
        while(it.hasNext())
        {
            Map.Entry<String, String> entry = it.next();
            String key = entry.getKey();//课程
            String value = entry.getValue();//教师
            //教师-->课程
            teachers.put(value,key);
        }
        //查看Multimap
        Set<String> keyset = teachers.keySet();
        for(String key:keyset)
        {
            Collection<String> col = teachers.get(key);
            System.out.println(key+"-->"+col);
        }
    }
}

运行结果：

邓小平-->[改革开放]
江泽民-->[三个代表]
胡锦涛-->[八荣八耻, 和谐社会]
李克强-->[互联网+]

七、BiMap

package Guava;

import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;

/**
 * HashMap 键唯一，值可以重复
 * BiMap:双向Map(Bidirectional Map) 键与值都不能重复(unique -valued map)
 */
public class Demo07 {
    public static void main(String[] args) {
        BiMap<String, String> biMap = HashBiMap.create();
        biMap.put("liguodong", "[email protected]");
        biMap.put("good","[email protected]");
        //通过邮箱找用户
        String user = biMap.inverse().get("[email protected]");
        System.out.println(user);
        System.out.println( biMap.inverse().inverse()==biMap );
    }
}

运行结果：

good
true

八、双键的Map

package Guava;

import java.util.Map;
import java.util.Set;

import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import com.google.common.collect.Table.Cell;
import com.google.common.collect.Tables;

/**
 * 双键的Map--> Table-->rowKey+columnKey+value
 * 1.方法
 *   所有的行数据:cellSet()
 *   所有的学生：rowKeySet()
 *   所有的课程：columnKeySet()
 *   所有的成绩：values()
 *   学生对应的课程：rowMap()+get(学生)
 *               row(学生)
 *
 *   课程对应的学生：columnMap()+get(课程)
 *               column(课程)
 */
public class Demo08 {
    public static void main(String[] args) {
        Table<String, String, Integer> tables = HashBasedTable.create();
        //测试数据
        tables.put("a", "javase", 80);
        tables.put("b", "javase", 90);
        tables.put("a", "oracle", 100);
        tables.put("c", "javase", 95);

        //所有的行数据
        Set<Cell<String, String, Integer>> cells = tables.cellSet();
        for(Cell<String, String, Integer> temp:cells)
        {
            System.out.println(temp.getRowKey()+"-->"+temp.getColumnKey()+"-->"+temp.getValue());
        }

        System.out.println("=======学生查看成绩============");
        System.out.print("学生\t");
        //所有的课程
        Set<String> cours = tables.columnKeySet();
        for(String t:cours)
        {
            System.out.print(t+"\t");
        }
        System.out.println();

        //所有的学生
        Set<String> stus = tables.rowKeySet();

        for(String stu:stus)
        {
            System.out.print(stu+"\t");//输出学生

            //以下是输出学生的每一门课程
            Map<String,Integer> scores = tables.row(stu);//<课程,分数>

            for(String c:cours)//课程
            {
                System.out.print(scores.get(c)+"\t");
            }
            System.out.println();
        }

        System.out.println("=======课程查看成绩============");
        System.out.print("课程\t");
        //所有的学生
        Set<String> stus1 = tables.rowKeySet();

        for(String t:stus1)
        {
            System.out.print(t+"\t");
        }
        System.out.println();

        //所有的课程
        Set<String> cours1 = tables.columnKeySet();

        for(String c:cours1)
        {
            System.out.print(c+"\t");//课程
            Map<String,Integer> scores = tables.column(c);//<学生,分数>
            for(String s:stus1)
            {
                System.out.print(scores.get(s)+"\t");
            }
            System.out.println();
        }

        System.out.println("=======转换===========");
        Table<String, String, Integer> tables2 = Tables.transpose(tables);

        //所有的行数据
        Set<Cell<String, String, Integer>> cells2 = tables2.cellSet();
        for(Cell<String, String, Integer> temp:cells2)
        {
            System.out.println(temp.getRowKey()+"-->"+temp.getColumnKey()+"-->"+temp.getValue());
        }
    }
}

运行结果：

b-->javase-->90
c-->javase-->95
a-->oracle-->100
a-->javase-->80
=======学生查看成绩============
学生  javase  oracle
b   90  null
c   95  null
a   80  100
=======课程查看成绩============
课程  b   c   a
javase  90  95  80
oracle  null    null    100
=======转换===========
javase-->b-->90
javase-->c-->95
oracle-->a-->100
javase-->a-->80
时间： 2024-10-13 15:19:40

Guava基本用法的相关文章

Google Guava 库用法整理&lt;转&gt;

参考: http://codemunchies.com/2009/10/beautiful-code-with-google-collections-guava-and-static-imports-part-1/(2,3,4) http://blog.publicobject.com 更多用法参考http://ajoo.iteye.com/category/119082 附 guava中文api地址http://ifeve.com/google-guava/ 以前这么用: Java代码   M

Java 学习文章汇总

目前JAVA可以说是产业界和学术界最热门的语言,许多人都很急切想把JAVA学好. 但学习是需要步骤的,除非像电影中演的那样,能够把需要的专业技巧下载到脑海:主角只花了几秒下载资料,就马上具备飞行员的技巧,或是武侠小说中的运功传送内力的方式,否则花上一段时间苦学是少不了的.花时间,不打紧,就怕方法错误,事倍功半. java 学习文章推荐.java学习线路.java 知识图谱. HTML5 微数据 RDFa/微格式 使用 jQuery 的 Autocomplete 插件实现input输入提示功能 创

Guava中Predicate的常见用法

1.  Predicate基本用法 guava提供了许多利用Functions和Predicates来操作Collections的工具,一般在 Iterables, Lists, Sets, Maps, Multimaps中用到. Predicate最基本的用法就是对Collection进行过滤,guava中很多集合的filter方法都是用Predicate来实现过滤的. Collection type Filter method Iterable Iterables.filter(Iterab

【java】【guava】Google Guava的splitter用法

Google Guava的splitter,分割字符串的用法 package com.sxd.swapping.guava; import com.google.common.base.CharMatcher; import com.google.common.base.Splitter; import org.assertj.core.util.Lists; import org.junit.Test; import org.junit.runner.RunWith; import org.s

Guava: 事件总线EventBus

EventBus 直译过来就是事件总线,它使用发布订阅模式支持组件之间的通信,不需要显式地注册回调,比观察者模式更灵活,可用于替换Java中传统的事件监听模式,EventBus的作用就是解耦,它不是通用的发布订阅系统,也不能用于进程间通信.可用于Android的EventBus库主要有这几个:Google出品的Guava,Guava是一个庞大的库,EventBus 只是它附带的一个小功能,因此实际项目中使用并不多.用的最多的是greenrobot/EventBus,这个库的优点是接口简洁,集成方

Spring中@Cacheable的用法

在Spring中通过获取MemCachedClient来实现与memcached服务器进行数据读取的方式.不过,在实际开发中,我们往往是通过Spring的@Cacheable来实现数据的缓存的,所以,本文给大家详细介绍一下@Cacheable的用法.首先,在使用@Cacheable之前,我们要做好准备工作. 第一步:要导入相应的jar包.   <classpathentry kind="lib" path="lib/spring-core-4.1.4.RELEASE.j

Guava学习笔记：EventBus（转）

EventBus是Guava的事件处理机制,是设计模式中的观察者模式(生产/消费者编程模型)的优雅实现.对于事件监听和发布订阅模式,EventBus是一个非常优雅和简单解决方案,我们不用创建复杂的类和接口层次结构. Observer模式是比较常用的设计模式之一,虽然有时候在具体代码里,它不一定叫这个名字,比如改头换面叫个Listener,但模式就是这个模式.手工实现一个Observer也不是多复杂的一件事,只是因为这个设计模式实在太常用了,Java就把它放到了JDK里面:Observable和O

Guava学习笔记：　Files

Guava Files中的文件操作 转载:http://outofmemory.cn/java/guava/IO/Files-operation 介绍Guava IO包提供的方便操作文件的方法,包括:读文件,写文件,复制移动文件等操作 Java的基本API对文件的操作很繁琐,为了向文件中写入一行文本,都需要写十几行的代码.guava对此作了很多改进,提供了很多方便的操作. 一. Guava的文件写入 Guava的Files类中提供了几个write方法来简化向文件中写入内容的操作,下面的例子演示 

Java返回类型泛型的用法小结

Java返回类型泛型的用法小结 版权声明:本文为博主原创文章,未经博主允许不得转载. 关于Java泛型的基本用法就不多说了,主要是一个编译期的检查,也避免了我们代码中的强制转换,比较经典的用法有泛型DAO,泛型Page的DTO. 现在我要说的是一个挺有趣但是貌似还不是太多的人在代码中使用的方法,前段时间用guava和op4j的时候发现这样的用法,看看了源码,也是很简单的. 比如guava中创建集合的方法 List<xx> list = Lists.newArrayList(),这个代替了我们传