Guava Functional Cookbook – 番石榴功能食谱

最后修改: 2013年 10月 30日

中文/混合/英文(键盘快捷键:t)

1. Overview

1.概述

This cookbook is organized into small and focused recipes and code snippets for using the Guava functional-style elements – Predicates and Functions.

这本食谱被组织成小而集中的食谱和代码片段,用于使用Guava功能式元素–谓词和函数。

The cookbook format is focused and practical – no extraneous details and explanations necessary.

食谱的形式是重点和实用的 – 没有多余的细节和解释的必要。

2. The Cookbook

2.食谱

filter a collection by a condition (custom Predicate)

通过一个条件(自定义谓词)过滤一个集合

List<Integer> numbers = Lists.newArrayList(1, 2, 3, 6, 10, 34, 57, 89);
Predicate<Integer> acceptEven = new Predicate<Integer>() {
    @Override
    public boolean apply(Integer number) {
        return (number % 2) == 0;
    }
};
List<Integer> evenNumbers = Lists.newArrayList(Collections2.filter(numbers, acceptEven));
Integer found = Collections.binarySearch(evenNumbers, 57);
assertThat(found, lessThan(0));

filter out nulls from a collection

过滤掉一个集合中的空值

List<String> withNulls = Lists.newArrayList("a", "bc", null, "def");
Iterable<String> withoutNuls = Iterables.filter(withNulls, Predicates.notNull());
assertTrue(Iterables.all(withoutNuls, Predicates.notNull()));

check condition for all elements of a collection

检查一个集合的所有元素的条件

List<Integer> evenNumbers = Lists.newArrayList(2, 6, 8, 10, 34, 90);
Predicate<Integer> acceptEven = new Predicate<Integer>() {
    @Override
    public boolean apply(Integer number) {
        return (number % 2) == 0;
    }
};
assertTrue(Iterables.all(evenNumbers, acceptEven));

negate a predicate

否定一个谓词

List<Integer> evenNumbers = Lists.newArrayList(2, 6, 8, 10, 34, 90);
Predicate<Integer> acceptOdd = new Predicate<Integer>() {
    @Override
    public boolean apply(Integer number) {
        return (number % 2) != 0;
    }
};
assertTrue(Iterables.all(evenNumbers, Predicates.not(acceptOdd)));

apply a simple function

应用一个简单的函数

List<Integer> numbers = Lists.newArrayList(1, 2, 3);
List<String> asStrings = Lists.transform(numbers, Functions.toStringFunction());
assertThat(asStrings, contains("1", "2", "3"));

sort collection by first applying an intermediary function

首先应用一个中间函数对集合进行排序

List<Integer> numbers = Arrays.asList(2, 1, 11, 100, 8, 14);
Ordering<Object> ordering = Ordering.natural().onResultOf(Functions.toStringFunction());
List<Integer> inAlphabeticalOrder = ordering.sortedCopy(numbers);
List<Integer> correctAlphabeticalOrder = Lists.newArrayList(1, 100, 11, 14, 2, 8);
assertThat(correctAlphabeticalOrder, equalTo(inAlphabeticalOrder));

complex example – chaining predicates and functions

复杂的例子–链式谓词和函数

List<Integer> numbers = Arrays.asList(2, 1, 11, 100, 8, 14);
Predicate<Integer> acceptEvenNumber = new Predicate<Integer>() {
    @Override
    public boolean apply(Integer number) {
        return (number % 2) == 0;
    }
};
Function<Integer, Integer> powerOfTwo = new Function<Integer, Integer>() {
    @Override
    public Integer apply(Integer input) {
        return (int) Math.pow(input, 2);
    }
};

FluentIterable<Integer> powerOfTwoOnlyForEvenNumbers = 
FluentIterable.from(numbers).filter(acceptEvenNumber).transform(powerOfTwo);
assertThat(powerOfTwoOnlyForEvenNumbers, contains(4, 10000, 64, 196));

compose two functions

组成两个函数

List<Integer> numbers = Arrays.asList(2, 3);
Function<Integer, Integer> powerOfTwo = new Function<Integer, Integer>() {
    @Override
    public Integer apply(Integer input) {
        return (int) Math.pow(input, 2);
    }
};
List<Integer> result = Lists.transform(numbers, 
    Functions.compose(powerOfTwo, powerOfTwo));
assertThat(result, contains(16, 81));

create a Map backed by a Set and a Function

创建一个由一个集合和一个函数支持的地图

Function<Integer, Integer> powerOfTwo = new Function<Integer, Integer>() {
    @Override
    public Integer apply(Integer input) {
        return (int) Math.pow(input, 2);
    }
};
Set<Integer> lowNumbers = Sets.newHashSet(2, 3, 4);

Map<Integer, Integer> numberToPowerOfTwoMuttable = Maps.asMap(lowNumbers, powerOfTwo);
Map<Integer, Integer> numberToPowerOfTwoImuttable = Maps.toMap(lowNumbers, powerOfTwo);
assertThat(numberToPowerOfTwoMuttable.get(2), equalTo(4));
assertThat(numberToPowerOfTwoImuttable.get(2), equalTo(4));

create a Function out of a Predicate

从一个谓词中创建一个函数

List<Integer> numbers = Lists.newArrayList(1, 2, 3, 6);
Predicate<Integer> acceptEvenNumber = new Predicate<Integer>() {
    @Override
    public boolean apply(Integer number) {
        return (number % 2) == 0;
    }
};
Function<Integer, Boolean> isEventNumberFunction = Functions.forPredicate(acceptEvenNumber);
List<Boolean> areNumbersEven = Lists.transform(numbers, isEventNumberFunction);

assertThat(areNumbersEven, contains(false, true, false, true));

3. More Guava Cookbooks

3.更多的番石榴烹饪书

Guava is a comprehensive and fantastically useful library – here’s a few more APIs covered in cookbook form:

Guava是一个全面的、非常有用的库–这里还有一些以菜谱形式介绍的API。

Enjoy.

请享受。

4. Conclusion

4.结论

This format is a little different than my usual tutorials – mainly because this is an internal development cookbook that I have been keeping and using for quite some time. The goal is to have this information readily available online – and to add to it whenever I run into a new useful example.

这个格式与我通常的教程有些不同–主要是因为这是一本内部开发手册,我已经保留并使用了相当长的一段时间。我们的目标是让这些信息在网上随时可用,并在我遇到新的有用的例子时加以补充。

The implementation of all these examples and code snippets can be found over on GitHub – this is a Maven-based project, so it should be easy to import and run as it is.

所有这些例子和代码片段的实现都可以在GitHub上找到–这是一个基于Maven的项目,所以应该很容易导入并按原样运行。