guava

package com.example.demo;

import com.example.demo.dao.CityAnnotationMapper;
import com.example.demo.domain.City;
import com.google.common.base.Joiner;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.*;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import java.util.*;

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootdemoApplication.class)
@WebAppConfiguration
public class SpringbootdemoApplicationTests {
    @Autowired
    private CityAnnotationMapper cityAnnotationMapper;

    @Test
    public void contextLoads() {
        log.info("" + cityAnnotationMapper.selectAllCity());
        log.info("测试用例----------------------------------");

    }


    @Test
    public void optional() {
        //测试guava的optional
        //optional:一般数据库查询结果或者代用方法返回值 无一例外三种结果：1、操作成功，返回有值 2、操作成功，返回null  3、操作失败，返回null
        //通常处理，程序无法区别返回的null值是 2 还是 3 的情况，创建optional的类型变量，该变量只能包含1 和 2 的结果，当变量没有值的时候就是处于 3 的情况


        //1、创建允许null值的Optional
        Optional
 
   optionalResult = Optional.fromNullable(cityAnnotationMapper.selectByName("Qandahar"));
        if (optionalResult.isPresent()) {
            log.info(String.format("-----------查询数据库成功----------,其结果为：%s", optionalResult.get().getName()));
            //OptionalObject.or(): 和Optional对象值合并，如果为null为空则将or的参数作为默认值,可表达if else,是否为空时的初始化默认值行为
            //可以在接收 数据库查询结果 或者前台参数 或者调用方法返回值时 使用
            City defaultCity = new City();
            defaultCity.setName("默认城市名");
            log.info(String.format("-----------使用or方法判断赋值----------,其结果为：%s", optionalResult.or(defaultCity)));
        } else {
            log.info(String.format("-----------查询数据库成功----------,但其结果为：null"));

            //OptionalObject.or(): 和Optional对象值合并，如果为null为空则将or的参数作为默认值,可表达if else,是否为空时的初始化默认值行为
            //可以在接收 数据库查询结果 或者前台参数 或者调用方法返回值时 使用
            City defaultCity = new City();
            defaultCity.setName("默认城市名");
            log.info(String.format("-----------使用or方法判断赋值----------,其结果为：%s", optionalResult.or(defaultCity)));
        }


        //2、创Optional对象，输入参数不能为null,通常前台传参，或者方法形参校验，若引用为null则快速失败触发java.lang.NullPointerException
        Integer nubmerone = 4;
        Optional
  
    integerOptional = Optional.of(nubmerone); //orNull() == or(null) Optional
   
     optional = Optional.of(5); Integer value2 = optional.orNull(); log.info("value2 =" + value2); //3、创建空的的Optional实例,返回一个空Optional对象,isPresent() 将会返回false Optional
    
      nulloptional = Optional.absent();//null就是缺少的意思 //orNull() == or(null) Integer value1 = nulloptional.orNull(); log.info("value1 =" + value1); /** * 使用Optional的意义在哪儿？ 使用Optional除了赋予null语义，增加了可读性，最大的优点在于它是一种傻瓜式的防护。 Optional 迫使你积极思考引用缺失的情况 因为你必须显式地从Optional获取引用。 * eg: public static Optional
     
       sum(Optional
      
        a,Optional
       
         b){ if(a.isPresent() && b.isPresent()){ return Optional.of(a.get()+b.get()); } return Optional.absent(); } * * */ } /** * 校验参数 */ @Test public void checkParamTest() { Preconditions.checkArgument(1 > 2, "%s is wrong", "1 > 2"); Preconditions.checkNotNull(null, "参数为空"); } /** * 排序 */ @Test public void sortTest() { /** 　reverse(): 返回与当前Ordering相反的排序: 　　nullsFirst(): 返回一个将null放在non-null元素之前的Ordering，其他的和原始的Ordering一样； 　　nullsLast()：返回一个将null放在non-null元素之后的Ordering，其他的和原始的Ordering一样； 　　compound(Comparator)：返回一个使用Comparator的Ordering，Comparator作为第二排序元素，例如对bug列表进行排序，先根据bug的级别，再根据优先级进行排序； 　　lexicographical()：返回一个按照字典元素迭代的Ordering； 　　onResultOf(Function)：将function应用在各个元素上之后, 在使用原始ordering进行排序； 　　greatestOf(Iterable iterable, int k)：返回指定的第k个可迭代的最大的元素，按照这个从最大到最小的顺序。是不稳定的。 　　leastOf(Iterable
        
          iterable,int k)：返回指定的第k个可迭代的最小的元素，按照这个从最小到最大的顺序。是不稳定的。 　　isOrdered(Iterable)：是否有序，Iterable不能少于2个元素。 　　isStrictlyOrdered(Iterable)：是否严格有序。请注意，Iterable不能少于两个元素。 　　sortedCopy(Iterable)：返回指定的元素作为一个列表的排序副本。 */ //自然排序:整数从小到大，字符串是按字典顺序,日期按先后排序 //排序器 Ordering
         
           naturalOrdering1 = Ordering.natural(); List
          
            list = naturalOrdering1.sortedCopy(Lists.newArrayList(1, 5, 2, 4, 9, 7)); log.info("" + list); log.info("" + naturalOrdering1.min(Lists.newArrayList(1, 5, 2, 4, 9, 7))); //排序器2 Ordering
           
             naturalOrdering2 = Ordering.natural().reverse(); List
            
              list1 = naturalOrdering2.sortedCopy(Lists.newArrayList("c", "a", "w", "b", "1")); log.info("" + list1); log.info("" + naturalOrdering2.min(Lists.newArrayList("c", "a", "w", "b", "1"))); /** * 附加：对象集合的排序 */ List
             
               listB = new ArrayList
              
               (); //1、util包的排序 Collections.sort(listB, new Comparator
               
                () { public int compare(City b1, City b2) { return b1.getName().compareTo(b2.getName()); } }); //2、java8的排序 listB.sort(Comparator.comparing(City::getName).reversed()); } /** * splitter & joiner操作 */ @Test public void stringDo() { String str = "i'm ,just ,want ,go ,die"; //原生split 肢解 字符串数组 String[] arr = str.split(","); //guava 强化split String[] arr2 = new String[]{}; Iterable
                
