java代码之美（2）

guava 复写Object常用方法

Guava 是一个 Google 的基于java1.6的类库集合的扩展项目，这个库提供用于集合，缓存，支持原语，并发性，常见注解，字符串处理，I/O和验证的实用方法。

这些高质量的 API 可以使你的Java代码更加优雅，更加简洁，让你工作更加轻松愉悦。

一、概述

在Java中Object类是所有类的父类，其中有几个需要override的方法比如equals,hashCode和toString等方法。每次写这几个方法都要做很多重复性的判断,

很多类库提供了覆写这几个方法的工具类, Guava也提供了类似的方式。下面我们来看看Guava中这几个方法简单使用。

Guava中Objects类提供了很多和Object类作用相同、效率更高的方法可供使用：

1、equal方法

使用Obejct的equals方法进行相等判断，例如：test.equals("test");如果test为null，则会发生NullPointerException，Objects的equal方法可以帮助你

避免NullPointerException，它的判断逻辑是这样的：return a == b || (a!=null&& a.equals(b));所以，可以很放心的使用，Objects.equal(test,"test")

当然在JDK7中也提供了同样判断逻辑的方法：Objects.equals(test,"test");

public class ObjectTest {

    @Test
    public void equalTest() {
        System.out.println(Objects.equal("a", "a"));
        System.out.println(Objects.equal(null, "a"));
        System.out.println(Objects.equal("a", null));
        System.out.println(Objects.equal(null, null));
    }
}
/**输出结果
 * true
 * false
 * false
 * true
 */

2、hashCode方法

对于hashCode首先要明白两点：

1、如果equals()判断两个对象相等，那么它们的hashCode()方法一定返回同样的值。

　　2、并没有强制要求如果equals()判断两个对象不相等，它们的hashCode可以相同也可以不同。

Guava提供给我们了一个更加简单的方法--Objects.hashCode(Object ...)， 这是个可变参数的方法，参数列表可以是任意数量，所以可以像这样

使用Objects.hashCode(field1， field2， ...，fieldn)。非常方便和简洁。

import org.junit.Test;
import com.google.common.base.Objects;

public class ObjectTest {
    @Test
    public void hashcodeTest() {
        System.out.println(Objects.hashCode("a"));
        System.out.println(Objects.hashCode("a"));
        System.out.println(Objects.hashCode("a","b"));
        System.out.println(Objects.hashCode("b","a"));
        System.out.println(Objects.hashCode("a","b","c"));

        Person person=new Person("peida",23);
        System.out.println(Objects.hashCode(person));
        System.out.println(Objects.hashCode(person));
    }
}

class Person {
    public String name;
    public int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

//输出结果
128
4066
4096
126145
19313256
19313256

3、toStringHelper()方法

因为每个类都直接或间接地继承自Object，因此每个类都有toString()方法。这个方法是用得最多的, 覆写得最多, 一个好的toString方法对于调试来说是非常重要的,

但是写起来确实很不爽。Guava也提供了toString（）方法。

通过toStringHelper方法来输出你需要输出的属性字段

import org.junit.Test;
import com.google.common.base.Objects;

public class ObjectTest {

    @Test
    public void toStringTest() {
         //this代表当前类，这里只输出x一个属性字段
        System.out.println(Objects.toStringHelper(this).add("x", 1).toString());

        //代表输出对象为Person对象  
       System.out.println(Objects.toStringHelper(Person.class).add("x", 1).toString());

        //add可以叠加
        Person person=new Person("peida",23);
        String result = Objects.toStringHelper(Person.class).add("name", person.name).add("age", person.age).toString();
        System.out.print(result);
    }
}
class Person {
    public String name;
    public int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
//============输出===============
ObjectTest{x=1}
Person{x=1}
Person{name=peida, age=23}

4、firstNonNull方法

Object的firstNonNull方法可以根据传入的两个参数来返回一个非Null的参数，Guava现在推荐使用MoreObjects.firstNonNull(T first,T second)替代它。

import com.google.common.base.MoreObjects;

public class TestFilter {

