Ce n'est peut-être pas ancien ou nouveau w Principalement sur le traitement des boucles, la confrontation de vitesse. J'ai joué jusqu'à 3 fois.
ListSize.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;
/**
* Test.
*
* @author me
*
*/
public class ListSizeTest {
/**
*la mesure.
* @param args
*/
public static void main(String[] args) {
System.out.println("-----size-----");
Long start1 = System.nanoTime();
loop1();
Long end1 = System.nanoTime();
System.out.println(end1 - start1 + "ns\r\n\r\n-----isEmpty-----");
Long start2 = System.nanoTime();
loop2();
Long end2 = System.nanoTime();
System.out.println(end2 - start2 + "ns");
}
/**
* size
*/
private static void loop1() {
List<Integer> list = new LinkedList<Integer>();
IntStream.range(0, 100000).forEach(i -> list.add(0));
if (list.size() == 0) {
}
}
/**
* isEmpty
*/
private static void loop2() {
List<Integer> list = new LinkedList<Integer>();
IntStream.range(0, 100000).forEach(i -> list.add(0));
if (list.isEmpty()) {
}
}
/**
* -----size-----
* 48341618ns
*
* -----isEmpty-----
* 10812354ns
*/
}
La victoire écrasante d'isEmpty ArrayList Je ne veux pas l'utiliser sauf si je n'ai pas d'autre choix que de connaître le nombre d'éléments.
pour et IntStream.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;
/**
* Test.
*
* @author me
*
*/
public class LoopTest1 {
/**
*la mesure.
* @param args
*/
public static void main(String[] args) {
System.out.println("-----pour déclaration-----");
Long start1 = System.nanoTime();
loop1();
Long end1 = System.nanoTime();
System.out.println(end1 - start1 + "ns\r\n\r\n-----IntStream-----");
Long start2 = System.nanoTime();
loop2();
Long end2 = System.nanoTime();
System.out.println(end2 - start2 + "ns");
}
/**
*pour déclaration
*/
private static void loop1() {
List<Integer> list = new LinkedList<Integer>();
for (int i = 0; i < 10000000; i++) {
list.add(0);
}
}
/**
* IntStream
*/
private static void loop2() {
List<Integer> list = new LinkedList<Integer>();
IntStream.range(0, 10000000).forEach(i -> list.add(0));
}
/**
* -----pour déclaration-----
* 1563850086ns
* 1563641080ns
* 1802331635ns
*
* -----IntStream-----
* 1809124813ns
* 1726875157ns
* 1476842733ns
*/
}
Hum ... Eh bien, je ne l'ai pas vérifié exactement, mais c'est peut-être juste une déclaration for. IntStream semble avoir une lisibilité élevée S'agit-il plutôt d'une opération intermédiaire de stream?
C'est mon préféré
Étendu pour la déclaration et le flux.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;
/**
* Test.
*
* @author me
*
*/
public class LoopTest2 {
/**
*la mesure.
* @param args
*/
public static void main(String[] args) {
System.out.println("-----pour déclaration-----");
Long start1 = System.nanoTime();
loop1();
Long end1 = System.nanoTime();
System.out.println(end1 - start1 + "ns\r\n\r\n-----stream-----");
Long start2 = System.nanoTime();
loop2();
Long end2 = System.nanoTime();
System.out.println(end2 - start2 + "ns");
}
/**
*pour déclaration
*/
private static void loop1() {
List<Integer> list = new LinkedList<Integer>();
IntStream.range(0, 10000000).forEach(i -> list.add(0));
for(Integer num : list) {
num += 1;
}
}
/**
* stream
*/
private static void loop2() {
List<Integer> list = new LinkedList<Integer>();
IntStream.range(0, 10000000).forEach(i -> list.add(0));
list.stream().map(num -> num += 1);
}
/**
* -----pour déclaration-----
* 1746784426ns
* 1855868091ns
* 1790482647ns
*
* -----stream-----
* 1453116296ns
* 1630589874ns
* 1487128838ns
*/
}
Dans un article, j'ai vu quelque chose comme stream, ok for statement si le nombre de boucles est petit. Eh bien, c'est amusant d'utiliser stream
pour instruction et étendu pour instruction.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;
/**
* Test.
*
* @author me
*
*/
public class LoopTest3 {
/**
*la mesure.
* @param args
*/
public static void main(String[] args) {
System.out.println("-----pour déclaration-----");
Long start1 = System.nanoTime();
loop1();
Long end1 = System.nanoTime();
System.out.println(end1 - start1 + "ns\r\n\r\n-----Étendu pour déclaration-----");
Long start2 = System.nanoTime();
loop2();
Long end2 = System.nanoTime();
System.out.println(end2 - start2 + "ns");
}
/**
*pour la liste d'instructions#get()
*/
private static void loop1() {
List<Integer> list = new LinkedList<Integer>();
IntStream.range(0, 100000).forEach(i -> list.add(0));
for (int i = 0; i < list.size(); i++) {
int a = list.get(i);
}
}
/**
*Étendu pour déclaration
*/
private static void loop2() {
List<Integer> list = new LinkedList<Integer>();
IntStream.range(0, 100000).forEach(i -> list.add(0));
for (Integer num : list) {
int a = num;
}
}
/**
* -----pour déclaration-----
* 5172240485ns
*
* -----Étendu pour déclaration-----
* 25571106ns
*/
}
Oui. Il n'y a pas beaucoup de situations où vous ne pouvez pas utiliser l'instruction for étendue. Prolongé pour la phrase C'est comme si c'était le cas.
Boucle avec traitement intermédiaire.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
/**
* Test.
*
* @author me
*
*/
public class LoopTest4 {
/**
*la mesure.
* @param args
*/
public static void main(String[] args) {
System.out.println("-----pour déclaration-----");
Long start1 = System.nanoTime();
loop1();
Long end1 = System.nanoTime();
System.out.println(end1 - start1 + "ns\r\n\r\n-----stream-----");
Long start2 = System.nanoTime();
loop2();
Long end2 = System.nanoTime();
System.out.println(end2 - start2 + "ns");
}
/**
*pour déclaration
*/
private static void loop1() {
List<String> list = new LinkedList<String>();
IntStream.range(0, 5000000).forEach(v -> list.add("a"));
IntStream.range(0, 5000000).forEach(v -> list.add("z"));
List<String> answer = new LinkedList<String>();
for (String str : list) {
if (str.equals("a")) {
answer.add(str);
}
}
}
/**
* stream
*/
private static void loop2() {
List<String> list = new LinkedList<String>();
IntStream.range(0, 5000000).forEach(v -> list.add("a"));
IntStream.range(0, 5000000).forEach(v -> list.add("z"));
list.stream().filter(v -> v.equals("a")).collect(Collectors.toList());
}
/**
* -----pour déclaration-----
* 2954071288ns
* 2845232552ns
* 2849512987ns
*
* -----stream-----
* 2036753887ns
* 2563286049ns
* 2188877495ns
*/
}
Je pense que cela dépend du contenu de l'opération intermédiaire, mais il semble que cela ne puisse être dit sans condition. Eh bien, est-ce un ruisseau?
Méthode et fonction.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.function.Supplier;
import java.util.stream.IntStream;
/**
* Test
* @author me
*
*/
public class MethodFunctionTest1 {
/**
*la mesure
* @param args
*/
public static void main(String[] args) {
System.out.println("-----method-----");
Long start1 = System.nanoTime();
method();
Long end1 = System.nanoTime();
System.out.println(end1 - start1 + "ns\r\n\r\n-----function-----");
Long start2 = System.nanoTime();
function.get();
Long end2 = System.nanoTime();
System.out.println(end2 - start2 + "ns");
}
/**
* method
*/
private static List<String> method() {
List<String> list = new LinkedList<String>();
IntStream.range(0, 10000000).forEach(i -> list.add("a"));
return list;
}
/**
* function
*/
private static Supplier<List<String>> function = () -> {
List<String> list = new LinkedList<String>();
IntStream.range(0, 10000000).forEach(v -> list.add("a"));
return list;
};
/**
* -----method-----
* 1766534141ns
* 1802412812ns
* 1645580959ns
*
* -----function-----
* 1560679066ns
* 1584875301ns
* 1897649797ns
*/
}
Je ne comprends vraiment pas ça Il semble que cela ne sert à rien si l'utilisation de la fonction est étrange en raison de la charge sur la mémoire À quoi sert la fonction? Est-ce vraiment à cause du fonctionnement intermédiaire de stream?
Eh bien, est-ce le résultat que la méthode est bonne?