java 8 – recursos

hoje eu trago este blog uma entrada sobre o Java Melhorias 8. Eu tenho que confessar, que, embora a princípio parecesse uma galimaties autêntica, com o curso das horas e acima de tudo, com a prática das novas estruturas, tenho sido convincente de que realmente o código é muito mais legível , confortável para implementar e mais importante: eficiente.

Bem, é verdade que eu tenho um ótimo momento para tentar, aprender e fortalecer, mas há estruturas e modos de trabalho que fizeram da minha vida.

Então, talvez o mesmo, você também pode servi-lo.

fluxo, com todos vocês começaram em Java 8!

Ao contrário do seu predecessor, o Java 7, sua versão mais recente (Java 8) adicionou à interface de coleta (do pacote java.util) o método de fluxo.

/** * Returns a sequential {@code Stream} with this collection as its source. * *This method should be overridden when the {@link #spliterator()} * method cannot return a spliterator that is {@code IMMUTABLE}, * {@code CONCURRENT}, or late-binding. (See {@link #spliterator()} * for details.) * * @implSpec * The default implementation creates a sequential {@code Stream} from the * collection's {@code Spliterator}. * * @return a sequential {@code Stream} over the elements in this collection * @since 1.8 */ default Stream stream() { return StreamSupport.stream(spliterator(), false); }

O que é fluxo? Bem, não mais ou menos do que uma seqüência de elementos. Com este método, podemos transformar uma coleção de objetos (matrizes, listas, …) em uma sucessão de objetos.

Vamos gravar como esse método foi usado para classes de arraylist ou para matrizes:

A interface de lista herda a partir da coleção para qualquer tipo que você também poderá usar seu método de fluxo para que seja fácil deduzir o seguinte:

List listaCadenas = new ArrayList(); //Notación diamanteList listaCadenas = new ArrayList(); listaCadenas.add("Juan"); listaCadenas.add("Antonio"); listaCadenas.add("Maria"); Stream streamCadenas = listaCadenas.stream();En el caso de Arrays también podemos usar el método: public static Stream stream(T array) { return stream(array, 0, array.length); }Integer enteros = {1,2,3,4,5,6}; Stream enterosStream = Arrays.stream(enteros);Además del método stream Java 8 incluye otro método muy en la línea: parallelStream. Para más información: https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html#stream--

Perfeito, mas e com isso, o que fazemos? Shhh, tranquilidade … dormir um passo, macio macio … ahem 😉 Continuamos.

mapa, Seu aliado

Embora a interface do fluxo fornece vários métodos, vamos começar por este: mapa.
enquanto nas seguintes entradas não vamos sair no esquecimento: filtro, flatmap e reduzir.

Quantas vezes? Nós viajamos uma estrutura onde verificando uma condição que fizemos uma ação ou outra? Quantas linhas de código? Quantos para / if / senle aninhado do qual sonar reclamou (e passamos algumas semanas quando esquecemos o que esse fragmento do código)?

Bem em Java 8, estamos autorizados a fazer isso mesmo em uma linha.

Como antes que a primeira coisa seja apresentar o método:

/** * Returns a stream consisting of the results of applying the given * function to the elements of this stream. * *This is an intermediate * operation. * * @param The element type of the new stream * @param mapper a non-interfering, * stateless * function to apply to each element * @return the new stream */ Stream map(Function mapper);

Mapa aplicará uma função que chamamos de f envelope cada um dos elementos da sucessão e retornará outra sucessão de elementos já modificados.

e essa função é …?

Qualquer pessoa que precise se inscrever, que sim cumprindo alguns Restrições.

Por exemplo, podemos dizer que queremos fazer um acabamento () a cada elemento da sucessão do tipo de string da sucessão do primeiro elemento. Para isso, podemos escrevê-lo assim em java 8:

streamCadenas.map(s->s.trim());

É a maneira que eu comecei a usá-lo e com isso eu ainda não faço o único. BR> Nesta opção, usamos uma variável s, cujo escopo é o do método (fora desse mapa não será necessário e não será necessário declará-lo anteriormente).
estamos indicando que cada elemento dessa sucessão, Vamos salvá-lo em uma variável s, do mesmo tipo de elemento, e vamos aplicar a função Trim ().

Por que não colocamos a string s- > s .trim ()? Porque Java reconhece perfeitamente o tipo de variável s conhecendo o tipo de elementos de sucessão (fluxo). Se tivéssemos usado o fluxo enterarossstream S seria o tipo inteiro e não seria necessário declará-lo.

Outra maneira de fazer o mesmo seria o seguinte:

streamCadenas.map(String :: trim).

A diferença com o anterior é que salvamos a variável, esta nomenclatura nem sempre é válida. Devemos ter certeza de que o método não tem parâmetros, se você os tivesse, não poderia ser usado dessa maneira, embora ele faça em sua primeira versão