    public static void main(String[] args) {
      //name不为空
        String  name="张三";
        String nann=  MoreObjects.firstNonNull(name, "哈哈");
        System.out.println(nann);

      //sex为null
        String   sex=null;
        String   sexx=  MoreObjects.firstNonNull(sex, "哈哈");
        System.out.println(sexx);

    }
    /*
     *运行结果：
     *  张三
     *  哈哈
     */
}

在实际开发中，Objects.equal(test,"test")和MoreObjects.firstNonNull(T first,T second)在许多实际场合还是非常有帮助的。

Immutable(不可变)集合

一、概述

guava是google的一个库，弥补了java语言的很多方面的不足，很多在java8中已有实现，暂时不展开。Collections是jdk提供的一个工具类。

Guava中不可变对象和Collections工具类的unmodifiableSet/List/Map/etc的区别：

当Collections创建的不可变集合的wrapper类改变的时候，不可变集合也会改变，而Guava的Immutable集合保证确实是不可变的。

1、JDK中实现immutable集合

在JDK中提供了Collections.unmodifiableXXX系列方法来实现不可变集合, 但是存在一些问题，下面我们先看一个具体实例：

public class ImmutableTest {

    @Test
    public void testJDKImmutable(){
        List<String> list=new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");

        //通过list创建一个不可变的unmodifiableList集合
        List<String> unmodifiableList=Collections.unmodifiableList(list);
        System.out.println(unmodifiableList);

        //通过list添加元素
        list.add("ddd");
        System.out.println("往list添加一个元素:"+list);
        System.out.println("通过list添加元素之后的unmodifiableList:"+unmodifiableList);

        //通过unmodifiableList添加元素
        unmodifiableList.add("eee");
        System.out.println("往unmodifiableList添加一个元素:"+unmodifiableList);

    }
}

运行结果：

通过运行结果我们可以看出：虽然unmodifiableList不可以直接添加元素，但是我的list是可以添加元素的，而list的改变也会使unmodifiableList改变。

所以说Collections.unmodifiableList实现的不是真正的不可变集合。

2、Guava的immutable集合

Guava提供了对JDK里标准集合类里的immutable版本的简单方便的实现，以及Guava自己的一些专门集合类的immutable实现。当你不希望修改一个集合类，

或者想做一个常量集合类的时候，使用immutable集合类就是一个最佳的编程实践。

注意：每个Guava immutable集合类的实现都拒绝null值。我们做过对Google内部代码的全面的调查，并且发现只有5%的情况下集合类允许null值，而95%的情况下

都拒绝null值。万一你真的需要能接受null值的集合类，你可以考虑用Collections.unmodifiableXXX。

immutable集合可以有以下几种方式来创建：

　　1、用copyOf方法, 譬如, ImmutableSet.copyOf(set)

　　2、使用of方法，譬如，ImmutableSet.of("a", "b", "c")或者ImmutableMap.of("a", 1, "b", 2)

　　3、使用Builder类

举例：

 @Test
    public void testGuavaImmutable(){

        List<String> list=new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");

        ImmutableList<String> imlist=ImmutableList.copyOf(list);
        System.out.println("imlist："+imlist);

        ImmutableList<String> imOflist=ImmutableList.of("peida","jerry","harry");
        System.out.println("imOflist："+imOflist);

        ImmutableSortedSet<String> imSortList=ImmutableSortedSet.of("a", "b", "c", "a", "d", "b");
        System.out.println("imSortList："+imSortList);

        list.add("baby");
        //关键看这里是否imlist也添加新元素了
        System.out.println("list添加新元素之后看imlist:"+imlist);

        ImmutableSet<Color> imColorSet =
                ImmutableSet.<Color>builder()
                        .add(new Color(0, 255, 255))
                        .add(new Color(0, 191, 255))
                        .build();

        System.out.println("imColorSet:"+imColorSet);
    }

运行结果：发现imlist并未改变。

对于排序的集合来说有例外，因为元素的顺序在构建集合的时候就被固定下来了。譬如，ImmutableSet.of("a", "b", "c", "a", "d", "b")，对于这个集合的遍历顺序来说就是"a", "b", "c", "d"。

更智能的copyOf

copyOf方法比你想象的要智能，ImmutableXXX.copyOf会在合适的情况下避免拷贝元素的操作－先忽略具体的细节，但是它的实现一般都是很“智能”的。譬如：

