[JAVA] Die Funktion ist sehr einfach zu bedienen

Funktionsschnittstelle

Sie können jetzt eine Methode als Funktion in einen Lambda-Ausdruck schreiben. Lass es uns vorerst tun.

Referenz Offizielle Referenz

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

Deklarieren Sie einfach Function <Argument, Rückgabewert> und schreiben Sie einen beliebigen Prozess.

Funktionen können mit der Methode
• .andThen kombiniert werden (kontinuierlich ausgeführt)
• Wenn kein Argument vorhanden ist, führen Sie es mit der Methode "Supplier", .get () aus
• Wenn es keinen Rückgabewert gibt, führen Sie ihn mit der Methode `Consumer`, .accept () aus
• Mit der Methode `Function`, .apply () für ein Argument und einen Rückgabewert ausführen
• Wenn das Argument und der Rückgabetyp identisch sind, führen Sie sie mit der Methode .apply () "UnaryOperator" aus (Es ist in Ordnung, `Function ` auszuführen, daher ist dies praktisch unnötig.)

Nun, es gibt viele andere Dinge, aber sie wurden offiziell erwähnt.

Was Sie normalerweise in der Methode schreiben, indem Sie in Funtion schreiben Dadurch wird die Anzahl der Zeilen verringert und die Anzeige erleichtert.

Die Schwierigkeit ist, dass JavaDoc schwer zu sehen ist?

Trotzdem wird es wahnsinnig klug sein, oder?