[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. ・ ʻArrayListLinkedList

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

Recommended Posts

[Note] Java: vitesse de traitement de la liste par objectif
[Note] Java: mesure la vitesse de concaténation de chaînes
Résumé du traitement des erreurs Java
[Java] Résumé de base de Java non couvert par Progate ~ Partie 2 ・ Liste ~
[Java] Comparaison de vitesse de combinaison de chaînes
[Java] Supprimer les éléments de la liste
Trier la liste des objets Java
[Java] DateTimeFormatter sortie par FormatStyle
[Note] Gestion des points décimaux Java
Liste des membres ajoutés dans Java 9
Traitement de flux d'inversion de liste Java étonnamment profond
Flux de traitement de base de Java Stream
Liste des types ajoutés dans Java 9
Connaissance de base de la rédaction de notes de développement Java
Liste des destinations de téléchargement pour Oracle Java
[Java] Notez comment utiliser RecyclerView et comment implémenter le traitement par balayage animé.
[Java] Contenu de l'interface de collection et de l'interface de liste
[Java] Appel de méthode dynamique par réflexion du type enum (enum)
Mémorandum Java (liste)
Clonez la liste Java.
Traitement des threads Java
Traitement des chaînes Java
[Introduction à Java] Liste des choses qui ont été capturées par le 14e jour de programmation
[Java] Traitement multi-thread
[Java] Présentation de Java
[Java] Traitement de flux
Analyse statistique simple du montant monétaire à partir de la liste recherchée par le développement Mercari Java
traitement itératif java
[Java] Résumé de base de Java non couvert par Progate ~ Partie 1 ~
Traitement des listes à comprendre avec des images - java8 stream / javaslang-
Obtenir une liste d'informations MBean pour les applications Java
Veuillez noter la division (division) de java kotlin Int et Int
Résumé des révisions (nouveaux problèmes de yuan) par version Java
Exemple d'implémentation d'un système de traitement LISP simple (version Java)
Le traitement Java 8 Stream peut être omis jusqu'à présent!
Traitement d'image: structure de base de l'image lue par le programme
Etude comparative de TLS Cipher Suite pris en charge par Java 8
Liste des instructions Java fréquemment utilisées (pour les débutants et les débutants)