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图,待续。。。。。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值