[JAVA] Jusqu'où est la bonne réponse pour diviser le processus?

Par rapport

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 est sysout, il est préparé séparément.

Vérification de la vitesse de traitement.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
	 */
}

résultat

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

Raison

Pas où diviser le processus 1 est le plus rapide car j'appelle Integer 2 est plus lent que 3 car j'utilise et puis au milieu de l'opération

4 et 5 sont la différence entre la méthode et la fonction

Méthode.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

Cela ne fait donc pas beaucoup de différence, mais la méthode peut être un peu plus rapide ...?

Si la vitesse ne change pas beaucoup entre la méthode et la fonction, la fonction est-elle née pour une opération intermédiaire de stream ...?

Recommended Posts

Jusqu'où est la bonne réponse pour diviser le processus?
Personnalisez la répartition du contenu de Recyclerview
Comment la valeur suivante de l'objet Time est-elle correcte?
Comment effectuer un processus spécifique lorsque le bouton de retour est enfoncé dans le fragment Android
Comment utiliser la méthode link_to
Comment utiliser la méthode include?
Comment trouver l'angle moyen
Comment utiliser la classe wrapper
Comment afficher la valeur lorsqu'il y a un tableau dans le tableau
J'ai essayé de comprendre comment la méthode des rails "redirect_to" est définie
J'ai essayé de comprendre comment la méthode des rails "link_to" est définie
Comment identifier le chemin sur lequel il est facile de se tromper
Comment ajouter la fonction de suppression
[Docker] Comment créer lorsque le code source est monté en liaison sur le conteneur
[Java] Comment utiliser la classe File
Comment désactiver le regroupement d'erreurs
[Rails] Comment utiliser la méthode de la carte
[Java] Comment utiliser la méthode toString ()
Etudier comment utiliser le constructeur (java)
[Traitement × Java] Comment utiliser la boucle
Comment déterminer le nombre de parallèles
[Java] Comment régler la date sur 00:00:00
[Java] Comment obtenir le répertoire actuel
Comment le site Web s'affiche à l'écran
[Traitement × Java] Comment utiliser la classe
Comment trier une liste de SelectItems
Comment trouver les dizaines et les unités
Comment passer la valeur à un autre écran
Comment obtenir la date avec Java
[Java 7] Divisez la liste Java et exécutez le processus
[Traitement × Java] Comment utiliser la fonction
[Java] Comment utiliser la classe Calendar
Résumé de la façon de monter les escaliers de programmation
Comment définir quand "Le constructeur Empty () n'est pas visible" se produit dans junit
Comment trouver la cause de l'erreur Ruby
Comment utiliser le module caméra OV7725 (ESP32-WROVER-B)
Comment rédiger la réponse à la 15e question de référence hors ligne
Comment vérifier le journal dans le conteneur Docker
Comment mettre en œuvre la fonction de chapelure avec Gretel
Comment obtenir le jour d'aujourd'hui