Résumé des fonctions intégrées couramment utilisées dans Java8 (exemples de code)

Ce que cet article vous apporte est un résumé (exemples de code) des fonctions intégrées couramment utilisées dans Java 8. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Les interfaces de fonctions couramment utilisées sont enregistrées pour une référence facile ultérieurement

接口	参数	返回类型	说明
Predicate	T	boolean	输入某个值，输出boolean 值，用于对某值进行判定
Consumer	T	void	输入某值，无输出。用于消费某值
Function	T	R	输入某类型值，输出另种类型值，用于类型转化等
Supplier	None	T	无输入，输出某值，用于生产某值
UnaryOperator	T	T	输入某类型值，输出同类型值，用于值的同类型转化，如对值进行四则运算等
BinaryOperator	(T,T)	T	输入两个某类型值，输出一个同类型值，用于两值合并等

Prédicats

Les prédicats sont une interface booléenne contenant un paramètre. Il comprend certaines méthodes par défaut, qui peuvent être combinées pour implémenter une logique métier complexe (telle que : et, ou, négation). L'exemple de code est le suivant :

Predicate<String> predicate = (s) -> s.length() > 0;
 
predicate.test("foo");              // true
predicate.negate().test("foo");     // false
 
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
 
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();

Fonctions

L'interface Functions reçoit un paramètre et produit un résultat. Sa méthode par défaut est généralement utilisée pour enchaîner plusieurs fonctions (compose, andThen). L'interface

Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
 
backToString.apply("123");     // "123"

Fournisseurs

Fournisseurs génère un résultat d'un type donné. Contrairement aux fonctions, il ne reçoit pas de paramètres.

Supplier<Person> personSupplier = Person::new;
personSupplier.get();   // new Person

Consommateurs

Les consommateurs représentent des opérations qui prennent un seul paramètre d'entrée.

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));

Comparateurs

Les comparateurs sont mis à niveau à partir des anciennes versions de Java et ajoutent quelques méthodes par défaut.

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
 
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
 
comparator.compare(p1, p2);             // > 0
comparator.reversed().compare(p1, p2);  // < 0

Méthodes courantes de Stream

Créer un Stream

1. Convertir la structure de données existante en Stream

Stream<Integer> s = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> s = Arrays.stream(arr);
Stream<Integer> s = aList.stream();

1. Par méthode Stream.generate() :

// 这种方法通常表示无限序列
Stream<T> s = Stream.generate(SuppLier<T> s);
// 创建全体自然数的Stream
class NatualSupplier implements Supplier<BigInteger> {
    BigInteger next = BigInteger.ZERO;
    @Override
    public BigInteger get() {
        next = next.add(BigInteger.ONE);
        return next;
    }
}

1. Retour par d'autres méthodes

Stream<String> lines = Files.lines(Path.get(filename))
...

méthode map

Une opération est mappé à chaque élément du Stream, complétant ainsi la conversion d'un Stream à un autre
L'objet accepté par la méthode map est l'interface Function, qui est une interface fonctionnelle :

<R> Stream<R> map(Function<? super T, ? extends R> mapper);


@FunctionalInterface
public interface Function<T, R> {
    // 将T转换为R
    R apply(T t);
}

Utiliser. :

// 获取Stream里每个数的平方的集合
Stream<Integer> ns = Stream.of(1, 2, 3, 4, 5);
ns.map(n -> n * n).forEach(System.out::println);

flatMap

La méthode map est un mappage un-à-un, et une seule valeur sera générée pour chaque donnée d'entrée.

La méthode flatMap est un mappage un-à-plusieurs. Chaque élément est toujours mappé à un Stream, puis les éléments de ce Stream enfant sont mappés à la collection parent :

Stream<List<Integer>> inputStream = Stream.of(Arrays.asList(1), Arrays.asList(2, 3), Arrays.asList(4, 5, 6));
List<Integer> integerList = inputStream.flatMap((childList) -> childList.stream()).collect(Collectors.toList());
//将一个“二维数组”flat为“一维数组”
integerList.forEach(System.out::println);

méthode filter

La méthode filter permet de filtrer les éléments du Stream et de générer un nouveau Stream avec des éléments qualifiés. Le paramètre accepté par la méthode
filter est l'objet d'interface Predicate. Cette interface est une interface fonctionnelle :

Stream<T> filter(Predicate<? super T>) predicate;


@FunctionInterface
public interface Predicate<T>   {
    // 判断元素是否符合条件
    boolean test(T t);
}

Utiliser

// 获取当前Stream所有偶数的序列
Stream<Integer> ns = Stream.of(1, 2, 3, 4, 5);
ns.filter(n -> n % 2 == 0).forEach(System.out::println);

limite, sauter

limit Il est utilisé pour limiter le nombre de résultats obtenus. Il est similaire à la limite dans la base de données qui est utilisée pour exclure les premiers résultats.

trié

La fonction triée doit transmettre un objet qui implémente l'interface fonctionnelle Comparator. La méthode abstraite compare de cette interface reçoit deux paramètres et renvoie une valeur entière. , et autres Les méthodes de tri courantes sont les mêmes.

distinct

distinct est utilisé pour éliminer les doublons, ce qui est cohérent avec l'utilisation de distinct dans la base de données.

findFirst

La méthode findFirst renvoie toujours le premier élément. S'il n'y a pas d'élément, elle renvoie vide. Son type de valeur de retour est Facultatif. sachez que c'est un type facultatif. S'il y a un premier élément, la valeur stockée dans le type Facultatif est là. S'il n'y a pas de premier élément, le type est vide.

Stream<User> stream = users.stream();
Optional<String> userID = stream.filter(User::isVip).sorted((t1, t2) -> t2.getBalance() - t1.getBalance()).limit(3).map(User::getUserID).findFirst();
userID.ifPresent(uid -> System.out.println("Exists"));

min, max

min peut trouver la valeur minimale du flux entier et renvoyerOptionalInt.

max peut trouver la valeur maximale du flux entier et renvoyerOptionalInt.

Ces deux méthodes sont des opérations de fin et ne peuvent être appelées qu'une seule fois.

allMatch, anyMatch, noneMatch

allMatch : tous les éléments du Stream correspondent au prédicat entrant et renvoient true

anyMatch : tant qu'un élément du Stream correspond au prédicat entrant prédicat, il renvoie true

noneMatch : aucun des éléments du Stream ne correspond au prédicat entrant et renvoie true

méthode de réduction

La méthode de réduction applique chaque élément d'un Stream à BiFunction à la fois et combinez les résultats.
La méthode acceptée par la méthode réduire est l'objet d'interface BinaryOperator.

Optional<T> reduce(BinaryOperator<T> accumulator);


@FuncationalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
    // Bi操作，两个输入，一个输出
    T apply(T t, T u);
}

Utilisation :

// 求当前Stream累乘的结果
Stream<Integer> ns = Stream.of(1, 2, 3, 4, 5);
int r = ns.reduce( (x, y) -> x * y ).get();
System.out.println(r);

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!