Java ArrayList versus Vector

1. Overzicht

In deze tutorial we gaan ons concentreren op de verschillen tussen de ArrayList en Vector klassen. Ze behoren allebei tot het Java Collections Framework en implementeren het java.util.List koppel.

Echter, deze klassen hebben significante verschillen in hun implementaties.

2. Wat is er anders?

Laten we om snel te beginnen de belangrijkste verschillen van ArrayList en Vector. Vervolgens bespreken we enkele punten in meer detail:

  • synchronisatie - Het eerste grote verschil tussen deze twee. Vector is gesynchroniseerd en ArrayList niet.
  • groottegroei - Een ander verschil tussen de twee is de manier waarop ze het formaat wijzigen terwijl ze hun capaciteit bereiken. De Vector verdubbelt de grootte. In tegenstelling tot, ArrayList neemt slechts met de helft van zijn lengte toe
  • iteratie - En Vector kan gebruiken Iterator en Opsomming om de elementen te doorkruisen. Aan de andere kant, ArrayList kan alleen gebruiken Iterator.
  • prestaties - grotendeels als gevolg van synchronisatie, Vector bewerkingen zijn langzamer in vergelijking met ArrayList
  • framework - Ook, ArrayList maakt deel uit van het Collections framework en werd geïntroduceerd in JDK 1.2. Ondertussen, Vector is aanwezig in de eerdere versies van Java als een legacy-klasse.

3. Vector

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

Simpel gezegd, een Vector is een array die kan worden aangepast. Het kan groeien en krimpen als we de elementen toevoegen of verwijderen.

We kunnen een vector op een typische manier maken:

Vectorvector = nieuwe vector ();

De standaardconstructor maakt een leeg Vector met een initiële capaciteit van 10.

Laten we een paar waarden toevoegen:

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

En tot slot, laten we de waarden doorlopen met behulp van de Iterator koppel:

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

Of we kunnen het Vector gebruik makend van Opsomming:

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

Laten we nu enkele van hun unieke kenmerken dieper bekijken.

4. Gelijktijdigheid

Dat hebben we al genoemd ArrayList en Vector verschillen in hun gelijktijdigheidsstrategie, maar laten we het eens nader bekijken. Als we erin zouden duiken Vector's methodehandtekeningen, zouden we zien dat elk het gesynchroniseerde trefwoord heeft:

openbare gesynchroniseerde E get (int index)

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

Echt, deze synchronisaties op bewerkingsniveau moeten hoe dan ook worden overlay met onze eigen synchronisatie voor samengestelde bewerkingen.

Dus in tegenstelling ArrayList heeft een andere benadering. De methoden zijn niet gesynchroniseerd en die zorg is onderverdeeld in klassen die zijn gewijd aan gelijktijdigheid.

We kunnen bijvoorbeeld gebruiken CopyOnWriteArrayList of Collections.synchronizedList om een ​​soortgelijk effect te krijgen als Vector:

vector.get (1); // gesynchroniseerde Collections.synchronizedList (arrayList) .get (1); // ook gesynchroniseerd

5. Prestaties

Zoals we hierboven al hebben besproken, Vector wordt gesynchroniseerd, wat een directe impact heeft op de prestaties.

Om het prestatieverschil tussen te zien Vector versus ArrayList bewerkingen, laten we een eenvoudige JMH-benchmarktest schrijven.

In het verleden hebben we gekeken naar de tijdcomplexiteit van ArrayList‘S operaties, dus laten we de testcases voor toevoegen Vector.

Eerste, laten we de krijgen() methode:

@Benchmark openbare Werknemer testGet (ArrayListBenchmark.MyState state) {return state.employeeList.get (state.employeeIndex); } @Benchmark openbare Werknemer testVectorGet (ArrayListBenchmark.MyState state) {return state.employeeVector.get (state.employeeIndex); }

We zullen JMH configureren om drie threads en 10 opwarmings-iteraties te gebruiken.

En laten we de gemiddelde tijd per operatie op nanoseconde niveau rapporteren:

Benchmarkmodus Cnt Score Fout Eenheden ArrayListBenchmark.testGet avgt 20 9.786 ± 1.358 ns / op ArrayListBenchmark.testVectorGet avgt 20 37.074 ± 3.469 ns / op

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

Laten we nu de resultaten van de bevat () operatie:

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

En print de resultaten uit:

Benchmarkmodus Cnt Score Fout Eenheden ArrayListBenchmark.testContains avgt 20 8.665 ± 1.159 ns / op ArrayListBenchmark.testContainsVector avgt 20 36.513 ± 1.266 ns / op

Zoals we kunnen zien, voor de bevat () operatie, de prestatie tijd voor Vector is veel langer dan ArrayList.

6. Samenvatting

In dit artikel hebben we de verschillen tussen de Vector en ArrayList klassen in Java. Daarnaast hebben we ook gepresenteerd Vector functies in meer details.

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