  @Test
        public void testCotyOf(){
            ImmutableSet<String> imSet=ImmutableSet.of("peida","jerry","harry","lisa");
            System.out.println("imSet："+imSet);

            //set直接转list
            ImmutableList<String> imlist=ImmutableList.copyOf(imSet);
            System.out.println("imlist："+imlist);

            //list直接转SortedSet
            ImmutableSortedSet<String> imSortSet=ImmutableSortedSet.copyOf(imSet);
            System.out.println("imSortSet："+imSortSet);

            List<String> list=new ArrayList<String>();
            for(int i=0;i<=10;i++){
                list.add(i+"x");
            }
            System.out.println("list："+list);

            //截取集合部分元素
            ImmutableList<String> imInfolist=ImmutableList.copyOf(list.subList(2, 8));
            System.out.println("imInfolist："+imInfolist);
        }

运行结果

Guava集合和不可变对应关系

可变集合类型	可变集合源：JDK or Guava?	Guava不可变集合
Collection	JDK	ImmutableCollection
List	JDK	ImmutableList
Set	JDK	ImmutableSet
SortedSet/NavigableSet	JDK	ImmutableSortedSet
Map	JDK	ImmutableMap
SortedMap	JDK	ImmutableSortedMap
Multiset	Guava	ImmutableMultiset
SortedMultiset	Guava	ImmutableSortedMultiset
Multimap	Guava	ImmutableMultimap
ListMultimap	Guava	ImmutableListMultimap
SetMultimap	Guava	ImmutableSetMultimap
BiMap	Guava	ImmutableBiMap
ClassToInstanceMap	Guava	ImmutableClassToInstanceMap
Table	Guava	ImmutableTable

guava之Multiset

一、概述

Guava提供了一个新集合类型Multiset，它可以多次添加相等的元素，且和元素顺序无关。Multiset继承于JDK的Cllection接口，而不是Set接口。它和set最大的区别就是

它可以对相同元素做一个计数的功能，普通的 Set 就像这样 :[car, ship, bike]，而 Multiset 会是这样 : [car x 2, ship x 6, bike x 3]Multiset有一个有用的功能，

就是跟踪每种对象的数量，所以你可以用来进行数字统计。每存放一个相同元素，那么该元素的count就加1。

譬如一个 List 里面有各种字符串，然后你要统计每个字符串在 List 里面出现的次数，这个用Multiset就能够快速实现。

1、举例说明

import com.google.common.collect.HashMultiset;
import com.google.common.collect.Multiset;

public class MultisetTest {

