Guava---collection集合用法

List

• 创建

	//初始化
	    ImmutableList<Integer> of = ImmutableList.of(1, 2, 3);
        LinkedList<Object> linkedList = Lists.newLinkedList();
        ArrayList<String> list2 = Lists.newArrayList();
        //处始化大小
        ArrayList<String> list3 = Lists.newArrayListWithCapacity(10);
        //处始化，并添加元素
        String[] ss = {"2"};
        List<String> list = Lists.asList("1", ss);
        ArrayList<String> list4 = Lists.newArrayList("A","B");

• 常用方法介绍

        //笛卡儿积
        List<List<String>> list5 = Lists.cartesianProduct(Lists.newArrayList("A","B"), Lists.newArrayList("1","2"));
        System.out.println(list5);//[[A, 1], [A, 2], [B, 1], [B, 2]]

        //元素转换
        List<String> transform = Lists.transform(Lists.newArrayList("A","B"), new Function<String, String>() {
            @Nullable
            @Override
            public String apply(@Nullable String input) {
                return input.toLowerCase();
            }
        });
        System.out.println(transform);//[a, b]

        //字符串转化为字符，返回ImmutableList，Immutable是不可变对象
        ImmutableList<Character> list6 = Lists.charactersOf("mnbvcxz");
        System.out.println(list6);//[m, n, b, v, c, x, z]

        //reversed
        List<Character> reverse = Lists.reverse(list6);
        System.out.println(reverse);//[z, x, c, v, b, n, m]

        //按个数分组
        List<List<Character>> partition = Lists.partition(reverse, 3);
        System.out.println(partition);//[[z, x, c], [v, b, n], [m]]

上述方法，其实实际并未将元素改变，是在正在需要拿元素的时候，才将相关元素按照指定变化。这是一个很重要思想，避免了一开始就遍历元素一个个将元素变化

• list存在null排序问题

        /**
         * jdk 排序
         *
         * 但是存在一个问题，不能为null，否则将抛出异常
         */
        List<Integer> list = Arrays.asList(1, 3, 2, 4,null);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);

上述代码会抛错，因为存在null无法排序，这时需要传递一个Comparator进去、
guava为我们提供了Ordering类

        List<Integer> list = Arrays.asList(1, 3, 2, 4,null);
        System.out.println(list);
        //将null放到第一个
        Collections.sort(list, Ordering.natural().nullsFirst());
        System.out.println(list);
        //判断list是否是有序
         System.out.println(Ordering.natural().nullsFirst().isOrdered(list));
        //倒序
		//Ordering.natural().reverse().nullsFirst()

Set

• 创建

HashSet<Integer> set = Sets.newHashSet(1, 2, 3);
HashSet<Integer> set1 = Sets.newHashSet(Lists.newArrayList(1, 1, 2, 3, 4));

• 常用方法

 	//子集，size表示每一个子集的个数
        Set<Set<Integer>> set2 = Sets.combinations(Sets.newHashSet(1, 2, 3), 2);
        set2.forEach(System.out::print);//[1, 2][1, 3][2, 3]
        //差集，交集，并集

Map

• map

	 //map构建
        HashMap<Object, Object> hashMap = Maps.newHashMap();
        Maps.newHashMapWithExpectedSize(5);
        ConcurrentMap<Object, Object> concurrentMap = Maps.newConcurrentMap();//线程安全map
        ImmutableMap<Object, Object> immutableMap = ImmutableMap.builder()
                .put(1, "文文是猪").build();

        //map初始化并赋值
        Map<Integer, String> map = Maps.asMap(Sets.newHashSet(1, 2, 3), k -> k + "_value");
        System.out.println(map);//{1=1_value, 2=2_value, 3=3_value}
        ImmutableMap<String, Integer> map1 = Maps.uniqueIndex(Lists.newArrayList(1, 2, 3), v -> v + "_key");
        System.out.println(map1);//{1_key=1, 2_key=2, 3_key=3}

        //map修改value
        Map<Integer, String> map2 = Maps.transformValues(map, v -> v + "transformValues");
        System.out.println(map2);//{1=1_valuetransformValues, 2=2_valuetransformValues, 3=3_valuetransformValues}

        //按key过滤
        Map<Integer, String> map3 = Maps.filterKeys(map, key -> key == 1);
        System.out.println(map3);//{1=1_value}

