添加Maven依赖
ListsTest
import com.google.common.collect.Lists;
import org.hamcrest.core.Is;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
public class ListsTest {
@Test
public void test_new_normal() {
ArrayList<String> objects = Lists.newArrayList("a", "b", "c");
List<List<String>> partition = Lists.partition(objects, 2);
Assert.assertEquals(2, partition.size());
}
@Test
public void test_reverse() {
ArrayList<String> strings = Lists.newArrayList("a", "b", "c");
ArrayList<String> reverse = Lists.newArrayList("c", "b", "a");
Assert.assertThat(Lists.reverse(strings), Is.is(reverse));
}
@Test(expected = AssertionError.class)
public void test_partition_ex() {
ArrayList<String> objects = Lists.newArrayList("a");
List<List<String>> partition = Lists.partition(objects, 2);
Assert.assertEquals(2, partition.size());
}
}
MapsTest
import com.google.common.collect.*;
import org.junit.Assert;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;
public class MapsTest {
@Test
public void test_asMap() {
Map<Integer, Integer> map = Maps.asMap(Sets.newHashSet(1, 2, 3), i -> i == null ? 0 : i * i);
Assert.assertThat(map, is(Map.of(1, 1, 2, 4, 3, 9)));
}
/**
* ArrayListMultimap：接口Multimap的实现，它使用ArrayList存储给定键的值。 HashMap将每个键与值的ArrayList相关联。
* 迭代此类提供的集合时，给定键的值的排序与添加值的顺序一致。
* 此多图允许重复的键值对。 添加等于现有键值对的新键值对后，ArrayListMultimap将包含新值和旧值的条目。
* 键和值可以为null。 支持所有可选的multimap方法，并且所有返回的视图都是可修改的。
* get，removeAll和replaceValues返回的列表都实现了java.util.RandomAccess。
* 当任何并发操作更新multimap时，此类不是线程安全的。
* 并发读取操作将正常工作。 要允许并发更新操作，请通过调用Multimaps.synchronizedListMultimap来包装。
*/
@Test
public void test_arrayListMultiMap() {
ArrayListMultimap<String, String> multiMap = ArrayListMultimap.create();
multiMap.put("Foo", "1");
multiMap.put("Foo", "2");
multiMap.put("Foo", "3");
multiMap.put("Foo", "3");
List<String> expected = Lists.newArrayList("1", "2", "3", "3");
assertEquals(multiMap.get("Foo"), expected);
}
/**
* 使用哈希表实现Multimap。
* 多图不存储重复的键值对。 添加等于现有键值对的新键值对无效。
* 键和值可以为null。 支持所有可选的multimap方法，并且所有返回的视图都是可修改的。
* 当任何并发操作更新multimap时，此类不是线程安全的。 并发读取操作将正常工作。
* 要允许并发更新操作，请通过调用Multimaps.synchronizedSetMultimap来包装。
*/
@Test
public void test_hashMultiMap() {
HashMultimap<String, String> multiMap = HashMultimap.create();
multiMap.put("Foo", "1");
multiMap.put("Foo", "3");
multiMap.put("Foo", "2");
multiMap.put("Foo", "3");
Set<String> expected = Sets.newHashSet("1", "2", "3");
assertEquals(multiMap.get("Foo"), expected);
}
@Test(expected = IllegalArgumentException.class)
public void test_biMap() {
BiMap<String, String> biMap = HashBiMap.create();
biMap.put("1", "Tom");
biMap.put("2", "Tom");
}
/**
* forcePut:另一种put形式，它在继续执行put操作之前以静默方式删除任何具有值的现有条目。
* 如果bimap以前包含提供的键值映射，则此方法无效。
* 警告：如果删除具有此值的现有条目，则会丢弃该条目的键，并且不会返回该键。
*/
@Test
public void test_biMap_forcePut() {
BiMap<String, String> biMap = HashBiMap.create();
biMap.forcePut("1", "Tom");
biMap.forcePut("2", "Tom");
assertTrue(biMap.containsKey("2"));
assertFalse(biMap.containsKey("1"));
}
/**
* 返回此bimap的反向视图，该视图将每个bimap的值映射到其关联的键。
* 两个bimaps由相同的数据支持; 对一个的任何更改都会出现在另一个中。
*/
@Test
public void test_biMap_reverse() {
BiMap<String, String> biMap = HashBiMap.create();
biMap.put("1", "Tom");
biMap.put("2", "Harry");
assertThat(biMap.get("1"), is("Tom"));
assertThat(biMap.get("2"), is("Harry"));
BiMap<String, String> inverseMap = biMap.inverse();
assertThat(inverseMap.get("Tom"), is("1"));
assertThat(inverseMap.get("Harry"), is("2"));
}
@Test
public void test_multimap_builder() {
Multimap<Integer, String> map = new ImmutableListMultimap.Builder<Integer, String>().put(1, "Foo").putAll(2, "Foo", "Bar", "Baz").putAll(4, "Huey", "Duey", "Luey").put(3, "Single").build();
ArrayListMultimap<Integer, String> multimap = ArrayListMultimap.create();
multimap.put(1, "Foo");
multimap.putAll(2, Arrays.asList("Foo", "Bar", "Baz"));
multimap.put(3, "Single");
multimap.putAll(4, Arrays.asList("Huey", "Duey", "Luey"));
Assert.assertThat(map, is(multimap));
}
}
SetsTest
import com.google.common.collect.Sets;
import org.junit.Assert;
import org.junit.Test;
import java.util.Set;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
public class SetsTest {
/**
* 返回两组差异的不可修改视图。 返回的集合包含set1包含但未包含在set2中的所有元素。 而set2包含set1却不存在的元素都会被忽略。
* 返回集的迭代顺序与set1的迭代顺序匹配。
*/
@Test
public void test_difference() {
Set<String> s1 = Sets.newHashSet("1", "2", "3");
Set<String> s2 = Sets.newHashSet("2", "3", "4");
Sets.SetView<String> difference = Sets.difference(s1, s2);
Assert.assertTrue(difference.contains("1"));
Assert.assertEquals(1, difference.size());
}
/**
* 返回的集合包含set1或set2中包含但不同时包含在两者中的所有元素。
* 返回集的迭代顺序未定义。
*/
@Test
public void test_symmetricDifference() {
Set<String> s1 = Sets.newHashSet("1", "2", "3");
Set<String> s2 = Sets.newHashSet("2", "3", "4");
Sets.SetView setView = Sets.symmetricDifference(s1, s2);
//Would return [1,4]
Assert.assertEquals(2, setView.size());
Assert.assertTrue(setView.contains("1"));
Assert.assertTrue(setView.contains("4"));
}
/**
* 返回两个集合的交集。 返回集的迭代顺序与set1的迭代顺序匹配。
*/
@Test
public void test_intersection() {
Set<String> s1 = Sets.newHashSet("1", "2", "3");
Set<String> s2 = Sets.newHashSet("3", "2", "4");
Sets.SetView<String> sv = Sets.intersection(s1, s2);
assertThat(sv.size() == 2 && sv.contains("2") && sv.contains("3"), is(true));
}
/**
* 返回两个集合的合集，返回集的迭代顺序与set1的迭代顺序匹配，剩余的与set2的迭代顺序匹配。
*/
@Test
public void test_union() {
Set<String> s1 = Sets.newHashSet("1", "2", "3");
Set<String> s2 = Sets.newHashSet("3", "2", "4");
Sets.SetView<String> sv = Sets.union(s1, s2);
assertThat(sv.size() == 4 && sv.contains("2") && sv.contains("3") && sv.contains("4") && sv.contains("1"), is(true));
}
@Test
public void test_filter() {
Set<Integer> s1 = Sets.newHashSet(1, 4, 2, 6);
Set<Integer> filter = Sets.filter(s1, input -> input != null && input > 2);
assertThat(filter.size() == 2 && filter.contains(4) && filter.contains(6), is(true));
}
}