    public static void main(String[] args) {

        String str = "张三 李四 李四 王五 王五 王五";
        String[] strArr = str.split(" ");

        List<String> words = new ArrayList<String>(Arrays.asList(strArr));

        //创建一个HashMultiset集合，并将words集合数据放入
        Multiset<String> wordMultiset = HashMultiset.create();
        wordMultiset.addAll(words);

        //将不同的元素放在一个集合set中
        for (String key : wordMultiset.elementSet()) {
            //查看指定元素的个数
            System.out.println(key + "-->" + wordMultiset.count(key));
        }

        System.out.println("---------向集合中添加元素----------");
        //向集合中添加元素
        wordMultiset.add("李四");
        for (String key : wordMultiset.elementSet()) {
            System.out.println(key + "-->" + wordMultiset.count(key));
        }

        System.out.println("-------向集合中添加若干个元素------");
        //向集合中添加若干个元素
        wordMultiset.add("赵六", 10);
        for (String key : wordMultiset.elementSet()) {
            System.out.println(key + "-->" + wordMultiset.count(key));
        }

        System.out.println("--------向集合中移出一个元素------");
        //向集合中移出一个元素
        wordMultiset.remove("张三");
        for (String key : wordMultiset.elementSet()) {
            System.out.println(key + "-->" + wordMultiset.count(key));
        }

        System.out.println("------向集合中移出若干个元素------");
        //向集合中移出若干个元素,如果元素的个数小于要移除的个数，则会把该元素移除光
        wordMultiset.remove("赵六",5);
        for (String key : wordMultiset.elementSet()) {
            System.out.println(key + "-->" + wordMultiset.count(key));
        }

        System.out.println("-----设定某一个元素的重复次数-----");
        //设定某一个元素的重复次数
        wordMultiset.setCount("张三", 10);
        for (String key : wordMultiset.elementSet()) {
            System.out.println(key + "-->" + wordMultiset.count(key));
        }

        System.out.println("-----设置复合元素的个数设为新的重复次数-----");
        //设置复合元素的个数设为新的重复次数(条件是第二个参数的数量要是实际数量一致，否则无效)
        wordMultiset.setCount("and", 1,0);
        for (String key : wordMultiset.elementSet()) {
            System.out.println(key + "-->" + wordMultiset.count(key));
        }

        System.out.println("-------删除给定集合中的元素------");
        //删除给定集合中的元素
        wordMultiset.removeAll(words);
        for (String key : wordMultiset.elementSet()) {
            System.out.println(key + "-->" + wordMultiset.count(key));
        }
    }
} 

主要看运行结果：

根据运行结果我们得到：

（1）它把把list放入HashMultiset中，就成了key还是list的属性，value就是重复数的一个计数。

（2）每添加一个相同元素，计数+1。

（3）可以添加和移除计数的值。

2、Multiset主要方法介绍

• add(E element) :向其中添加单个元素

• add(E element,int occurrences) : 向其中添加指定个数的元素

• count(Object element) : 返回给定参数元素的个数

• remove(E element) : 移除一个元素，其count值 会响应减少

• remove(E element,int occurrences): 移除相应个数的元素

• elementSet() : 将不同的元素放入一个Set中

• entrySet(): 类似与Map.entrySet 返回Set<Multiset.Entry>。包含的Entry支持使用getElement()和getCount()

• setCount(E element ,int count): 设定某一个元素的重复次数

• setCount(E element,int oldCount,int newCount): 将符合原有重复个数的元素修改为新的重复次数

• retainAll(Collection c) : 保留出现在给定集合参数的所有的元素

• removeAll(Collectionc) : 去除出现给给定集合参数的所有的元素

3、常用的实现了Multiset 接口的类

1、HashMultiset: 元素存放于 HashMap

2、LinkedHashMultiset: 元素存放于 LinkedHashMap，即元素的排列顺序由第一次放入的顺序决定

3、TreeMultiset:元素被排序存放于TreeMap

4、EnumMultiset: 元素必须是 enum 类型

5、ImmutableMultiset: 不可修改的 Mutiset

4、Multiset与Map<E, Integer>区别

实际开发中我们也可以利用Map<E, Integer>来实现计数功能，但它和Multiset还是有很大区别的，首先Multiset也不是Map<E, Integer>类型的结构，区别如下：

1、Multiset中的元素出现的次数只能为正数，前面说了原因。如果E的出现次数为0，那么E将不出现在multiset中，是不能在elementSet()和entrySet()的视图中；

2、multiset.size()返回这个集合的大小，相当于在multiset中元素的出现的总数。如果想得到multiset中不同元素出现的总数，可以利用elementSet().size()来实现；

3、multiset.iterator()可以遍历multiset中的所有元素，所以iteration遍历的次数就等于multiset.size()；

4、Multiset支持添加、删除元素，设置元素出现的次数；setCount(elem, 0)相当于移除elem的所有元素；

5、multiset.count(elem)方法中的elem如果没有出现在Multiset中，那么它的返回值永远都是0。

guava之multimap

上一篇讲到Multiset它可以对存入相同元素做一个计数的功能，那multimap呢？

一、概述

1、基本介绍和案例说明

multimap和MultiSet的继承结果很相似，只不过在上层的接口是Multimap不是Multiset。

Multimap的特点其实就是可以包含有几个重复Key的value，你可以put进入多个不同value但是相同的key，但是又不是让后面覆盖前面的内容。

它的业务场景：当你需要构造像Map<K, List<V>>或者Map<K, Set<V>>这样比较复杂的集合类型的数据结构，来做相应的业务逻辑处理。那Multimap在合适不过。

举例

