[Note] Java: vitesse de traitement de la liste par objectif

introduction

Une collection est une boîte qui peut stocker plusieurs éléments tels que ʻArrayList et LinkedList. Cette fois, j'écrirai sur les deux collections suivantes. La réponse est écrite dans le livre de référence, mais je voudrais l'essayer par moi-même et en faire l'expérience. Si possible, comparez-le à la séquence. ・ ʻArrayList ・ LinkedList

Conclusion

L'addition est un peu plus rapide avec ʻArrayList. (LinkedList est également assez rapide) L'acquisition est beaucoup plus rapide avec ʻArrayList. La suppression est de loin la LinkedList la plus rapide.

Puisqu'il faut beaucoup de temps pour obtenir la LinkedList Lors de la création d'une liste avec acquisition, je pense que ʻArrayList` est bien.

Ajouter x Obtenir=> `ArrayList`
Ajouter x Supprimer=> `LinkedList`
Ajouter x Obtenir x Supprimer=> `ArrayList`

1, ajouter un élément

CompareList.java

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

public class CompareList {
    public static void main(String[] args) {
        //Commencer à mesurer le tableau
        long arrayStart = System.currentTimeMillis();
        //Préparation
        List<String> addArrayList = new ArrayList<String>();
        //Traitement supplémentaire
        for (int num = 0; num<1000000; num++) {
            addArrayList.add("élément");
        }
        //Fin de la mesure de arrayList
        long arrayEnd = System.currentTimeMillis();
        System.out.println("arrayList(ajouter à) : "+(arrayEnd - arrayStart)  + "ms");
        //Confirmer la quantité supplémentaire
        int arraylistSize = addArrayList.size();
        System.out.println(arraylistSize);

        //Commencer à mesurer linkedList
        long linkedStart = System.currentTimeMillis();
        //Préparation
        List<String> addLinkedList = new LinkedList<String>();
        //Traitement supplémentaire
        for (int num = 0; num<1000000; num++) {
            addLinkedList.add("élément");
        }
        //Fin de la mesure de linkedList
        long linkedEnd = System.currentTimeMillis();
        System.out.println("linkedList(ajouter à) : "+(linkedEnd - linkedStart)  + "ms");
        //Confirmer la quantité supplémentaire
        int linkedListSize = addLinkedList.size();
        System.out.println(linkedListSize);
    }
}

résultat.java

        arrayList(ajouter à) : 35ms
        1000000
        linkedList(ajouter à) : 259ms
        1000000

2, supprimer l'élément

CompareList.java

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

public class CompareList {
    public static void main(String[] args) {
        //Préparez une liste de 30000 éléments
        String elem = "elem";
        List<String> array30000elems = new ArrayList<String>();
        List<String> linked30000elems = new LinkedList<String>();
        for(int i = 0; i<300000; i++){
            array30000elems.add(elem);
            linked30000elems.add(elem);
        }

        //arrayList début de la mesure
        long arrayStart = System.currentTimeMillis();
        int num = 0;
        //Supprimer le processus
        while(array30000elems.size() > 0){
            num += 1;
            array30000elems.remove(elem);
        }
        System.out.println("temps de traitement: "+num+"Fois");
        long arrayEnd = System.currentTimeMillis();
        System.out.println("arrayList(Effacer) : "+(arrayEnd - arrayStart)  + "ms");

        //Démarrage de la mesure linkedList
        long linkedStart = System.currentTimeMillis();
        int num2 = 0;
        //Supprimer le processus
        while(linked30000elems.size() > 0){
            num2 += 1;
            linked30000elems.remove(elem);
        }
        System.out.println("temps de traitement: "+num2+"Fois");
        long linkedEnd = System.currentTimeMillis();
        System.out.println("linkedList(Effacer) : "+(linkedEnd - linkedStart)+"ms");
    }
        
}

résultat.java

temps de traitement:300 000 fois
        arrayList(Effacer) : 5387ms
temps de traitement:300 000 fois
        linkedList(Effacer) : 16ms

3, obtenir l'élément

CompareList.java

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

public class CompareList {
    public static void main(String[] args) {
        //Préparez une liste de 30000 éléments
        String elem = "elem";
        List<String> array30000elems = new ArrayList<String>();
        List<String> linked30000elems = new LinkedList<String>();
        for(int i = 0; i<300000; i++){
            array30000elems.add(elem);
            linked30000elems.add(elem);
        }

        //arrayList début de la mesure
        int count = 0;
        long arrayStart = System.currentTimeMillis();
        //Processus d'acquisition
        for(int i = 0; i < array30000elems.size(); i++){
            count += 1;
            array30000elems.get(i);
        }
        long arrayEnd = System.currentTimeMillis();
        System.out.println("arrayList(Avoir) : "+(arrayEnd - arrayStart)  + "ms");
        System.out.println("temps de traitement: "+count+"Fois");

        //Démarrage de la mesure linkedList
        int count2 = 0;
        long linkedStart = System.currentTimeMillis();
        //Processus d'acquisition
        for(int i = 0; i < linked30000elems.size(); i++){
            count2 += 1;
            linked30000elems.get(i);
        }
        long linkedEnd = System.currentTimeMillis();
        System.out.println("linkedList(Avoir) : "+(linkedEnd - linkedStart)  + "ms");
        System.out.println("temps de traitement: "+count2+"Fois");

    }
        
}

résultat.java

        arrayList(Avoir) : 7ms
temps de traitement:300 000 fois
        linkedList(Avoir) : 38475ms
temps de traitement:300 000 fois

4, combinaison d'ajout et de suppression

CompareList.java

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

public class CompareList {
    public static void main(String[] args) {
        String elem = "elem";

        List<String> samplelist = new ArrayList<String>();
        long start1 = System.currentTimeMillis();
        for(int i =0; i < 30000; i++){
            samplelist.add(elem);
        }
        System.out.println("Après l'addition: "+samplelist.size());
        while(samplelist.size() > 0){
            samplelist.remove(elem);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("arrayList(Ajouter supprimer) : "+(end1 - start1)  + "ms");
        System.out.println("Après suppression: "+samplelist.size());

        List<String> samplelist2 = new LinkedList<String>();
        long start2 = System.currentTimeMillis();
        for(int i =0; i < 30000; i++){
            samplelist2.add(elem);
        }
        System.out.println("Après l'addition: "+samplelist2.size());
        while(samplelist2.size() > 0){
            samplelist2.remove(elem);
        }
        long end2 = System.currentTimeMillis();
        System.out.println("linkedList(Ajouter supprimer) : "+(end2 - start2)  + "ms");
        System.out.println("Après suppression: "+samplelist2.size());
    }
        
}

résultat.java

Après l'addition: 30000
        arrayList(Ajouter supprimer) : 78ms
Après suppression: 0
Après l'addition: 30000
        linkedList(Ajouter supprimer) : 21ms
Après suppression: 0

5, combinaison d'ajout, d'acquisition et de suppression

CompareList.java

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

public class CompareList {
    public static void main(String[] args) {
        String elem = "elem";

        // arrayList
        List<String> samplelist = new ArrayList<String>();
        long start1 = System.currentTimeMillis();

        //300000 ajoutés
        for(int i =0; i < 300000; i++){
            samplelist.add(elem);
        }
        System.out.println("Après l'addition: "+samplelist.size());

        //Obtenez 300 000
        for(int i = 0; i < samplelist.size(); i++){
            samplelist.get(i);
        }
        //Sortie du temps nécessaire à l'acquisition supplémentaire
        long half1 = System.currentTimeMillis();
        System.out.println("arrayList(Acquisition supplémentaire) : "+(half1 - start1)  + "ms");

        //Supprimer 300 000
        while(samplelist.size() > 0){
            samplelist.remove(elem);
        }

        //Afficher le temps écoulé entre l'ajout et la suppression
        long end1 = System.currentTimeMillis();
        System.out.println("arrayList(Ajouter la suppression d'acquisition) : "+(end1 - start1)  + "ms");
        System.out.println("Après suppression: "+samplelist.size());


        // linkedList
        List<String> samplelist2 = new LinkedList<String>();
        long start2 = System.currentTimeMillis();

        //300000 ajoutés
        for(int i =0; i < 300000; i++){
            samplelist2.add(elem);
        }
        System.out.println("Après l'addition: "+samplelist2.size());

        //Obtenez 300 000
        for(int i = 0; i < samplelist2.size(); i++){
            samplelist2.get(i);
        }

        //Sortie du temps nécessaire à l'acquisition supplémentaire
        long half2 = System.currentTimeMillis();
        System.out.println("linkedList(Acquisition supplémentaire) : "+(half2 - start2)  + "ms");

        //Supprimer 300 000
        while(samplelist2.size() > 0){
            samplelist2.remove(elem);
        }

        //Afficher le temps écoulé entre l'ajout et la suppression
        long end2 = System.currentTimeMillis();
        System.out.println("linkedList(Ajouter la suppression d'acquisition) : "+(end2 - start2)  + "ms");
        System.out.println("Après suppression: "+samplelist2.size());
    }
        
}

résultat.java

Après l'addition: 300000
        arrayList(Acquisition supplémentaire) : 34ms
        arrayList(Ajouter la suppression d'acquisition) : 5152ms
Après suppression: 0
Après l'addition: 300000
        linkedList(Acquisition supplémentaire) : 37727ms
        linkedList(Ajouter la suppression d'acquisition) : 37745ms
Après suppression: 0