filtro ou como salvar alguns loops

/** * Returns a stream consisting of the elements of this stream that match * the given predicate. * *This is an intermediate * operation. * * @param predicate a non-interfering, * stateless * predicate to apply to each element to determine if it * should be included * @return the new stream */ Stream filter(Predicate predicate);

Como na própria API é indicado, o filtro recebe uma sucessão de elementos e retorna aqueles que cumprem o padrão pesquisado (predicado).

Começamos a mostrar um exemplo básico.
Temos uma lista de correntes na qual mantemos tipos de veículos e vamos obter aqueles que não são “motos”

List vehicles = Arrays.asList("car", "motorbike", "bus");Antes haríamos algo de este tipo:List filteredVehicles = new ArrayList(); for(String vehicle: vehicles){ if(!"motorbike".equals(vehicle)){ filteredVehicles.add(vehicle); } }

com o Java 8 seria tal como:

List filteredVehicles = vehicles.stream() .filter(v -> !"motorbike".equals(v)) .collect(Collectors.toList());

No nosso caso, já para um projeto, tivemos uma lista de tipo de perfil chamado perfis onde Tivemos instâncias de vários tipos: individual, corporativo, … Queríamos essa lista para obter três. Um para cada tipo de perfil daqueles que consistiam no aplicativo.

No começo, recorremos ao para / se, no qual iteramos a lista de perfis e, se especificamos a condição de ser cumprida. Como havia várias listas que queríamos como uma saída era necessária para usar se / mais aninhado. Finalmente, ficamos muito mais limpos com este método Java 8. Abaixo do exemplo de uma das listas obtidas.

Neste caso, o importante é ver outro tipo de estrutura onde o predicado do filtro é outro método: ISTYPE, um método próprio.

List individuales = profiles.stream().filter(s -> isType(s, EnumTypeCertificate.INDIVIDUAL.name())).collect(Collectors.toList());private boolean isType(Profile profile,String typeProfile) { return profile.getType().equals(typeProfile); }flatMap, magia!/** * Returns a stream consisting of the results of replacing each element of * this stream with the contents of a mapped stream produced by applying * the provided mapping function to each element. Each mapped stream is * {@link java.util.stream.BaseStream#close() closed} after its contents * have been placed into this stream. (If a mapped stream is {@code null} * an empty stream is used, instead.) * *This is an intermediate * operation. * * @apiNote * The {@code flatMap()} operation has the effect of applying a one-to-many * transformation to the elements of the stream, and then flattening the * resulting elements into a new stream. * *Examples. * *If {@code orders} is a stream of purchase orders, and each purchase * order contains a collection of line items, then the following produces a * stream containing all the line items in all the orders: *{@code * orders.flatMap(order -> order.getLineItems().stream())... * }* *If {@code path} is the path to a file, then the following produces a * stream of the {@code words} contained in that file: *{@code * Stream lines = Files.lines(path, StandardCharsets.UTF_8); * Stream words = lines.flatMap(line -> Stream.of(line.split(" +"))); * }* The {@code mapper} function passed to {@code flatMap} splits a line, * using a simple regular expression, into an array of words, and then * creates a stream of words from that array. * * @param The element type of the new stream * @param mapper a non-interfering, * stateless * function to apply to each element which produces a stream * of new values * @return the new stream */ Stream flatMap(Function<? super T, ? extends Stream> mapper);

No exemplo, vemos abaixo que tivemos o seguinte problema. Cada elemento de perfil tinha um campo de corrente de tipo de token que continha valores separados por vírgula.
Nós queríamos obter cada um desses elementos e adicioná-los a uma lista, mas sem itens repetidos.

para este Com o mapa Tranformammo Lista de objetos de perfil em uma sucessão de elementos à qual foi aplicado para sua variável token o método dividido.

Imagine que temos algo como este

public class Profile { String token; ... //Getters and Setters ... }

o campo de token tem um valor como este = > token = “navegador, pkcs12, jks”; agora eu imagino que temos dois objetos de perfil que teríamos Algo como este:

O que pretendemos obter é esta:

Lista de String "BROWSER" "PKCS12" "JKS" "USER_GENERATED" "SOFT"

e ainda mais, não queríamos na realidade a lista, queríamos retornar falso ou verdade, dependendo se o perfil continha qualquer um dos tokens, por isso deve ser exibido na tela.

profiles.stream() .map(s->StringUtils.split(s.getToken(), ",")) .flatMap(Arrays::stream) .distinct() .map(StringUtils::trim) .collect(Collectors.toList()) .stream() .anyMatch(EnumToken::isShowInMenu);

para terminar OS, deixamos o capítulo 1, download gratuito, do doc Java 8: (Clique aqui)