        @Test
        public void testMultimap(){
        HashMultimap<Integer, Integer> map = HashMultimap.create();
        map.put(1, 2);
        map.put(1, 3);
        map.put(1, 2);
        map.put(2, 3);
        map.put(4, 2);
        map.put(4, 3);
        map.put(4, 2);
        map.put(4, 3);
        System.out.println(map.toString());
    }
}
/*输出结果：
 *{1=[2, 3], 2=[3], 4=[2, 3]}
 */

其实它会把相同key和value的值给覆盖起来，但是相同的key又可以保留不同的value。因为它的entry的实现是一个set，set会对相同的Entry<K,V>进行去重，所以会有这种情况。

2、实际开发场景及常用方法

 （1）根据业务需要对下面的list数据根据name字段来进行分组：

[
    {
        "date":"2018-01-31",
        "name":"wuzhong",
        "socre":0.8
    },
    {
        "date":"2018-01-30",
        "name":"wuzhong",
        "socre":0.9
    },
    {
        "date":"2018-01-31",
        "name":"wuzhong2",
        "socre":0.8
    }
]

传统做法：

//Item就是封装的对象
Map<String,List<Item>> map = new HashMap<>();
for (Item item : list){
  List<Item> tmp = map.get(item.getName());
  if (null == tmp){
      tmp = new ArrayList<>();
      map.put(item.getName(),tmp);
  }
  tmp.add(item);
}

很简单， 但是代码量有点多，特别是需要判断List为null并初始化。

再用guava实现上述的功能：

Multimap<String,Item> multiMap = ArrayListMultimap.create();
for (Item item : list){
    multiMap.put(item.getName(),item);
}

代码量直接减少了一半，这就是实际开发中它发挥的作用。

（2）再举一例子了解常用方法：

public class MultimapTest {

        public static void main(String args[]){

              Multimap<String,String> multimap = ArrayListMultimap.create();

            multimap.put("lower", "a");
            multimap.put("lower", "b");
            multimap.put("lower", "c");

            multimap.put("upper", "A");
            multimap.put("upper", "B");

            List<String> lowerList = (List<String>)multimap.get("lower");
            //输出key为lower的list集合
            System.out.println("输出key为lower的list集合=========");
            System.out.println(lowerList.toString());
            lowerList.add("f");
            System.out.println(lowerList.toString());

            Map<String, Collection<String>> map = multimap.asMap();
            System.out.println("把Multimap转为一个map============");
            for (Map.Entry<String,  Collection<String>> entry : map.entrySet()) {
                String key = entry.getKey();
                Collection<String> value =  multimap.get(key);
                System.out.println(key + ":" + value);
            }

            System.out.println("获得所有Multimap的key值==========");
            Set<String> keys =  multimap.keySet();
            for(String key:keys){
                System.out.println(key);
            }

            System.out.println("输出Multimap所有的value值========");
            Collection<String> values = multimap.values();
            System.out.println(values);
        }
}
/**输出结果：
 *输出key为lower的list集合=========
 * [a, b, c]
 * [a, b, c, f]
 * 把Multimap转为一个map============
 * lower:[a, b, c, f]
 * upper:[A, B]
 * 获得所有Multimap的key值==========
 * lower
 * upper
 * 输出Multimap所有的value值========
 * [a, b, c, f, A, B]
  */

4、Multimap的实现类

　　Multimap提供了丰富的实现，所以你可以用它来替代程序里的Map<K, Collection<V>>，具体的实现如下：

　　Implementation            Keys 的行为类似       　　　Values的行为类似

　　ArrayListMultimap         HashMap                   　　ArrayList

　　HashMultimap               HashMap                  　　 HashSet

　　LinkedListMultimap        LinkedHashMap*              LinkedList*

　　LinkedHashMultimap      LinkedHashMap                LinkedHashSet

　　TreeMultimap                TreeMap                          TreeSet

　　ImmutableListMultimap  ImmutableMap                 ImmutableList

　　ImmutableSetMultimap  ImmutableMap                 ImmutableSet　　

　　以上这些实现，除了immutable的实现都支持null的键和值。

　　1、LinkedListMultimap.entries()能维持迭代时的顺序。

　　2、LinkedHashMultimap维持插入的顺序，以及键的插入顺序。

guava之Bimap

bimap的作用很清晰：它是一个一一映射，可以通过key得到value，也可以通过value得到key。

一、概述

1、bimap和普通HashMap区别

（1）在Java集合类库中的Map，它的特点是存放的键（Key）是唯一的，而值（Value）可以不唯一，而

bimap要求key和value都唯一，如果key不唯一则覆盖key，如果value不唯一则直接报错。

2、案例展示

public class bimapTest {
        public static void main(String args[]){

            //双向map
            BiMap<Integer,String> biMap=HashBiMap.create();
            biMap.put(1,"张三");
            biMap.put(2,"李四");
            biMap.put(3,"王五");
            biMap.put(4,"赵六");
            biMap.put(5,"李七");
            biMap.put(4,"小小");

            //通过key值得到value值(注意key里面的类型根据泛行
            String value= biMap.get(1);
            System.out.println("id为1的value值 --"+value);

            //通过value值得到key值
            int key= biMap.inverse().get("张三");
            System.out.println("张三key值 --"+key);

            //通过key值重复，那么vakue值会被覆盖。
            String valuename= biMap.get(4);
            System.out.println("id为4的value值 --"+valuename);
        }
}
/*运行结果：
 *id为1的value值 --张三
 *张三key值 --1
 *id为4的value值 --小小
 */

如果value值重复，则运行直接报错如下：

