Lists
Lists类主要提供了对List类的子类构造以及操作的静态方法。在Lists类中支持构造ArrayList、LinkedList以及newCopyOnWriteArrayList对象的方法。
其中提供了以下构造ArrayList的函数:下面四个构造一个ArrayList对象,但是不显式的给出申请空间的大小:
newArrayList()
newArrayList(E... elements)
newArrayList(Iterable<? extends E> elements)
newArrayList(Iterator<? extends E> elements)
以下两个函数在构造ArrayList对象的时候给出了需要分配空间的大小:
newArrayListWithCapacity(int initialArraySize)
newArrayListWithExpectedSize(int estimatedSize)
如果你事先知道元素的个数,可以用newArrayListWithCapacity函数;如果你不能确定元素的个数,可以用newArrayListWithExpectedSize函数,在newArrayListWithExpectedSize函数里面调用了computeArrayListCapacity(int arraySize)函数,其实现如下:
@VisibleForTesting static int computeArrayListCapacity(int arraySize) {
checkArgument(arraySize >= 0);
// TODO(kevinb): Figure out the right behavior, and document it
return Ints.saturatedCast(5L + arraySize + (arraySize / 10));
}
返回的容量大小为5L + arraySize + (arraySize / 10),当arraySize比较大的时候,给定大小和真正分配的容量之比为10/11。
Lists类还支持构造LinkedList、newCopyOnWriteArrayList对象,其函数接口为:
newLinkedList()
newLinkedList(Iterable<? extends E> elements)
newCopyOnWriteArrayList()
newCopyOnWriteArrayList(Iterable<? extends E> elements)
我们还可以将两个(或三个)类型相同的数据存放在一个list中,这样可以传入到只有一个参数的函数或者需要减少参数的函数中,这些函数如下:
asList(@Nullable E first, E[] rest)
asList(@Nullable E first, @Nullable E second, E[] rest)
Lists类中transform函数可以根据传进来的function对fromList进行相应的处理,并将处理得到的结果存入到新的list对象中,这样有利于我们进行分析,函数接口如下:
public static <F, T> List<T> transform(
List<F> fromList, Function<? super F, ? extends T> function)
但是使用这个类的是需要注意一点,转化之后的集合,不再支持 add 等修改集合的方法。如果使用遍历方法去修改集合里面对象,并不会产生效果。原因在于转化之后的 List 只是原 List 的视图而已,所以获取转化后集合里的对象,比如调用 get 时,每次调用会是会使用 function 转化方法。
使用例子:
Function<String, Integer> strlen = new Function<String, Integer>() {
public Integer apply(String from) {
Preconditions.checkNotNull(from);
return from.length();
}
};
List<String> from = Lists.newArrayList("abc", "defg", "hijkl");
List<Integer> to = Lists.transform(from, strlen);
for (int i = 0; i < from.size(); i++) {
System.out.printf("%s has length %d\n", from.get(i), to.get(i));
}
Function<String, Boolean> isPalindrome = new Function<String, Boolean>() {
public Boolean apply(String from) {
Preconditions.checkNotNull(from);
return new StringBuilder(from).reverse().toString().equals(from);
}
};
from = Lists.newArrayList("rotor", "radar", "hannah", "level", "botox");
List<Boolean> to1 = Lists.transform(from, isPalindrome);
for (int i = 0; i < from.size(); i++) {
System.out.printf("%s is%sa palindrome\n", from.get(i), to1.get(i) ? " " : " NOT ");
}
// changes in the "from" list are reflected in the "to" list
System.out.printf("\nnow replace hannah with megan...\n\n");
from.set(2, "megan");
for (int i = 0; i < from.size(); i++) {
System.out.printf("%s is%sa palindrome\n", from.get(i), to1.get(i) ? " " : " NOT ");
}
Lists还可以将传进来的String或者CharSequence分割为单个的字符,并存入到一个新的List对象中返回,如下:
ImmutableList<Character> wyp = Lists.charactersOf("wyp");
System.out.println(wyp);
将List对象里面的数据顺序反转可以用reverse函数实现,取得List对象里面的子序列可以用subList函数实现。
Maps
HashMap
Map<String, String> aNewMap = Maps.newHashMap();
ImmutableMap
创建不可变Map:
@Test
public void whenCreatingImmutableMap_thenCorrect() {
Map<String, Integer> salary = ImmutableMap.<String, Integer> builder()
.put("John", 1000)
.put("Jane", 1500)
.put("Adam", 2000)
.put("Tom", 2000)
.build();
assertEquals(1000, salary.get("John").intValue());
assertEquals(2000, salary.get("Tom").intValue());
}
salary初始化后,不能在更改,调用put方法会报java.lang.UnsupportedOperationException异常。
SortedMap
本节我们看下创建SortMap,下面示例我们使用Guava相应builder创建一个有序map:
@Test
public void whenUsingSortedMap_thenKeysAreSorted() {
ImmutableSortedMap<String, Integer> salary = new ImmutableSortedMap
.Builder<String, Integer>(Ordering.natural())
.put("John", 1000)
.put("Jane", 1500)
.put("Adam", 2000)
.put("Tom", 2000)
.build();
assertEquals("Adam", salary.firstKey());
assertEquals(2000, salary.lastEntry().getValue().intValue());
}
我们看到salary中记录按照字母进行排序。
BiMap
本节我们讨论如何使用BiMap,BiMap也可以反向把值映射到键,只要确保值唯一。
下面示例中,我们创建BiMap,并使用其inverse()方法:
@Test
public void whenCreateBiMap_thenCreated() {
BiMap<String, Integer> words = HashBiMap.create();
words.put("First", 1);
words.put("Second", 2);
words.put("Third", 3);
assertEquals(2, words.get("Second").intValue());
assertEquals("Third", words.inverse().get(3));
}
Multimap
本节我们使用Multimap ,对每个键关联多个值:
@Test
public void whenCreateMultimap_thenCreated() {
Multimap<String, String> multimap = ArrayListMultimap.create();
multimap.put("fruit", "apple");
multimap.put("fruit", "banana");
multimap.put("pet", "cat");
multimap.put("pet", "dog");
assertThat(multimap.get("fruit"), containsInAnyOrder("apple", "banana"));
assertThat(multimap.get("pet"), containsInAnyOrder("cat", "dog"));
}
Multimap的get方法返回 java.util.Collection,上述测试代码除了junit,还需要增加:
testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
Table
当需要多余一个键索引值时,需要Table。下面示例中,我们使用Table存储城市之间距离:
@Test
public void whenCreatingTable_thenCorrect() {
Table<String,String,Integer> distance = HashBasedTable.create();
distance.put("London", "Paris", 340);
distance.put("New York", "Los Angeles", 3940);
distance.put("London", "New York", 5576);
assertEquals(3940, distance.get("New York", "Los Angeles").intValue());
assertThat(distance.columnKeySet(),
containsInAnyOrder("Paris", "New York", "Los Angeles"));
assertThat(distance.rowKeySet(), containsInAnyOrder("London", "New York"));
}
ClassToInstanceMap
把类作为键映射至对象:
@Test
public void whenCreatingClassToInstanceMap_thenCorrect() {
ClassToInstanceMap<Number> numbers = MutableClassToInstanceMap.create();
numbers.putInstance(Integer.class, 1);
numbers.putInstance(Double.class, 1.5);
assertEquals(1, numbers.get(Integer.class));
assertEquals(1.5, numbers.get(Double.class));
}
Integer,Double都继承至Number,ClassToInstanceMap让不同的子类作为key。
Multimap分组
通过Multimap对List进行分组,下面示例中是使用Multimaps.index方法依据list元素的长度进行分组。
@Test
public void whenGroupingListsUsingMultimap_thenGrouped() {
List<String> names = Lists.newArrayList("John", "Adam", "Tom");
Function<String,Integer> func = new Function<String,Integer>(){
public Integer apply(String input) {
return input.length();
}
};
Multimap<Integer, String> groups = Multimaps.index(names, func);
assertThat(groups.get(3), containsInAnyOrder("Tom"));
assertThat(groups.get(4), containsInAnyOrder("John", "Adam"));
}