Guava学习笔记（三）：集合

添加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));
    }
}