[JAVA] La fonction est très facile à utiliser

Interface de fonction

Vous pouvez maintenant écrire une méthode en tant que Function dans une expression lambda. Faisons-le pour le moment.

référence Référence officielle

Function.java

package functionPractice;

import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Arrays;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;

/**
 * To practice function-interface
 * 
 * @author me
 *
 */
public class FunctionPractice {

	/**
	 * main
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			run();
		} catch (NumberFormatException e) {
			echo.accept("・ Ω ・ v");
		}
	}

	/**
	 * run
	 * 
	 * @throws NumberFormatException if conversion to numeric number is impossible.
	 */
	private static void run() throws NumberFormatException {
		generate.get().stream().filter(Objects::nonNull).map(toString.andThen(add3).andThen(toInteger)).forEach(echo);
		echo.accept(join.apply(generate.get()));
		List<Integer> list = generate.get().stream().map(toInteger).collect(Collectors.toList());
		echo.accept(list);
		echo.accept(sum.apply(list));
	}

	/** Output */
	static Consumer<Object> echo = v -> System.out.println(v);
	/** Generate */
	static Supplier<List<String>> generate = () -> Arrays.asList(null, "1", "2", "3");
	/** Object to String */
	static Function<Object, String> toString = v -> String.valueOf(v);
	/** Object to Integer */
	static Function<Object, Integer> toInteger = v -> Integer
			.parseInt(Optional.ofNullable(v).orElse("1").toString());
	/** Add "3" */
	static UnaryOperator<String> add3 = v -> v + "3";
	/** Join comma */
	static Function<List<String>, String> join = v -> v.stream().filter(Objects::nonNull).collect(Collectors.joining(","));
	/** Sum integer list */
	static Function<List<Integer>, Integer> sum = v -> v.stream().filter(Objects::nonNull)
			.collect(Collectors.summingInt(Integer::intValue));
}

Déclarez simplement Fonction <argument, valeur de retour> et écrivez le processus de votre choix.

Les fonctions peuvent être combinées avec la méthode
• .andThen (exécutée en continu)
• S'il n'y a pas d'argument, exécutez avec la méthode `Supplier`, .get ()
• S'il n'y a pas de valeur de retour, exécutez avec la méthode `Consumer`, .accept ()
• Exécuter avec la méthode `Function`, .apply () pour un argument et une valeur de retour
• Si l'argument et le type de retour sont identiques, exécutez avec la méthode ʻUnaryOperator`, .apply () (Il est normal de faire `Function `, donc c'est pratiquement inutile)

Eh bien, il y a beaucoup d'autres choses, mais elles ont été officiellement mentionnées.

Ce que vous écrivez habituellement dans la méthode, en écrivant dans Funtion Cela réduira le nombre de lignes et le rendra plus facile à voir.

La difficulté est que javaDoc est difficile à voir?

Même ainsi, ce sera incroyablement intelligent, non?