Complexité temporelle des collections Java

The ArrayList in Java is backed by an array. Cela aide à comprendre la logique interne de sa mise en œuvre. Un guide plus complet pour lesArrayList est disponiblein this article.

Alors, concentrons-nous d'abord sur la complexité temporelle des opérations courantes, à un niveau élevé:

Cette implémentation de l'interfaceList estvery useful when working with multi-threaded applications. C'est thread-safe et bien expliqué dansthis guide here.

Voici l'aperçu de la notation Big-O des performances pourCopyOnWriteArrayList:

Comme nous pouvons le voir, l'utilisation de cette collection est très coûteuse en raison des caractéristiques de performance de la méthodeadd().

LinkedList is a linear data structure which consists of nodes holding a data field and a reference to another node. Pour plus de fonctionnalités et de capacités deLinkedList, jetez un œil àthis article here.

Présentons l'estimation moyenne du temps dont nous avons besoin pour effectuer certaines opérations de base:

Maintenant, pour prouver la théorie, jouons avec les données réelles. To be more precise, we’ll present the JMH (Java Microbenchmark Harness) test results of the most common collection operations.

Si vous n'êtes pas familier avec l'outil JMH, consultez ceuseful guide.

Dans un premier temps, nous présentons les principaux paramètres de nos tests de référence:

Ensuite, nous définissons le nombre d'itérations de préchauffage sur10. Nous souhaitons également voir la durée moyenne de nos résultats affichée en microsecondes.

Il est maintenant temps d’exécuter nos tests de performances. Tout d'abord, nous commençons par lesArrayList:

À l'intérieur de nosArrayListBenchmark, nous ajoutons la classeState pour contenir les données initiales.

Ici, nous créons unArrayList d'objetsEmployee. Après,we initialize it with 100.000 items inside of the setUp() method. The @State indicates that the @Benchmark tests have full access to the variables declared in it within the same thread.

Enfin, il est temps d’ajouter les tests de référence pour les méthodesadd(), contains(), indexOf(), remove(), etget():

Tous les résultats sont présentés en microsecondes:

From the results we can learn, that testContains() and testIndexOf() methods run in approximately the same time. Nous pouvons également clairement voir l'énorme différence entre les scores de la méthodetestAdd(), testGet() du reste des résultats. L'ajout d'un élément prend 2.296microsecondes et en obtenir un est une opération de 0,007 microseconde.

La recherche ou la suppression d'un élément coûte environ700 microsecondes. Ces nombres sont la preuve de la partie théorique, où nous avons appris queadd(), etget() ont une complexité temporelle deO(1) et les autres méthodes sontO(n). élémentsn=10.000 dans notre exemple.

De même, nous pouvons écrire les mêmes tests pour la collectionCopyOnWriteArrayList. Tout ce dont nous avons besoin est de remplacer lesArrayList dans employeeList par l'instanceCopyOnWriteArrayList.

Voici les résultats du test de référence:

Ici encore, les chiffres confirment la théorie. Comme nous pouvons le voir,testGet() s'exécute en moyenne en 0,006 ms que nous pouvons considérer commeO(1). Comparing to ArrayList, we also notice the significant difference between testAdd() method results. As we have here O(n) complexity for the add() method versus ArrayList’s O(1). 

We can clearly see the linear growth of the time, as performance numbers are 878.166 compared to 0.051.

Maintenant, il est temps deLinkedList:

Nous pouvons voir d'après les scores, que l'ajout et la suppression d'éléments dansLinkedList sont assez rapides.

En outre, il existe un écart de performances important entre les opérations d'ajout / suppression et d'obtention / contenance.

Montrons quelques chiffres réels. Tout d'abord, pour lesHashMap:

As we see, the numbers prove the O(1) constant time for running the methods listed above. Maintenant, faisons une comparaison des résultats du testHashMap avec les autres scores de l'instanceMap.

Pour toutes les méthodes répertoriées,we have O(1) for HashMap, LinkedHashMap, IdentityHashMap, WeakHashMap, EnumMap and ConcurrentHashMap.

Présentons les résultats des résultats des tests restants sous la forme d'un tableau:

À partir des nombres de sortie, nous pouvons confirmer les affirmations de complexité temporelle deO(1).

Pour l'arborescenceTreeMap and ConcurrentSkipListMap the put(), get(), remove(), containsKey()  operations time is O(log(n)).

[.pl-smi] # Ici,we want to make sure that our performance tests will run approximately in logarithmic time. Pour cette raison, nous initialisons les cartes avec n=1000, 10,000, 100,000, 1,000,000éléments en continu. #

Dans ce cas, nous nous intéressons au temps total d'exécution:

[.pl-smi] #Quandn=1000 nous avons le total du temps d'exécution de00:03:17 millisecondes. n=10,000 le temps est presque inchangé00:03:18 ms. n=100,000 a une augmentation mineure00:03:30. Et enfin, lorsquen=1,000,000, l'exécution se termine en00:05:27 ms. #

Après avoir comparé les nombres d'exécution avec la fonctionlog(n) de chaquen, nous pouvons confirmer que la corrélation des deux fonctions correspond.

Passons maintenant à nos tests de référence:

De plus, nous laissons les configurations de référence restantes en l'état.

Voyons le comportement du score d'exécution à l'exécution pour les élémentsHashSet etLinkedHashSet havingn = 1000; 10,000; 100,000.

Pour lesHashSet, , les nombres sont:

De même, les résultats pourLinkedHashSet sont:

Comme on le voit, les scores restent presque les mêmes pour chaque opération. De plus, lorsque nous les comparons avec les sorties de test deHashMap, elles se ressemblent également.

En conséquence, nous confirmons que toutes les méthodes testées fonctionnent en temps constantO(1).