L'instruction for étendue est plus rapide que l'instruction for normale car elle utilise Iterator! Quelqu'un m'a dit que je l'avais laissé tel quel sans le vérifier. À ce moment, j'ai décidé de faire une enquête appropriée. Et s'il s'agissait de l'histoire qu'une phrase normale est meilleure ... Je pense que l'ère est stream, mais comme mon site est Java 6, je dois apprendre à mes juniors à écrire en Java 6. ~~ Ce n'est pas parce que je ne peux pas écrire un flux. ~~
Quand je l'ai fait à environ 100 000, la valeur était trop petite pour être comparée, alors je l'ai bouclée 10 millions de fois.
Main.java
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 10000000; i++) {
list.add(i);
}
//début
long start = System.currentTimeMillis();
//10 millions de boucles
for (int i = 0; i < list.size(); i++) {
int tmp = list.get(i);
}
//Fin
long end = System.currentTimeMillis();
System.out.println("pour déclaration: " + (end - start) + " ms");
//début
start = System.currentTimeMillis();
//10 millions de boucles
for (Integer i : list) {
int tmp = i;
}
//Fin
end = System.currentTimeMillis();
System.out.println("Étendu pour déclaration: " + (end - start) + " ms");
}
}
Quel idiot ... Je l'ai essayé plusieurs fois, mais la déclaration étendue pour ne s'est pas accélérée.
pour déclaration: 24 ms
Étendu pour déclaration: 29 ms
Quand j'ai pensé que ça ne finirait pas comme ça, il y avait un site comme celui-ci.
Raison de l'utilisation de la déclaration étendue - [Seasar] Diary of soichirooooo5
Si vous regardez le lien, la réponse que vous vouliez écrire dans cet article est écrite, C'est un gros problème, alors je vais le faire jusqu'à la fin. Étant donné que la vérification est effectuée uniquement avec ArrayList, je vérifierai également avec Array et LinkedList.
Main.java
public class Main {
public static void main(String[] args) {
int[] array = new int[10000000];
for (int i = 0; i < 10000000; i++) {
array[i] = i;
}
//début
long start = System.currentTimeMillis();
//10 millions de boucles
for (int i = 0; i < array.length; i++) {
int tmp = array[i];
}
//Fin
long end = System.currentTimeMillis();
System.out.println("pour déclaration: " + (end - start) + " ms");
//début
start = System.currentTimeMillis();
//10 millions de boucles
for (int i : array) {
int tmp = i;
}
//Fin
end = System.currentTimeMillis();
System.out.println("Étendu pour déclaration: " + (end - start) + " ms");
}
}
~~ pour une phrase trop rapide www ~~ Parce que l'autoboxing a été effectué dans l'instruction Extended for Je ne pouvais pas le mesurer avec précision. Le résultat reste le même.
pour déclaration: 3 ms
Étendu pour déclaration: 3 ms
Main.java
package qiita;
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = new LinkedList<>();
for (int i = 0; i < 10000000; i++) {
list.add(i);
}
//début
long start = System.currentTimeMillis();
//10 millions de boucles
for (int i = 0; i < list.size(); i++) {
int tmp = list.get(i);
}
//Fin
long end = System.currentTimeMillis();
System.out.println("pour déclaration: " + (end - start) + " ms");
//début
start = System.currentTimeMillis();
//10 millions de boucles
for (Integer i : list) {
int tmp = i;
}
//Fin
end = System.currentTimeMillis();
System.out.println("Étendu pour déclaration: " + (end - start) + " ms");
}
}
Je n'ai pas reçu de réponse depuis environ 5 minutes.
Puisqu'il ne se termine pas, revérifiez avec 100 000 boucles
Main.java
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = new LinkedList<>();
for (int i = 0; i < 100000; i++) {
list.add(i);
}
//début
long start = System.currentTimeMillis();
//10 millions de boucles
for (int i = 0; i < list.size(); i++) {
int tmp = list.get(i);
}
//Fin
long end = System.currentTimeMillis();
System.out.println("pour déclaration: " + (end - start) + " ms");
//début
start = System.currentTimeMillis();
//10 millions de boucles
for (Integer i : list) {
int tmp = i;
}
//Fin
end = System.currentTimeMillis();
System.out.println("Étendu pour déclaration: " + (end - start) + " ms");
}
}
c'est incroyable! !!
pour déclaration: 5695 ms
Étendu pour déclaration: 36 ms
Il s'est avéré que l'instruction for normale est plus rapide pour les éléments qui sont exploités dans l'ordre depuis l'avant, tels que ArrayList et les tableaux. Cependant, la liste liée a fait une énorme différence. Il est étrange de se soucier de la substance lors de la boucle de l'interface de liste, donc je pense que j'ai pu arriver à la conclusion que la déclaration étendue pour est bien.
Ce qui suit est une citation du site de référence.
Si vous utilisez l'instruction for étendue, vous n'avez pas à vous soucier d'une "dégradation des performances de 99% ou plus" même si vous ne savez pas si l'objet passé à l'instruction for est ArrayList ou LinkedList.
De plus, l'instruction for étendue convertit le type d'implémentation de l'interface List en code qui utilise un itérateur, et dans le cas d'un tableau, elle le convertit en code qui accède à l'index.
Vous pouvez voir que la traduction de ce compilateur générera le code approprié pour la liste ou le tableau que vous passez à l'instruction for. En d'autres termes, si vous utilisez Extended pour, vous n'avez à penser à rien et vous n'avez à vous soucier de rien. Si quelque chose ne va pas, cela fera quelque chose derrière l'API.
En d'autres termes, vous pouvez utiliser l'instruction Extended for sans penser à rien. stream Étudions.
Recommended Posts