[JAVA] Quel est le plus rapide, taille ou 0, comme argument de List # toArray?

Première conclusion

• toArray (new T [0]) est plus rapide.

Contexte

• list.toArray a de meilleures performances avec la taille! Je me suis souvenu.

• Si vous recherchez un peu sur Google, toutes les pages sont écrites comme ça en fonction de l'implémentation interne.

• Cependant, les performances des VM évoluent également de jour en jour.

• Au 31 mai 2018, est-ce vraiment le cas?

→ Expérimentons!

supposition

• En fonction de la version d'exécution et de l'environnement d'exécution, il n'est pas limité aux éléments suivants, veuillez donc ne pas l'avaler.
• Je n'ai pas vu l'implémentation interne.

Code expérimental

import java.util.ArrayList;
import java.util.List;

public class Test {

	public static void main(String[] args) {

		List<String> list = new ArrayList<>();
		for (int i = 0; i < 1000; i++) {
			list.add(Integer.toString(i));
		}

		int[] loopCounts = new int[] { 1000, 10000, 100000, 1000000, 10000000 };
		for (int loop : loopCounts) {
			long sum = 0;
			for (int j = 0; j < 10; j++) {
				long start = System.currentTimeMillis();

				String[] temp = null;
				for (int i = 0; i < loop; i++) {
					temp = list.toArray(new String[0]);
				}

				long stop = System.currentTimeMillis();
				sum += stop - start;
			}
			System.out.println("toArray(new String[0]) " + loop + "Vitesse du temps*La vitesse moyenne de 10 fois est" + sum / 10 + "C'est une milliseconde.");

			sum = 0;
			for (int j = 0; j < 10; j++) {
				long start = System.currentTimeMillis();

				String[] temp = null;
				for (int i = 0; i < loop; i++) {
					temp = list.toArray(new String[list.size()]);
				}

				long stop = System.currentTimeMillis();
				sum += stop - start;
			}
			System.out.println("toArray(new String[list.size()]) " + loop + "Vitesse du temps*La vitesse moyenne de 10 fois est" + sum / 10 + "C'est une milliseconde.");
		}
	}
}

résultat

[1 000 fois]

toArray (new String [0]) 1000 fois speed * 10 fois La vitesse moyenne est de 2 millisecondes.

toArray (new String [list.size ()]) 1000 fois la vitesse * 10 fois La vitesse moyenne est de 2 millisecondes.

[10 000 fois]

toArray (new String [0]) 10000 fois la vitesse * 10 fois La vitesse moyenne est de 19 millisecondes.

toArray (new String [list.size ()]) 10000 fois la vitesse * 10 fois La vitesse moyenne est de 25 millisecondes.

[100 000 fois]

toArray (new String [0]) 100000 fois la vitesse * 10 fois La vitesse moyenne est de 207 millisecondes.

toArray (new String [list.size ()]) 100000 fois vitesse * 10 fois La vitesse moyenne est de 288 millisecondes.

[1 000 000 fois]

toArray (new String [0]) 1000000 fois speed * 10 fois La vitesse moyenne est de 1497 millisecondes.

toArray (new String [list.size ()]) 1000000 fois vitesse * 10 fois La vitesse moyenne est de 1562 millisecondes.

[10 000 000 fois]

toArray (new String [0]) 10000000 fois la vitesse * 10 fois La vitesse moyenne est de 12949 millisecondes.

toArray (new String [list.size ()]) 10000000 fois la vitesse * 10 fois La vitesse moyenne est de 15622 millisecondes.

Conclusion encore

** toArray (new T [0]) est plus rapide! ** **

Épilogue

C'est gênant car c'est écrit dans un article sorti sur le net (autodiscipline)

URL qui semble utile

Lien externe: Tableaux de la sagesse des anciens