  biMap.put(6,"小小");
            /**后台直接报错
             * Exception in thread "main" java.lang.IllegalArgumentException: value already present: 小小
             *     at com.google.common.collect.HashBiMap.put(HashBiMap.java:285)
             *     at com.google.common.collect.HashBiMap.put(HashBiMap.java:260)
             *     at com.jincou.stream.study.bimapTest.main(bimapTest.java:40)
             */

如果你想value也发生覆盖key值，那么可以：

   // inverse方法会返回一个反转的BiMap，但是注意这个反转的map不是新的map对象，它实现了一种视图关联，这样你对于反转后的map的所有操作都会影响原先的map对象。
       biMap.forcePut(6,"小小");
       int key6= biMap.inverse().get("小小");
       System.out.println("小小key值 --"+key6);

     /**后台输出（已经把：biMap.put(4,"小小"覆盖）
       *
       * 小小key值 --6
       */

3、Bimap实现类

BiMap的常用实现有：

1、HashBiMap: key 集合与 value 集合都有 HashMap 实现

2、EnumBiMap: key 与 value 都必须是 enum 类型

3、ImmutableBiMap: 不可修改的 BiMap

guava字符串工具

在java开发过程中对字符串的处理是非常频繁的，google的guava工具对字符串的一些处理进行优化，使我们开发过程中让自己的代码看去更加美观，清爽。

一、Joiner

根据给定的分隔符把字符串连接到一起。MapJoiner 执行相同的操作，但是针对 Map 的 key 和 value。

分析源码可知：该类构造方法被private修身，无法直接通过new实现，通过调用on传如分隔符来得到实例。

案例

public class JoinerTest {

    public static void main(String args[]){

     //1、将list字符串集合，以,形式转为字符串
        List<String> list =new ArrayList<String>();
        list.add("xx");
        list.add("zz");
        list.add("dd");

        //Joiner.on(",")获得Joiner实例对象
        Joiner joiner =  Joiner.on(",");
        //joiner.join(list)传入操作的集合，并转成字符串格式
        System.out.println(joiner.join(list));
        //输出结果：xx,zz,dd

     //2、将Iterator<T>列表，转为字符串
        Iterator<String> it=list.iterator();
        String  str=Joiner.on("|").join(it);
        System.out.println(str);
        //输出结果：xx|zz|dd

     //3、连接多个字符串
        String str1=Joiner.on(",").join("小小","爸爸","妈妈","爷爷","奶奶");
        System.out.println(str1);
        //输出：小小,爸爸,妈妈,爷爷,奶奶

     //4、连接字符串与列表
        StringBuilder builder=new StringBuilder("小小最乖");
        //返回StringBuilder类型
        StringBuilder str2=Joiner.on(",").appendTo(builder,list);
        System.out.println(str2);
        //输出：小小最乖xx,zz,dd

     //5、跳过null值连接
        list.add(null);
        list.add("小小");
        //skipNulls()代表去除null
        String str3=Joiner.on(",").skipNulls().join(list);
        System.out.println(str3);
        //输出：xx,zz,dd,小小

     //6、替换null值进行连接
        String str4=Joiner.on(",").useForNull("空").join(list);
        System.out.println(str4);
        //输出：xx,zz,dd,空,小小

     //7、Map的键值对打印出来
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");
        Joiner.MapJoiner mapJoiner = Joiner.on(",").withKeyValueSeparator("=");
        System.out.println(mapJoiner.join(map));
        //输出：key1=value1,key2=value2,key3=value3     

    //8、一步将字符串转为List<Long>集合（前面先转为list<String>,后面用java8特性将List<String>转为List<Long>)
    List<Long> list=Splitter.on("#").splitToList("111#222#333").stream().mapToLong(str->Long.parseLong(str)).boxed().distinct().collect(Collectors.toList());

} }

Joiner在实际开发中，用处还是蛮大的。

二、Splitter

主要功能是拆分字符串为集合 Map等。 通过分析源码可知，该工具类是通过on函数传入拆分字符得到实例。

案例：

public class SplitterTest {