• Multimap

        /**
         * LinkedListMultimap
         * <p>
         *  非线程安全
         * 可以存储相同key
         * get方法返回的是list
         * </p>
         * <p>
         *     线程安全使用：
         *     Multimap<Object, Object>  multimap= Multimaps.synchronizedMultimap(LinkedListMultimap.create());
         * </p>
         *
         *
         */
        LinkedListMultimap<Object, Object> multimap = LinkedListMultimap.create();


        multimap.put("1", "2");
        multimap.put("1", "2");
        multimap.put("1", "3");
        multimap.put("1", "4");
        System.out.println(multimap);//{1=[2, 2, 3, 4]}


        /**
         * HashMultimap
         * <p>
         * 非线程安全
         * 可以存储相同key
         * 相同key value覆盖
         * get方法返回的是set
         * </p>
         * <p>
         *     线程安全使用：
         *    Multimap<Object, Object>  hashMultimap= Multimaps.synchronizedMultimap(HashMultimap.create());
         * </p>
         */
        HashMultimap<Object, Object> hashMultimap = HashMultimap.create();
        hashMultimap.put("1", "2");
        hashMultimap.put("1", "2");
        hashMultimap.put("1", "3");
        hashMultimap.put("1", "4");
        System.out.println(hashMultimap);//{1=[4, 2, 3]}

• BiMap

        /**
         * 非线程安全
         * 不能存在相同key,也不能存在相同value
         * 
         * 线程安全使用： Maps.synchronizedBiMap(biMap)
         */
        //相同key覆盖，相同value抛错
        HashBiMap<Object, Object> biMap = HashBiMap.create();
        biMap.put("11","2");
        biMap.put("1","3");
        System.out.println(biMap);//{11=2, 1=3}
        try {
            biMap.put("2","3");
        } catch (Exception e) {
            e.printStackTrace();//java.lang.IllegalArgumentException: value already present: 3
        }
        //强行加元素，若value和之前的相同，则覆盖之前的entry
        biMap.forcePut("3","3");
        System.out.println(biMap);//{11=2, 3=3}

• NavigableMap和TreeRangeMap

        //[]
        Range<Integer> closed = Range.closed(1, 5);
        //()
        Range<Integer> open = Range.open(1, 5);
        //(]
        Range<Integer> openClosed = Range.openClosed(1, 5);
        //[)
        Range<Integer> closedOpen = Range.closedOpen(1, 5);

        TreeMap<Integer, String> treeMap = Maps.newTreeMap();
        treeMap.put(1,"111");
        treeMap.put(3,"333");
        treeMap.put(2,"222");
        treeMap.put(4,"444");
        System.out.println(treeMap);//{1=111, 2=222, 3=333, 4=444}

        NavigableMap<Integer, String> subMap = Maps.subMap(treeMap, Range.closed(1, 3));
        System.out.println(subMap);//{1=111, 2=222, 3=333}


        TreeRangeMap<Integer, String> rangeMap = TreeRangeMap.create();
        rangeMap.put(Range.closed(90,100),"A");
        rangeMap.put(Range.closed(60,89),"B");
        System.out.println(rangeMap);//[[60..89]=B, [90..100]=A]
        System.out.println(rangeMap.get(99));//A

table

        //Map<key,Map< >>
        HashBasedTable<Object, Object, Object> table = HashBasedTable.create();
        table.put(1,2,3);
        System.out.println(table);
        table.put(1,2,4);
        System.out.println(table);
        Object o = table.get(1, 2);
        Map<Object, Object> row = table.row(1);
        Map<Object, Object> column = table.column(2);

guava的collection实在是太多了，这里介绍一部分用法。后续学习数据结构把实现原理及用到的算法详细介绍一遍，以及整个的设计的设计模式和UML图，待续。。。。。