Fluxos simples não simples

A cada nova versão do Java ele fica cada vez mais rico. Embora grande parte da riqueza resida em versões anteriores, a linguagem continuou a melhorar tanto na metodologia como na implementação. Coleções em Java não são exceção. A estrutura básica de coleções apareceu no J2SE 1.2 e continuou a evoluir, passando por mudanças que foram mais agradáveis ​​do que decepcionantes. Com o lançamento do JDK 5, as coleções tornaram-se mais convenientes, rápidas e fáceis de trabalhar. Isso levou ao fato de que os programadores começaram a explorá-los de forma mais intensa. Certos padrões foram desenvolvidos para trabalhar com eles, que são sem dúvida eficazes. Mas com o JDK 8, as coleções melhoraram novamente e melhoraram graças aos threads. Obviamente, pelo fato do acervo poder ser representado na forma de streams, a metodologia de trabalho com eles também mudará. Por isso, quero mostrar como soluções familiares e compreensíveis com coleções se tornam ainda mais simples.

• Exemplo 1. Não poderia ser mais simples
• Exemplo 2. Encontre valores pares na lista e exiba-os no console
• Exemplo 3. Vamos contar quantas palavras na lista têm 5 caracteres
• Exemplo 4. Imprima palavras exclusivas
• Exemplo 5. Palavras longas
• Exemplo 6. Palavras com números
• Exemplo 7. Seleção de números

Exemplo 1. Não poderia ser mais simples

Claro, vamos começar com o mais simples, vamos percorrer todos os elementos da coleção e exibir todos os elementos.

// создадим и заполним список
   List<Integer> list = new ArrayList<>();
   Collections.addAll(list, 1, 5, 6, 11, 3, 15, 7, 8);
   // а теперь
   // быстрый for по всем elementм, только для коллекций
   for (Integer i:list){
       System.out.println(i);
   }
   //но мы уже живем в JDK 8
   //а значит нужно так
   list.stream().forEach(System.out::println);

Como você percebeu, existe uma nova sintaxe que, na minha opinião como novato em Java, é muito mais simples. Então, o que fica visível na nova sintaxe:

берем_список(list).превращаем_в_поток(stream).перебираем_все_элементы(forEach)(тут_интуитивно_понятно)

System.out::println— um link para um método estático que gera uma string para o console. Em vez de um link para um método estático, você pode usar uma entrada um pouco diferente e menos clara:

list.stream().forEach(i -> System.out.println(i));

Esta entrada usa expressões lambda. E sim, para aprender a trabalhar com streams, você precisará aprender expressões lambda – elas são maravilhosas. Além disso, não mostrarei como trabalhar com coleções utilizando apenas streams, contando com o fato de que você se familiarizou com os métodos tradicionais durante o curso.

Exemplo 2. Encontre valores pares na lista e exiba-os no console

list.stream().filter(i -> i%2==0).forEach(System.out::println);

Todo o problema foi resolvido em uma linha. Espero que você goste de trabalhar em uma linha. Usando o método, filterfiltramos o stream e enviamos o que sobrou para o console. O filtro é algo muito poderoso que pode ajudar nos casos mais inesperados. Vamos ser criativos e mudar as condições do problema. Por exemplo, precisamos contar quantos números pares existem na lista:

long count = list.stream().filter(i -> i%2==0).count();

E novamente em uma linha. De alguma forma, tudo parece simples. No filtro, usamos uma expressão lambda, colocando assim apenas números pares no novo fluxo, e depois aplicamos ao novo fluxo count, que contou quantos elementos estão no novo fluxo.

Exemplo 3. Vamos contar quantas palavras na lista têm 5 caracteres

Já brincamos com números inteiros, agora vamos brincar com palavras.

List<String> list = new ArrayList<>();
Collections.addAll(list, "разые", "слова", "интересные", "And", "Not", "Very");

System.out.println(list.stream().filter(w -> w.length() == 5).count());

Usamos o filtro novamente. No filtro, usando uma expressão lambda, um novo fluxo foi exibido e então, compreensivelmente, countcalculei quantos elementos estavam no novo fluxo.

