[JAVA] Vitesse de traitement avec et sans statique

static Parce que statique a une image de propriété partagée Si vous êtes toujours assis dans le coin de la mémoire, j'ai essayé à partir de l'image que l'utilisation de l'électricité statique est plus rapide.

essayons

Classe de mesure de la vitesse de traitement.java

package mk42;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

public class StreamProcessingTest {
	private static final List<String> list = Arrays.asList("a", "s", "k");
	public static void main(String[] args) {
		Long start = System.nanoTime();
		test();
		Long end = System.nanoTime();
		Mk42.echo.accept("Processing TIme : " + (end - start) + "ns");
		/** ----------not static---------- */
		Mk42.echo.accept("next test");
		NotStaticProcessingTest no = new NotStaticProcessingTest();
		Long start2 = System.nanoTime();
		no.test2();
		Long end2 = System.nanoTime();
		Mk42.echo.accept("Processing TIme : " + (end2 - start2) + "ns");
	}
	private static void test() {
		// twice
		list.stream().forEach(v -> execute());
		list.stream().filter(v -> !v.equals("a")).forEach(v -> qwe());
		//Le temps de traitement ne change pas beaucoup même si des traitements multiples sont effectués à l'intérieur de l'opération de terminaison ou divisés..
	}
	private static void execute() {
		List<Integer> a = new ArrayList<Integer>();
		IntStream.range(0, 10).forEach(v -> a.add(2));
	}
	private static void qwe() {
		List<Integer> a = new ArrayList<Integer>();
		IntStream.range(0, 10000000).forEach(v -> a.add(2));
	}
}

Une classe qui résume les méthodes pour les expériences non statiques.java

package mk42;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

public class NotStaticProcessingTest {
	private static final List<String> list = Arrays.asList("a", "s", "k");
	public void run() {
		System.out.println("qwe");
	}
	public void test() {
		// onece
		list.stream().forEach(v -> {
			execute();
			if(!v.equals("a"))
				qwe();
		});
		//Le temps de traitement ne change pas beaucoup même si des traitements multiples sont effectués à l'intérieur de l'opération de terminaison ou divisés..
	}
	public void test2() {
		// twice
		list.stream().forEach(v -> execute());
		list.stream().filter(v -> !v.equals("a")).forEach(v -> qwe());
		//Le temps de traitement ne change pas beaucoup même si des traitements multiples sont effectués à l'intérieur de l'opération de terminaison ou divisés..
	}
	private void execute() {
		List<Integer> a = new ArrayList<Integer>();
		IntStream.range(0, 10).forEach(v -> a.add(2));
	}
	private void qwe() {
		List<Integer> a = new ArrayList<Integer>();
		IntStream.range(0, 10000000).forEach(v -> a.add(2));
	}
}

résultat

static -> Processing TIme : 222787700ns
Non statique-> Processing TIme : 176494000ns

Quoi? J'ai pensé, mais si tu expérimentes plusieurs fois

static.

Processing TIme : 225677500ns
Processing TIme : 223625900ns
Processing TIme : 223150400ns
Processing TIme : 228877000ns
Processing TIme : 223187400ns

Non statique.

Processing TIme : 178923100ns
Processing TIme : 167760600ns
Processing TIme : 190593300ns
Processing TIme : 180728700ns
Processing TIme : 216358400ns

Je ne veux pas le faire parce que c'est un peu moyen, mais ce n'est pas J'ai l'impression qu'il y a peu de flou

La force de la statique n'est pas qu'elle est rapide, mais qu'il y a peu de fluctuations dans la vitesse de traitement ...?