Maîtrisez comment utiliser Lambda, Stream et LocalDate afin de pouvoir l'utiliser régulièrement!
Lambda
Lambda est une méthode de définition et d'utilisation de méthodes en tant que variables. Lambda vous permet d'écrire moins de lignes de code. Vous pouvez également passer la méthode définie comme argument à une autre méthode. Écrivez des méthodes dans Lambda qui ne sont utilisées que quelques fois et qui ne sont pas référencées par d'autres classes!
Étant donné que Lambda omet tous les noms de fonction à remplacer, il est nécessaire d'hériter de l'interface dans laquelle une seule méthode est définie. Java fournit déjà des interfaces fonctionnelles qui peuvent être utilisées en fonction du nombre d'arguments et de valeurs de retour, nous les utiliserons donc.
** * Attention: lorsque vous utilisez des types primitifs tels que int et double pour les arguments et les valeurs de retour, utilisez les interfaces correspondantes! (Parce qu'il y a une différence de performance) ** Exemple) // Quand vous voulez envoyer int et recevoir int Function → IntUnaryOperator
Les types détaillés d'interfaces sont répertoriés ci-dessous. http://www.ne.jp/asahi/hishidama/home/tech/java/functionalinterface.html#h_Function
Il est défini comme le type d'argument et le type de retour.
L'exécution utilise la méthode ʻapply () . Il existe également une fonction BiFunction qui peut accepter deux arguments. Si vous voulez spécifier le type int pour l'argument et la valeur de retour, utilisez ʻIntUnaryOperator au lieu de Function.
La méthode d'exécution est ʻapplyAsInt () `.
import java.util.function.*;
//En général
Function<String, String> f = (i) -> { return i +"OK"; };
System.out.println(f.apply("test")); // testOK
Spécifie le type d'argument.
L'exécution utilise la méthode ʻaccept () . Si vous voulez spécifier l'argument comme type int, utilisez ʻIntConsumer.
import java.util.function.*;
//En général
Consumer<String> c = i -> { System.out.println(i); };
c.accept("testOK"); // testOK
Spécifie le type de retour.
L'exécution utilise la méthode get ().
Si vous souhaitez spécifier la valeur de retour comme type int, utilisez ʻIntSupplier. La méthode d'exécution est getAsInt ()`.
import java.util.function.*;
//En général
Supplier<String> s = () -> { return "testOK"; };
System.out.println(s.get()); // testOK
L'exécution utilise la méthode test ().
La différence entre la spécification booléenne de Function et Predicate est que Function retourne Boolean, tandis que Predicate renvoie boolean, qui est un type primitif.
Si vous voulez spécifier l'argument comme type int, utilisez ʻIntPredicate`.
import java.util.function.*;
//En général
Predicate<String> p = (i) -> { return i.equals("AAA"); };
System.out.println(p.test("AAA")); // true
Stream
Vous pouvez écrire un type de liste pour une déclaration, etc.
Vous pouvez également utiliser Lambda comme argument de méthode.
Lorsque vous l'utilisez, importez java.util.stream.
Tout d'abord, considérons une instruction for normale.
for(int i; i < 10; i++){
System.out.println(i+"C'est la deuxième fois")；
}
Si vous écrivez ceci dans Stream
IntStream.range(0, 10).forEach(i -> System.out.println(i+"C'est la deuxième fois"));
Ce sera simple.
De plus, si vous souhaitez rechercher les éléments de ArrayList,
//Pour la liste des variables
list.stream().forEach(i -> [En traitement])
Vous pouvez écrire comme ça.
Le flux a une méthode d'opération intermédiaire qui convertit chaque élément et une méthode d'opération de terminal qui renvoie ou stocke finalement la valeur. Veuillez noter que les éléments convertis ne seront pas enregistrés tant que l'opération de terminaison n'est pas effectuée.
Les opérations intermédiaires sont les suivantes.
.skip (n) ... Supprimer les n premiers éléments.
.limit (n) ... Extraire uniquement les n premiers éléments.
.filter (i-> [condition]) ... Extrayez celui qui remplit la condition.
.distinct () ... Supprimer les doublons.
.sorted () ... Trier par ordre naturel. Il est également possible de spécifier une règle de tri entre parenthèses.
.map (i-> [Traitement]) ... Traite tous les éléments.
Les opérations de terminaison sont les suivantes.
.forEach (i-> [Traitement]) ... Sortie.
.findFirst () ... Renvoie le premier élément.
.collect () ... Crée le résultat. (Le traitement change en fonction de l'argument.)
.count () ... Renvoie le nombre d'éléments.
.allMach ([condition]) .anyMach ([condition]) .noneMach ([condition]) ... Détermine s'il y a une correspondance.
LocalDate
Une classe qui traite les dates.
C'est plus facile à gérer que la classe Calendar que j'utilise.
Importez et utilisez java.time.LocalDate.
Nous aborderons ci-dessous les opérations souvent utilisées.
LocalDate date = LocalDate.now();
Jeu 2020-01-01
localDate date = LocalDate.of(2020, 1, 1);
Contrairement à Google Agenda, vous n'avez pas besoin de -1 mois!
Importez java.time.format.DateTimeFormatter.
date = LocalDate.parse("20200101",DateTimeFormater.ofPattern("yyyyMMdd"));
Également possible ci-dessous
date = LocalDate.parse("2020-01-01");
Année
date.getYear();
Mois
date.getMonth();
journée
date.getDayOfMonth();
journée
date.getDayOfWeek();
+10 jours
date.plusDays(10);
-Le 10
date.miusDays(10);
+2 ans
date.plusYears(2);
Importez java.time.temporal.ChronoUnit.
Différence de date
long diff = ChronoUnit.DAYS.between(date1, date2);
Lambda http://www.ne.jp/asahi/hishidama/home/tech/java/functionalinterface.html#h_Function https://qiita.com/sano1202/items/64593e8e981e8d6439d3
Stream http://www.ne.jp/asahi/hishidama/home/tech/java/stream.html https://qiita.com/kumazo/items/0876c5b251ecc131c960 https://qiita.com/kumazo/items/104fa685da8705b8cfd8 https://qiita.com/kumazo/items/284098c530fceb05805c
LocalDate https://blog.y-yuki.net/entry/2016/09/15/003000) https://m-shige1979.hatenablog.com/entry/2017/03/10/080000
Recommended Posts