Exemplo 4. Imprima palavras exclusivas

Uma tarefa familiar quando lemos muitas palavras diferentes em uma coleção de um arquivo e agora precisamos apenas de palavras exclusivas.

List<String> list = new ArrayList<>();
Collections.addAll(list, "Vasya", "Таня", "Olya", "Vasya", "Olya", "Сергей");

list.stream().distinct().forEach(System.out::println);

A ação principal foi realizada no stream usando distinct. A seguir, sugiro dar uma olhada em algumas de nossas tarefas do curso usando threads

Exemplo 5. Palavras longas

No 9º nível do Java Core, na aula 11 há um problema interessante, nele você precisa escrever palavras separadas por vírgulas no Arquivo2, cujo comprimento é estritamente maior que 6. Não importa que tipo de jardim você esteja cercando, Proponho a seguinte solução:

1. No arquivo de origem, lemos todas as palavras da lista.

2. Então executamos a seguinte linha

   Optional<String> rezult = list.stream()
   				.filter(w->w.length()>6)
   				.reduce((w1,w2)->w1+", "+w2);

3. result.get()escrever em um arquivo.

Aqui está uma solução interessante usando threads. O filtro foi filtrado e, usando redução e uma expressão regular, a string necessária foi gerada.

Exemplo 6. Palavras com números

Escreva todas as palavras que contenham números, por exemplo, a1 ou abc3d, separadas por um espaço no Arquivo2. Esta também é uma condição do nosso livro de problemas, como você adivinhou, a solução é simples.

Optional<String> rezult = list.stream()
				.filter(w->w.matches(".*?\\d+.*?"))
				.reduce((w1,w2)->w1+" "+w2);

Filtramos o fluxo usando uma expressão regular e, em seguida, reduzimos e uma expressão lambda. Muito em comum com a tarefa anterior.

Exemplo 7. Seleção de números

Toda a tarefa é assim:

• Leia 2 nomes de arquivos do console.
• Envie para o segundo arquivo todos os números que estão no primeiro arquivo.
• Os números são separados por espaços.
• Fechar fluxos.

Para a tarefa principal, que é escrever números em uma string separada por espaços, para posterior gravação em um arquivo, sugiro usar um stream, ficará assim:

Optional<String> rezult = list.stream().filter(w->w.matches("\\d+"))
				.reduce((w1,w2)->w1+" "+w2);
System.out.println(rezult.get());

Usando threads, o problema é resolvido de uma forma muito simples. Mas, vejam só, compare você mesmo esta solução com as duas anteriores. Concluindo o artigo, quero confessar para vocês: gente, trapaceei na hora de selecionar exemplos. O fato é que escolhi os exemplos mais simples para mostrar um tema desconhecido usando problemas familiares. É claro que os threads são usados ​​tanto para tarefas simples quanto para tarefas mais complexas. Mas, como Horstman enfatizou no seu livro, “os fluxos de dados operam com base no princípio de “o que, não como fazer.””, o que significa que muitas tarefas anteriormente complexas podem tornar-se mais simples. Não sei você, mas gostei dos fluxos, espero não ter desencorajado você de aprendê-los. E deixe-me explicar mais uma coisa:

1. Não pretendi ensinar ao leitor como usar streams em coleções; não sou um professor tão experiente. Queria mostrar para vocês que os tópicos são simples e muito interessantes! Em geral, isso é uma necessidade.
2. Quanto mais entendo os fluxos, mais vejo problemas onde eles resolvem todos os problemas do livro didático, o que significa que os fluxos não foram inventados em vão.
3. Os fluxos não são apenas fáceis de trabalhar, mas também têm uma vantagem importante: ao trabalhar com grandes quantidades de dados, os fluxos costumam ser mais produtivos.

PS . Eu estava brincando sobre TODOS OS PROBLEMAS. Recomendar: Biblioteca Java profissional. Volume 2 Ferramentas avançadas de programação. Kay Horstmann. Tenho a décima edição.