    public static void main(String args[]){

     //1、拆分字符串为List集合
        String str="小小,妈妈,爸爸,爷爷,奶奶";
        Splitter splitter =Splitter.on(",");
        List<String> list=splitter.splitToList(str);
        System.out.println(list);
        //输出：[小小, 妈妈, 爸爸, 爷爷, 奶奶]

     //2、忽略空字符
        String str1="a,b,c,d,,f,g";
        //omitEmptyStrings()代表去除空字符串
        List<String> list1=Splitter.on(",").omitEmptyStrings().splitToList(str1);
        System.out.println(list1);
        //输出：[a, b, c, d, f, g]

     //3、忽略空字符且去除字符串前后空格
        String str2="a,b,c,d,,f,  g  ";
        List<String> list2=Splitter.on(",").omitEmptyStrings().trimResults().splitToList(str2);
        System.out.println(list2);
        //输出：[a, b, c, d, f, g]
    }
}

三、Strings

案例

public class StringsTest {

    public static void main(String args[]){

     //1、补右全（Strings.padEnd方法）
        String a="12345";
        String b=Strings.padEnd(a, 10, 'x');
        System.out.println(b);
        //输出：12345xxxxx

     //2、补左全（Strings.padStart）
        String c=Strings.padStart(a, 10, 'x');
        System.out.println(c);
        //输出：xxxxx12345

     //3、校验空值和null
        String d="";
        String f=null;
        boolean e=Strings.isNullOrEmpty(d);
        boolean h=Strings.isNullOrEmpty(f);
        System.out.println(e);
        System.out.println(h);
        //输出：true,true

     //4、如果为null 转为""
        String m=null;
        String n=Strings.nullToEmpty(m);
        System.out.println(n);
        //输出：

     //5、如果为"" 转为null
        String j="";
        String k=Strings.emptyToNull(j);
        System.out.println(k);
        //输出：null

     //6、重复字符串（Strings.repeat）
        String o="123";
        String p=Strings.repeat(o, 3);
        System.out.println(p);
        //输出：123123123

     //7、获取a,b左公共部分字符串（左边第一个公共部分）
        String r="abcdsfsfs";
        String s="accdc3sfsd";
        String t=Strings.commonPrefix(r, s);
        System.out.println(t);
        //输出：a

    //8、获取a,b右公共部分字符串
        String w="faaxyz";
        String x="fwefxyz";
        String z=Strings.commonSuffix(w, x);
        System.out.println(z);
        //输出：xyz
    }
}

guava之Lists、Maps

谷歌提供了guava包里面有很多的工具类，Lists和Maps集合工具，集合操作做了些优化提升。

1、概述

1、静态工厂方法

（1）Guava提供了能够推断范型的静态工厂方法

List<Person> list = Lists.newArrayList();
Map<KeyType, Person> map = Maps.newLinkedHashMap();

(2) 用工厂方法模式，我们可以方便地在初始化时就指定起始元素。

Set<Type> copySet = Sets.newHashSet(elements);
List<String> theseElements = Lists.newArrayList("alpha", "beta", "gamma");

(3) 通过为工厂方法命名，我们可以提高集合初始化大小的可读性.

List<Type> exactly100 = Lists.newArrayListWithCapacity(100);
List<Type> approx100 = Lists.newArrayListWithExpectedSize(100);
Set<Type> approx100Set = Sets.newHashSetWithExpectedSize(100);

二、Lists案例

public class ListsTest {

