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