                  Ite = Splitter.on(",").trimResults().omitEmptyStrings().split(str); //iterable ->list List
                 
                   li = Lists.newArrayList(Ite); //list ->array array.aslist(); arr2 = (String[]) li.toArray(arr2); // array ->list List
                  
                    li2 = Arrays.asList(arr2); //java string中有Split没Join，所以经常使用StringBuilder进行append，Joiner即是很好的替代。 String str2 = Joiner.on(",").skipNulls().join(arr2); String str3 =Joiner.on("; ").skipNulls().join("hah,","bitch"); } /** * 集合collection */ @Test public void collection(){ /** * 更加简易的集合声明 和初始化 */ //原始声明 Map
                   
                    > lookup = new HashMap
                    
                     >(); Map
                     
                      > lookup_java7 =new HashMap<>(); //guava声明 Map
                      
                       > lookup_guavaMap= Maps.newHashMap(); List
                       
                        >> lookup_guavalist =Lists.newArrayList(); //guava初始化 Set
                        
                          set= Sets.newHashSet("a","1","2"); List
                         
                           list=Lists.newArrayList("s","da","a"); Map
                          
                            map = ImmutableMap.of("key1", "value1", "key2", "value2"); /** * 不可变的集合定义 不可变的好处： 可以放心的给不信任的库使用 线程安全:可以被多个线程使用而不会有竞争条件发生 不需要同步(synchronization)的逻辑，不需要支持互斥 设计和实现很简单。所有不可变的集合实现比可变版本的内存效率要高 */ ImmutableSet
                           
                             numbers = ImmutableSet.of(10, 30, 40, 50); } }