Java ArrayList vs Vector

overzicht

in deze handleiding gaan we ons richten op de verschillen tussen de ArrayList-en Vectorklassen. Beide behoren tot het Java Collections Framework en implementeren de java.util.Lijst interface.

deze klassen hebben echter aanzienlijke verschillen in hun implementatie.

Wat is er anders?

als een snelle start, laten we de belangrijkste verschillen van ArrayList en Vector presenteren. Dan zullen we een aantal van de punten in meer detail te bespreken:

• synchronisatie – het eerste grote verschil tussen deze twee. Vector is gesynchroniseerd en ArrayList niet.
• grootte groei – een ander verschil tussen de twee is de manier waarop ze verkleinen terwijl ze hun capaciteit bereiken. De Vector verdubbelt zijn grootte. ArrayList neemt daarentegen slechts met de helft van zijn lengte
• iteratie toe – en Vector kan Iterator en Enumeratie gebruiken om over de elementen te reizen. Aan de andere kant kan ArrayList alleen Iterator gebruiken.
• performance-grotendeels te wijten aan synchronisatie, Vector operaties zijn langzamer in vergelijking met ArrayList
• framework-ook, ArrayList is een onderdeel van het Collections framework en werd geïntroduceerd in JDK 1.2. Ondertussen is Vector aanwezig in de eerdere versies van Java als een legacy class.

Vector

omdat we al een uitgebreide gids over ArrayList hebben, zullen we hier de API en mogelijkheden ervan niet bespreken. Aan de andere kant, zullen we enkele kerndetails presenteren over Vector.

simpel gezegd is een vector een aanpasbare array. Het kan groeien en krimpen als we de elementen toevoegen of verwijderen.

we kunnen een vector maken op een typische manier:

Vector<String> vector = new Vector<>();

de standaard constructor maakt een lege Vector met een initiële capaciteit van 10.

laten we een paar waarden toevoegen:

vector.add("baeldung");vector.add("Vector");vector.add("example");

en tot slot, laten we herhalen door de waarden met behulp van de Iterator-interface:

Iterator<String> iterator = vector.iterator();while (iterator.hasNext()) { String element = iterator.next(); // ...}

of we kunnen de Vector doorkruisen met Enumeratie:

Enumeration e = vector.elements();while(e.hasMoreElements()) { String element = e.nextElement(); // ... }

nu, laten we verkennen een aantal van hun unieke functies in meer diepte.

Concurrency

we hebben al gezegd dat ArrayList en Vector verschillend zijn in hun concurrency strategie, maar laten we eens een kijkje nemen. Als we zouden duiken in vector ‘ s methode handtekeningen, zouden we zien dat elk heeft het gesynchroniseerde trefwoord:

public synchronized E get(int index)

simpel gezegd betekent dit dat slechts één thread toegang heeft tot een bepaalde vector tegelijk.

eigenlijk moeten deze synchronisaties op operatieniveau toch worden overlayed met onze eigen synchronisatie voor samengestelde operaties.

in tegenstelling hiermee neemt ArrayList een andere benadering. De methoden zijn niet gesynchroniseerd en die zorg is verdeeld in klassen die zijn gewijd aan concurrency.

we kunnen bijvoorbeeld CopyOnWriteArrayList of Collecties gebruiken.synchronizedList om een vergelijkbaar effect te krijgen als Vector:

vector.get(1); // synchronizedCollections.synchronizedList(arrayList).get(1); // also synchronized

Performance

zoals we hierboven al hebben besproken, wordt Vector gesynchroniseerd, wat een directe invloed heeft op de performance.

om het prestatieverschil tussen vector Versus ArrayList operaties te zien, schrijven we een eenvoudige JMH benchmark test.

in het verleden hebben we gekeken naar de tijdscomplexiteit van de operaties van ArrayList, dus laten we de testcases voor Vector toevoegen.

eerst testen we de get () methode:

@Benchmarkpublic Employee testGet(ArrayListBenchmark.MyState state) { return state.employeeList.get(state.employeeIndex);}@Benchmarkpublic Employee testVectorGet(ArrayListBenchmark.MyState state) { return state.employeeVector.get(state.employeeIndex);}

we zullen JMH configureren om drie threads en 10 opwarm iteraties te gebruiken.

en, laten we rapporteren over de gemiddelde tijd per operatie op nanoseconde niveau:

Benchmark Mode Cnt Score Error UnitsArrayListBenchmark.testGet avgt 20 9.786 ± 1.358 ns/opArrayListBenchmark.testVectorGet avgt 20 37.074 ± 3.469 ns/op

we kunnen zien dat ArrayList # get ongeveer drie keer sneller werkt dan Vector # get.

laten we nu de resultaten van de opdracht bevat() vergelijken:

@Benchmarkpublic boolean testContains(ArrayListBenchmark.MyState state) { return state.employeeList.contains(state.employee);}@Benchmarkpublic boolean testContainsVector(ArrayListBenchmark.MyState state) { return state.employeeVector.contains(state.employee);}

en print de resultaten uit:

Benchmark Mode Cnt Score Error UnitsArrayListBenchmark.testContains avgt 20 8.665 ± 1.159 ns/opArrayListBenchmark.testContainsVector avgt 20 36.513 ± 1.266 ns/op

zoals we kunnen zien, is de prestatietijd voor Vector voor de operatie bevat () veel langer dan ArrayList.

samenvatting

In dit artikel hebben we gekeken naar de verschillen tussen de vector-en Arraylistklassen in Java. Daarnaast hebben we ook vectorfuncties in meer details gepresenteerd.

zoals gewoonlijk is de volledige code voor dit artikel beschikbaar op GitHub.