Tableau Java vs ArrayList Java: j'ai écrit un programme pour comparer le temps qu'il faut pour stocker un tableau Java et ArrayList de taille MAX avec des nombres aléatoires. Ces résultats sont-ils bons? ArrayList est-il censé être plus rapide?
package arraylists;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Random;
public class arraylists {
public final static int MAX = 10000;
static Random rand = new Random();
static int rand_int1 = rand.nextInt(1000);
static int rand_int2 = rand.nextInt(1000);
public static void arrayFunc(int a1 ) {
int [] arry = new int[a1];
for(int i = 0; i < a1; i++) {
arry[i] = rand_int1;
}
}
public static void arrayList(int a2) {
ArrayList<Integer> num = new ArrayList<Integer>();
for(int i = 0; i < a2; i++) {
num.add(rand_int2);
}
}
public static void main(String args[]) {
for(int i = 0; i < 10; i++){
int num;
System.out.println("Enter the number of iterations: ");
Scanner input = new Scanner(System.in);
num = input.nextInt();
long start1 = System.nanoTime();
for(int j = 0; j < num; j++) {
arrayFunc(MAX);
}
long end1 = System.nanoTime();
long timeElapsed1 = end1 - start1;
long start2 = System.nanoTime();
for(int j = 0; j < num; j++) {
arrayFunc(MAX);
}
long end2 = System.nanoTime();
long timeElapsed2 = end2 - start2;
System.out.println("Java Array execution time (in nanonseconds): " + timeElapsed1);
System.out.println("Java Array List execution time (in nanoseconds): " + timeElapsed2);
}
}
}
Java Array vs Java Array List: J'ai écrit un programme pour comparer le temps nécessaire pour stocker un tableau java et une liste de tableaux de taille MAX avec des nombres aléatoires, ces nombres sortent-ils correctement? la liste de tableaux est-elle supposée être plus rapide?
3 Réponses :
Vos deux tests appellent arrayFunc () . Votre méthode arrayList () n'est jamais utilisée.
Après avoir corrigé votre test, j'obtiens le résultat suivant:
ArrayList<Integer> num = new ArrayList<Integer>(a2);
Cela indique que le tableau est environ 6,45 fois plus rapide. Je soupçonne que la majeure partie de cette différence provient du fait que le tableau qui soutient la ArrayList doit être redimensionné plusieurs fois. Cela peut être atténué en spécifiant au préalable la capacité requise pour la ArrayList :
Enter the number of iterations: 10 Java Array execution time (in nanoseconds): 7703329 Java Array List execution time (in nanoseconds): 49696074
Les tests de curseurs indiquent que cela accélérera votre ArrayList par un facteur de 2.
Notez que la méthodes utilisées pour le benchmark , mais je pense que même avec un benchmarking correct, vous obtiendrez des résultats similaires.
ArrayList est soutenu par un tableau (plus la logique pour créer un nouveau tableau et migrer les références lorsque la liste dépasse le tableau).
Donc, le tableau est plus rapide mais il a une interface de niveau inférieur, vous devez gérer la taille et réussir à mettre à jour les index lorsque vous supprimez ou insérez au milieu de la liste.
Sauf si nécessaire, ou si vous faites de la programmation de très bas niveau, respectez l'interface List.
Lorsque nous connaissons exactement le nombre d'éléments et si cette valeur n'est pas modifiée, nous devrions utiliser array car il sera plus rapide. ArrayList est basé sur un tableau