1. 这样，让我们​​过滤年龄，以使他是20多年的一天。这是一个过滤器。过滤器实际上过滤了数据，而不是转换数据（与地图不同），而是决定是否维护数据。 2.1。代码中的过滤器接收谓词作为parano，它代表接收参数并返回布尔值的函数。

1. 最后，让我们计算出已经从人转换并拍摄的数据的一天，以使年龄> 20岁。在这种情况下，这种操作的AVG将减少，让我们将开始作为聚合（最小，最大，计数等）。
。

为什么使用流？

List<Person> people = ...;

int sum = 0;
int count = 0;
for (Person person: people) {
    if (person.getAge() > 20) {
        count++;
        sum += person.getAge();
    }
}
double average = 0d;

if(count > 0) {
    average = sum / count;
}

在上面的示例中，我们有一种详细描述应采取的措施以达到结果（呈现示例的结果），如果我们更改算法，我们需要更改代码，即使算法相同。例如，在SQL中，不一定有必要写：

Select AVG(age) from People
Where People.age>20

请注意，在上面的示例中，我们描述了我们想完成的工作，前提，我们描述结果，而不是应计算结果。

Collection x流

好吧，如果方式是列表或任何集合的一部分，我们可以尝试实现以下操作：

List<Person> people = ...;
double average = 
people.map(person -> person.getAge())
    .filter(age — > age > 20)
    .average();

错误！

但是，为什么收藏和溪流的API分开？

List<Pessoa> pessoas = new ArrayList<>();

    pessoas.stream()
                 .map(...)
                 .filter(...)
                 .average();

Stream personNames = personStream.map(Person::getName);
Stream emptyNames = personNames.filter( name -> name.isEmpty())
Stream notEmptyNames = personNames.filter( name -> !name.isEmpty())

Stream personNames = personStream.map(Person::getName);
Stream personAges = personStream.map(Person::getAge);

Stream emptyNames = personStream.map(Person::getName).filter(name -> name.isEmpty());
Stream notEmptyNames = personStream.map(Person::getName).filter(name -> !name.isEmpty());

List<City> cities = ...;

Function<City, Stream<Person>> flatMapper = 
    city -> city.getPeople().stream();

long count = 
    cities.stream()
    .flatMap(flatMapper) /*poderíamos colocar city -> city.getPeople().stream() direto*/
    .count()

List words "Gomu","Gomu", "No", "Mi");

Stream streamStream =
words.stream()
.map(w -> w.split("")) // Stream
.flatMap(Arrays::stream) ; // Stream

flatmap在这种情况下起作用，因为应用 flatMap(Arrays::stream) ，您告诉java Stream 并将其转换为一条字符串（ Stream ）使用整个母亲 Arrays.stream() 。

从正则流

String sentence = "the quick brown fox jumps over the lazy dog";
String[] words = sentence. split(
Stream<String> wordsStream = Arrays.stream(words);
Ion count = wordsStream.count()

当我们这样做时，我们创建了一个中间数组，我们丢失了流的建议。

我们可以做：

Pattern pattern = Pattern.compile(" ");
long count = pattern.sp1itAsStream(sentence) . count();

另一种类型的流

在Java中，有一些流界面来更正确地操纵某些原始词，一个例子是IntStream

intstream

IntStream 当您使用原始整数值时，在空间和性能方面倾向于更有效，因为它避免了对象的创建 Integer 。

a IntStream 提供专门的操作，以使用 sum() ， average() ， koud15 ， rangeClosed() ，等等。 A Stream<Integer> 提供流操作基因©rich 适用于对象，但是在跟踪原始类型方面的效率较低。

ðâ¡

重构同时完成母亲任务的例子

流同时执行母任务不好，因此，如果我们有一个循环添加值â添加值迷，则我们需要将其分为3（重复）（重复）并将其更改为“流”。当然，这大大降低了性能，但其中很少有要元素的元素，这基本上是无法察觉的。

public String statement() {

    double totalAmount = rentals.stream()
        .mapToDoub1e(this::computeRenta1Amount)
        .sum();
    int frequentRenterPoints = rentals.stream()
    .mapToInt (this::getFrequentRenterPoints)
    .sum();

    String statement = composeHeader();

    statement += rentals.stream()
    .map(this::computeStatementLine)
    .collect(Collectors.joining());

}

reduã§ãµs

之前，我们听说减少与SQL的聚合类似，让我们牢记它，但是它如何工作？

我们将以示例为例，总和是一个BinaryOperator<Integer>实现，该实现需要两个元素和总和（sum = (i1,i2) -> i1+i2;）。一次发生两个元素，将值关联，然后添加到另一个。

空流的减少

但是，空流的减少是什么？>身份元素是一个突出的值，它是减少操作的起点。在功能编程上下文中，当不是在流中组合的元素时，还原操作将返回身份元素，从而确保定义操作并且在空流的情况下不会引起例外。这尤其是在处理特定操作没有数据的情况下处理的情况，使您可以以可预测且安全的方式行事。

例如，总和的身份为0，鉴于0不会影响最终值，最终值。

收集器允许您捕获集合或其他具体数据类型中的减少操作结果。 换句话说，它们将处理的元素变成了一个可以使用和操纵的真实集合。

List<Person> pessoasDaBaixada = new ArrayList<>();

// Supondo que o número de DDD seja uma String
List<Person> pessoasComDDD13 = pessoasDaBaixada.stream()
    .filter(p -> "13".equals(p.getDDD()))
    .collect(Collectors.toList());
    //.toList() retornará uma lista imutável!

新母亲©All stream.tolist（）不会产生可修改的列表，也不是collect(toUnmodifiableList())的快捷方式，因为toUnmodifiableList() **不接受null value 。 stream.tolist（）的实现不受Koude Interface34的限制；因此，Stream.toList()分配了更少的内存。这使其非常适合在流的大小提前知道时使用。

Map<Integer, List<Person>> pessoasPorIdade = pessoas.stream()
    .collect(Collectors.groupingBy(Person::getIdade));

List<Person> pessoas = Arrays.asList(
    new Person("Jorge", 25),
    new Person("Ben", 30),
    new Person("Jor", 35)
);

Map<String, Integer> mapNomeIdade = pessoas.stream()
    .collect(Collectors.toMap(Person::getNome, Person::getIdade));

// ex1
Map<Integer, List<Person>> pessoasPorIdade = new HashMap<>();
pessoas.forEach(person -> {
    Integer idade = person.getIdade();
    List<Person> pessoasComIdade = pessoasPorIdade.get(idade);
    if (pessoasComIdade == null) {
        pessoasComIdade = new ArrayList<>();
        pessoasPorIdade.put(idade, pessoasComIdade);
    }
    pessoasComIdade.add(person);
});

// ex2
Map<String, Integer> mapNomeIdade = new HashMap<>();
pessoas.stream().forEach(person -> mapNomeIdade.put(person.getNome(), person.getIdade()));

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// Cálculo da soma em uma stream paralela
int sum = numbers.parallelStream().reduce(0, Integer::sum);
Esse parágrafo tem como objetivo apenas introduzir e notificar a existência de streams paralelas, procure saber mais sobre elas!