    public static void main(String args[]){

    List<String> list1 = Lists.newArrayList();
        for (int i = 0; i < 10; i++) {
        list1.add(i + "");
    }
        System.out.println("list1: " + list1);
        //输出：list1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

   //2、传入多参数
     List<String> list2 = Lists.newArrayList("1", "2", "3");
        System.out.println("list2: " + list2);
        //输出：list2: [1, 2, 3]

   //3、传入数组
     List<String> list3 = Lists.newArrayList(new String[]{"22", "22"});
        System.out.println("list3: " + list3);
        //输出：list3: [22, 22]

   //4、传入集合
     List<String> list4 = Lists.newArrayList(list1);
        System.out.println("list4: " + list4);
        //输出：list4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

   //5、使用条件：你确定你的容器会装多少个，不确定就用一般形式的
    //说明：这个容器超过10个还是会自动扩容的。不用担心容量不够用。默认是分配一个容量为10的数组，不够将扩容
    //整个来说的优点有：节约内存，节约时间，节约性能。代码质量提高。
    List<String> list = Lists.newArrayListWithExpectedSize(10);
    //这个方法就是直接返回一个10的数组。
    List<String> list_ = Lists.newArrayListWithCapacity(10);
   }
}

三、Maps案例

public class MapsTest {
        public static void main(String[] args) {

            //1、Maps.newHashMap()获得HashMap();
            Map<Integer, Integer> map0 = Maps.newHashMap();
            for (int i = 0; i < 10; i++) {
                map0.put(i, i);
            }
            System.out.println("map0：" + map0);
            //输出：map0：{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9}

            //2、传入map0参数构建map
            Map<Integer, Integer> map1 = Maps.newHashMap(map0);
            map1.put(10, 10);
            System.out.println("map1：" + map1);
            //输出：map1：{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9, 10=10}

            //3、使用条件：你确定你的容器会装多少个，不确定就用一般形式的
            //说明：这个容器超过3个还是会自动扩容的。不用担心容量不够用。默认是分配一个容量为16的数组，不够将扩容
            Map<Integer, Integer> map2 = Maps.newHashMapWithExpectedSize(3);
            map2.put(1, 1);
            map2.put(2, 2);
            map2.put(3, 3);
            System.out.println("map2：" + map2);
            //输出：map2：{1=1, 2=2, 3=3}

            //4、LinkedHashMap<K, V> 有序map
            //Map<Integer,Integer> map3 = Maps.newLinkedHashMap();
            //Map<Integer,Integer> map3 = Maps.newLinkedHashMapWithExpectedSize(11);
            Map<Integer, Integer> map3 = Maps.newLinkedHashMap(map1);
            map3.put(11, 11);
            System.out.println("map3：" + map3);
            //输出：map3：{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9, 10=10, 11=11}

            outMapKeyValue(map3);

        }

        /**
         * 遍历Map的四种方法
         */
        private static void outMapKeyValue(Map<Integer, Integer> map3) {

            //1.通过Map.entrySet遍历key和value
            for (Map.Entry<Integer, Integer> integerEntry : map3.entrySet()) {
                System.out.println("key：" + integerEntry.getKey() + " value：" + integerEntry.getValue());
            }

            //2.通过Map.entrySet使用iterator遍历key和value-----不推荐，直接用上面的for each循环代替此方法
            Iterator<Map.Entry<Integer, Integer>> it = map3.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry<Integer, Integer> entry = it.next();
                System.out.println("key：" + entry.getKey() + " value：" + entry.getValue());
            }

            //3.通过Map.keySet遍历key；根据key得到value
            for (Integer integer : map3.keySet()) {
                System.out.println("key：" + integer + " value：" + map3.get(integer));
            }

            //4.通过Map.values()遍历所有的value，但不能遍历key
            for (Integer integer : map3.values()) {
                System.out.println("value：" + integer);
            }
        }
}