Java 8 – Caractéristiques

aujourd’hui, je vous apporte ce blog une entrée sur une entrée de Java Améliorations 8. Je dois avouer que, bien que, au début, il ressemblait à des galimaties authentiques, au cours des heures et surtout, avec la pratique des nouvelles structures, je suis convaincu que vraiment le code est beaucoup plus lisible. , confortable à mettre en œuvre et surtout: efficace.

Eh bien, il est vrai que j’ai un bon moment pour essayer, apprendre et renforcer, mais il y a des structures et des modes de travail qui ont fait ma vie.

Alors, peut-être la même chose, vous pouvez également vous servir.

Stream, avec vous tous ont commencé à Java 8!

Contrairement à votre prédécesseur, Java 7, sa version la plus récente (Java 8) a ajouté à l’interface de collecte (à partir du paquet Java.util) la méthode du flux.

/** * 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); }

Qu’est-ce que le flux? Eh bien, pas plus ou moins qu’une séquence d’éléments. Avec cette méthode, nous pouvons transformer une collection d’objets (matrices, listes, …) en une succession d’objets.

Nous allons enregistrer comment cette méthode a été utilisée pour les classes ArrayList ou pour les tableaux:

L’interface de liste hérite de la collection de sorte que vous puissiez également utiliser votre méthode de flux afin qu’il soit facile de déduire les éléments suivants:

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--

parfait, mais et avec ce que faisons-nous? Shhh, tranquillité … dormir une étape, doux doux … ahem 😉 Nous continuons.

Carte, Votre allié

Bien que l’interface de flux fournisse plusieurs méthodes, nous allons commencer par ceci: Carte.
Dans les entrées suivantes, nous ne partirons pas dans l’oubli: filtre, plat et réduisez.

Combien de fois? Nous avons parcouru une structure où vérifiez une condition que nous avons fait une action ou une autre?
Combien de lignes de code? Combien de personnes pour / si / sinon nichées à partir de quel sonar s’est plaint (et nous avons passé quelques semaines lorsque nous avons oublié ce que ce fragment de code a fait)?

Bien en Java 8, nous sommes autorisés à faire cela même dans une ligne.

Comme avant la première chose à faire, vous devez vous présenter la méthode:

/** * 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);

la carte appliquera une fonction que nous appelons f enveloppez chacun des éléments de la succession et retournera une autre succession d’éléments déjà modifiés.

et cette fonction est …?

Quiconque a besoin de postuler, que oui remplissant certains Restrictions.

Par exemple, nous pouvons dire que nous voulons faire une garniture () à chaque élément de la succession de la succession du premier élément. Pour cela, nous pouvons l’écrire comme ceci en Java 8:

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

C’est comme ça que j’ai commencé à l’utiliser et que je ne fais toujours pas le seul.
Dans cette option, nous utilisons une variable S, dont la portée est celle de la méthode (à l’extérieur de cette carte n’existera pas et il ne sera pas nécessaire de le déclarer précédemment).
Nous indiquons que chaque élément de cette succession, Nous allons l’enregistrer dans une variable S, du même type de l’élément, et nous allons appliquer la fonction de garniture ().

Pourquoi n’avons-nous pas mis de chaîne S- > s .trim ()? Parce que Java reconnaît parfaitement le type de variable S en connaissant le type d’éléments de succession (flux). Si nous avions utilisé le flux Enterarosstream S serait le type d’entier et il ne serait pas nécessaire de le déclarer.

Une autre façon de faire de même serait ce qui suit:

streamCadenas.map(String :: trim).

La différence avec la précédente est que nous avons enregistré la variable, cette nomenclature n’est pas toujours valide. Nous devons nous assurer que la méthode n’a pas de paramètres, si vous les avez eues, il ne pouvait pas être utilisé de cette manière, bien que cela puisse dans votre première version

filtre, ou comment enregistrer quelques boucles

/** * 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);

Comme dans l’API elle-même est indiquée, le filtre reçoit une succession d’éléments et renvoie ceux qui sont conformes au modèle recherché (prédicat).

Nous avons commencé à montrer un exemple de base.
Nous avons une liste de chaînes dans lesquelles nous gardons des types de véhicules et nous obtiendrons ceux qui ne sont pas « moto »

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); } }

avec Java 8 serait telle que:

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

Dans notre cas, déjà pour un projet, nous avions une liste de type de profil appelé Profils où Nous avons eu des cas de différents types: individuel, corporatif, … Nous voulions que cette liste obtient trois. Un pour chaque type de profil de ceux qui consistait en l’application.

Au début, nous avons eu recours à la tâche / si nous avons itéralisé la liste des profils et dans le si nous avons spécifié la condition à remplir. Comme il y avait plusieurs listes que nous voulions comme une sortie était nécessaire pour utiliser si / sinon imbriqué. Enfin, nous avons eu beaucoup de nettoyant avec cette méthode Java 8. Sous l’exemple de l’une des listes obtenues.

Dans ce cas, l’important est de voir un autre type de structure où le prédicat du filtre est une autre méthode: istype, une méthode à part entière.

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);

Dans l’exemple que nous voyons ci-dessous, nous avons eu le problème suivant. Chaque élément de profil avait un champ de chaîne de type jeton contenant des valeurs séparées par virgule.
Nous voulions obtenir chacun de ces éléments et les ajouter à une liste mais sans éléments répétés.

pour cela Avec la carte TranformAMMO Liste des objets de profil dans une succession d’éléments auxquels il a été appliqué pour son jeton variable la méthode fractionnée.

imagine que nous avons quelque chose comme ça

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

Le champ de jeton a une valeur comme celle-ci = > jeton = « navigateur, pkcs12, jks »; maintenant j’imagine que nous avons deux objets de profil que nous aurions deux objets de profil que nous aurions Quelque chose comme ceci:

Lista de Profile Profile = > token = "BROWSER,PKCS12,JKS,USER_GENERATED,JKS,SOFT" ...

Ce que nous avons l’intention d’obtenir est-ce:

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

Et encore plus, nous ne voulions pas en réalité la liste, nous voulions retourner faux ou vrai en fonction de la question de savoir si le profil contenait l’un des jetons de sorte qu’il devrait être affiché à l’écran.

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

pour terminer le système d’exploitation Nous quittons le chapitre 1, téléchargement gratuit, de DOC Java 8: (Cliquez ici)