Es kann nicht alt oder neu sein w Hauptsächlich über Schleifenverarbeitung, Geschwindigkeitskonfrontation. Ich habe bis zu 3 Mal gespielt.
ListSize.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;
/**
* Test.
*
* @author me
*
*/
public class ListSizeTest {
/**
*Messung.
* @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
*/
}
isEmptys überwältigender Sieg ArrayList Ich möchte es nicht so oft wie möglich verwenden, es sei denn, ich kann nicht anders, als die Anzahl der Elemente zu kennen.
für und IntStream.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;
/**
* Test.
*
* @author me
*
*/
public class LoopTest1 {
/**
*Messung.
* @param args
*/
public static void main(String[] args) {
System.out.println("-----zur Aussage-----");
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");
}
/**
*zur Aussage
*/
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));
}
/**
* -----zur Aussage-----
* 1563850086ns
* 1563641080ns
* 1802331635ns
*
* -----IntStream-----
* 1809124813ns
* 1726875157ns
* 1476842733ns
*/
}
Hmm ... Nun, ich habe es nicht genau überprüft, aber vielleicht ist es nur eine for-Aussage. IntStream scheint eine hohe Lesbarkeit zu haben Ist es eher eine Zwischenoperation des Stroms?
Das ist mein Lieblings
Erweitert für Anweisung und Stream.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;
/**
* Test.
*
* @author me
*
*/
public class LoopTest2 {
/**
*Messung.
* @param args
*/
public static void main(String[] args) {
System.out.println("-----zur Aussage-----");
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");
}
/**
*zur Aussage
*/
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);
}
/**
* -----zur Aussage-----
* 1746784426ns
* 1855868091ns
* 1790482647ns
*
* -----stream-----
* 1453116296ns
* 1630589874ns
* 1487128838ns
*/
}
In einem Artikel habe ich so etwas wie Stream gesehen, ok für die Aussage, wenn die Anzahl der Schleifen klein ist. Nun, es macht Spaß, Stream zu verwenden
für Aussage und erweitert für Aussage.java
package test;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;
/**
* Test.
*
* @author me
*
*/
public class LoopTest3 {
/**
*Messung.
* @param args
*/
public static void main(String[] args) {
System.out.println("-----zur Aussage-----");
Long start1 = System.nanoTime();
loop1();
Long end1 = System.nanoTime();
System.out.println(end1 - start1 + "ns\r\n\r\n-----Für Aussage erweitert-----");
Long start2 = System.nanoTime();
loop2();
Long end2 = System.nanoTime();
System.out.println(end2 - start2 + "ns");
}
/**
*für Anweisungsliste#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);
}
}
/**
*Für Aussage erweitert
*/
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;
}
}
/**
* -----zur Aussage-----
* 5172240485ns
*
* -----Für Aussage erweitert-----
* 25571106ns
*/
}
Ja. Es gibt nicht viele Situationen, in denen Sie die erweiterte for-Anweisung nicht verwenden können. Erweitert für Satz Es fühlt sich so an.
Schleife mit Zwischenverarbeitung.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 {
/**
*Messung.
* @param args
*/
public static void main(String[] args) {
System.out.println("-----zur Aussage-----");
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");
}
/**
*zur Aussage
*/
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());
}
/**
* -----zur Aussage-----
* 2954071288ns
* 2845232552ns
* 2849512987ns
*
* -----stream-----
* 2036753887ns
* 2563286049ns
* 2188877495ns
*/
}
Ich denke, es hängt vom Inhalt der Zwischenoperation ab, aber es scheint, dass dies nicht unbedingt gesagt werden kann. Nun, ist es ein Stream?
Methode und Funktion.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 {
/**
*Messung
* @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
*/
}
Ich verstehe das wirklich nicht Es scheint nutzlos zu sein, wenn die Verwendung von Funktionen aufgrund der Belastung des Speichers seltsam ist Wofür ist Funktion? Liegt es wirklich an der Zwischenoperation des Streams?
Nun, ist es das Ergebnis, dass die Methode gut ist?