[Guava]Guava框架-集合-集合工具类

1. Iterables(谷歌爸爸说建议使用JDK8的流,那我就不看了…)

2. Lists List集合工具类

1) Lists集合配备新建集合的工厂方法
/**
* 创建List集合的三种方式
*/
List<String> stringList1 = Lists.newArrayList();
List<String> stringList2 = Lists.newArrayList("a", "b", "c");
List<String> stringList3 = Lists.newArrayListWithCapacity(10);

2)Lists提供的其他工具方法:
  • partition(List, int) 将一个List集合按照指定的size进行均分,分为指定size的各个List集合
List<String> stringList = Lists.newArrayList("a", "b", "c");
List<List<String>> partition = Lists.partition(stringList, 2);// [[a, b], [c]]
System.out.println(partition);
  • reverse(List)反转集合中的元素

2. Sets Set集合工具类

1) 创建集合方法同Lists
2) Sets提供的其他工具方法
Set<String> s1 = ImmutableSet.of("one", "two", "three", "six", "seven", "eight");
Set<String> s2 = ImmutableSet.of("two", "three", "five", "seven");

/** 并集 */
System.out.println(Sets.union(s1, s2));// [one, two, three, six, seven, eight, five]
/** 交集 */
System.out.println(Sets.intersection(s1, s2));// [two, three, seven]
/** 按第一个集合为主,查询出第二个集合没有的元素 */
System.out.println(Sets.difference(s1, s2));// [one, six, eight]
/** 查出两个集合都不同的元素 */
System.out.println(Sets.symmetricDifference(s1, s2));// [one, six, eight, five]

Set<String> animals = ImmutableSet.of("gerbil", "hamster");
Set<String> fruits = ImmutableSet.of("apple", "orange", "banana");

/** 第一个集合中所有元素与第二个集合中配对,生成一堆List集合,两两在一起 */
Set<List<String>> product = Sets.cartesianProduct(animals, fruits);
// {{"gerbil", "apple"}, {"gerbil", "orange"}, {"gerbil", "banana"},
//  {"hamster", "apple"}, {"hamster", "orange"}, {"hamster", "banana"}}

/** 得出每个元素是第几个元素 */
Set<Set<String>> fruitsSets = Sets.powerSet(animals);
System.out.println(fruitsSets);
// powerSet({gerbil=0, hamster=1})

3. Maps Map集合工具类

1) 创建集合方法同Lists
2) Maps提供的其他工具方法
  • uniqueIndex(Iterable, Function) 把一个可迭代的容器中的数据通过一定的转换生成Key值存进Map,迭代的数据则作为Value值
ArrayList<String> strings = Lists.newArrayList("aaa2", "bbb");
/** 根据这些数据中的一些特性或者自定义Key值,而数据变成Value值 */
ImmutableMap<Integer, String> stringsByIndex = Maps.uniqueIndex(strings, new Function<String, Integer>() {
    public Integer apply(String string) {
        return string.length();
    }
});
System.out.println(stringsByIndex);
  • difference(Map, Map) 这个方法可以传入两个Map集合,然后获取到MapDifference对象,此对象封装着两个集合的比较情况
    MapDifference携带的方法:

    • entriesInCommon() 共同的Entry
    • entriesDiffering() 相同的一个Key值,但是Value不同的值
    • entriesOnlyOnLeft() 只有左边Map拥有的值
    • entriesOnlyOnRight() 只有右边Map拥有的值
Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);
Map<String, Integer> right = ImmutableMap.of("b", 2, "c", 4, "d", 5);
MapDifference<String, Integer> diff = Maps.difference(left, right);

diff.entriesInCommon(); // {"b" => 2}
diff.entriesDiffering(); // {"c" => (3, 4)}
diff.entriesOnlyOnLeft(); // {"a" => 1}
diff.entriesOnlyOnRight(); // {"d" => 5}
3) 针对BiMap的方法:
  • synchronizedBiMap(BiMap) 根据传递的BiMap参数生成一个线程安全的BiMap实例
  • unmodifiableBiMap(BiMap) 根据传递的BiMap参数生成一个不能修改的BiMap

4. Multisets Multiset工具类

1)创建方法见之前
2)其他方法
  • containsOccurrences(Multiset sup, Multiset sub) 遍历每个Multiset,当元素和个数都完全一样的时候返回true,containsAll只是比较元素是否相同
  • removeOccurrences(Multiset removeFrom, Multiset toRemove) 从第一个集合中移除掉第二个集合拥有的所有元素
  • retainOccurrences(Multiset removeFrom, Multiset toRetain) 遍历第一个集合中的每个元素,如果第二个元素没有则删掉,如果有但是数量小于第二个集合中的数量,则修改数量为这个小的数量
Multiset<String> multiset1 = HashMultiset.create();
multiset1.add("a", 2);
multiset1.add("b", 2);

Multiset<String> multiset2 = HashMultiset.create();
multiset2.add("a", 2);
multiset2.add("b", 3);
multiset2.add("b", 4);

/*
    遍历第一个集合中的每个元素,如果第二个元素没有则删掉,如果有但是数量小于第二个集合中的数量,则修改数量为这个小的数量
 */
boolean b = Multisets.retainOccurrences(multiset2, multiset1);
System.out.println(multiset2);// [a x 2, b x 2]
  • intersection(Multiset, Multiset) 两个集合取并集
  • copyHighestCountFirst(Multiset) 将传入的集合按数量排序返回视图
  • unmodifiableMultiset(Multiset) 返回不能修改的集合
  • unmodifiableSortedMultiset(SortedMultiset) 返回不能修改的集合

5. Multimaps Multimap集合工具类

1)创建方法见之前
2)其他方法
  • Multimaps.index(Iterable, Function) 封装函数转换其他集合为Multimap
ImmutableSet<String> digits = ImmutableSet.of("zero", "one", "two", "three", "four",
  "five", "six", "seven", "eight", "nine");
Function<String, Integer> lengthFunction = new Function<String, Integer>() {
  public Integer apply(String string) {
    return string.length();
  }
};
ImmutableListMultimap<Integer, String> digitsByLength = Multimaps.index(digits, lengthFunction);
/*
 * digitsByLength maps:
 *  3 => {"one", "two", "six"}
 *  4 => {"zero", "four", "five", "nine"}
 *  5 => {"three", "seven", "eight"}
 */
  • invertFrom(Multimap toInvert, Multimap dest)toInvert翻转封装到dest里面
ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.putAll("b", Ints.asList(2, 4, 6));
multimap.putAll("a", Ints.asList(4, 2, 1));
multimap.putAll("c", Ints.asList(2, 5, 3));

TreeMultimap<Integer, String> inverse = Multimaps.invertFrom(multimap, TreeMultimap.<String, Integer> create());
// note that we choose the implementation, so if we use a TreeMultimap, we get results in order
/*
 * inverse maps:
 *  1 => {"a"}
 *  2 => {"a", "b", "c"}
 *  3 => {"c"}
 *  4 => {"a", "b"}
 *  5 => {"c"}
 *  6 => {"b"}
 */
  • forMap(Map) 如果需要对一个Map使用Multimap提供的方法,用这个方法进行转换