[JAVA] Wie weit ist die richtige Antwort, um den Prozess zu teilen?

Verglichen

FUnction.java

package mk42;

import java.util.List;
import java.util.function.Function;
import java.util.function.UnaryOperator;

/**
 * All method has the same process.
 *
 * @author
 *
 */
public class NotStaticProcessingTest {
	/**
	 * This method contains all process to need.
	 * @param list
	 */
	public void streamTest1(List<String> list) {
		list.stream().map(v -> v + "3").mapToInt(Integer::parseInt).sum();
	}
	/**
	 * This method has 2 functions.
	 * @param list
	 */
	public void streamTest2(List<String> list) {
		list.stream().map(add3.andThen(convertInt)).mapToInt(v -> v).sum();
	}
	/**
	 * This method has 1 functions.
	 * @param list
	 */
	public void streamTest3(List<String> list) {
		list.stream().map(all).mapToInt(v -> v).sum();
	}
	/**
	 * This method has 1 function.
	 * The function has all process.
	 * @param list
	 */
	public void streamTest4(List<String> list) {
		this.sum.apply(list);
	}
	/**
	 * This method has methos instead of function.
	 * @param list
	 */
	public void streamTest5(List<String> list) {
		this.sum(list);
	}

	/** Add 3 */
	private UnaryOperator<String> add3 = v -> v + "3";
	/** Convert to Integer */
	private Function<Object, Integer> convertInt = v -> Integer.parseInt(String.valueOf(v));
	/** all */
	private Function<String, Integer> all = v -> Integer.parseInt(v + "3");
	/** all of them function */
	private Function<List<String>, Integer> sum = v -> v.stream().mapToInt(x -> Integer.parseInt(x + "3")).sum();
	/** all of them method */
	private Integer sum(List<String> list) {
		return list.stream().mapToInt(v -> Integer.parseInt(v + "3")).sum();
	}
}

Mk42.echo ist sysout, es wird separat vorbereitet.

Überprüfung der Verarbeitungsgeschwindigkeit.java

package mk42;

import java.util.Arrays;
import java.util.List;

public class StreamProcessingTest {

	/** constant list */
	private static final List<String> list = Arrays.asList("1", "2", "3");

	/**
	 * main
	 * @param args
	 */
	public static void main(String[] args) {

		// instance
		NotStaticProcessingTest no = new NotStaticProcessingTest();

		/** ----------test1---------- */
		Mk42.echo.accept("stream test 1");
		Long start1 = System.nanoTime();
		no.streamTest1(list);
		Long end1 = System.nanoTime();
		Mk42.echo.accept("Processing TIme : " + (end1 - start1) + "ns");

		/** ----------test2---------- */
		Mk42.echo.accept("stream test 2");
		Long start2 = System.nanoTime();
		no.streamTest2(list);
		Long end2 = System.nanoTime();
		Mk42.echo.accept("Processing TIme : " + (end2 - start2) + "ns");

		/** ----------test3---------- */
		Mk42.echo.accept("stream test 3");
		Long start3 = System.nanoTime();
		no.streamTest3(list);
		Long end3 = System.nanoTime();
		Mk42.echo.accept("Processing TIme : " + (end3 - start3) + "ns");

		/** ----------test4---------- */
		Mk42.echo.accept("stream test 4");
		Long start4 = System.nanoTime();
		no.streamTest4(list);
		Long end4 = System.nanoTime();
		Mk42.echo.accept("Processing TIme : " + (end4 - start4) + "ns");

		/** ----------test5---------- */
		Mk42.echo.accept("stream test 5");
		Long start5 = System.nanoTime();
		no.streamTest5(list);
		Long end5 = System.nanoTime();
		Mk42.echo.accept("Processing TIme : " + (end5 - start5) + "ns");
	}
	/**
	 * As a result.
	 *
	 * stream test 1
	 * Processing TIme : 3630700ns
	 *
	 * stream test 2
	 * Processing TIme : 632701ns
	 *
	 * stream test 3
	 * Processing TIme : 195400ns
	 *
	 * stream test 4
	 * Processing TIme : 151499ns
	 *
	 * stream test 5
	 * Processing TIme : 143600ns
	 */
}

Ergebnis

stream test 1
Processing TIme : 3630700ns
stream test 2
Processing TIme : 632701ns
stream test 3
Processing TIme : 195400ns
stream test 4
Processing TIme : 151499ns
stream test 5
Processing TIme : 143600ns

Grund

Nicht, wo der Prozess aufgeteilt werden soll 1 ist die schnellste, weil ich Integer aufrufe 2 ist langsamer als 3, weil ich andThen in der mittleren Operation verwende

4 und 5 sind der Unterschied zwischen Methode und Funktion

Methode.java

	public void streamTest4(List<String> list) {
		this.sum.apply(list);
	}
	
	public void streamTest5(List<String> list) {
		this.sum(list);
	}

stream test 4
Processing TIme : 151499ns
stream test 5
Processing TIme : 143600ns

Es macht also keinen großen Unterschied, aber die Methode kann etwas schneller sein ...?

Es wird langsamer, wenn Sie Folgendes tun
• Die Funktion ist mit andThen verbunden
• Teilen Sie die Methode in kleine Teile und nennen Sie sie
• Stream-Zwischenoperationen nehmen zu
• Rufen Sie Collectors, String usw. auf.

Wenn sich die Geschwindigkeit zwischen der Methode und der Funktion nicht wesentlich ändert, wurde die Funktion für eine Zwischenoperation des Streams geboren ...?