Java ArrayList vs Vector

1. Oversigt

I denne vejledning vi vil fokusere på forskellene mellem ArrayList og Vektor klasser. De hører begge til Java Collections Framework og implementerer java.util.List interface.

Imidlertid, disse klasser har betydelige forskelle i deres implementeringer.

2. Hvad er anderledes?

Lad os som en hurtig start præsentere de vigtigste forskelle i ArrayList og Vektor. Derefter diskuterer vi nogle af punkterne mere detaljeret:

  • synkronisering - Den første store forskel mellem disse to. Vektor er synkroniseret og ArrayList ikke er.
  • størrelsesvækst - En anden forskel mellem de to er den måde, de ændrer størrelse på, når de når deres kapacitet. Det Vektor fordobler størrelsen. I modsætning, ArrayList stiger kun med halvdelen af ​​dens længde
  • iteration - Og Vektor kan bruge Iterator og Optælling at krydse over elementerne. På den anden side, ArrayList kan kun bruge Iterator.
  • ydeevne - Stort set på grund af synkronisering, Vektor operationer er langsommere sammenlignet med ArrayList
  • ramme - Også ArrayList er en del af rammerne for samlinger og blev introduceret i JDK 1.2. I mellemtiden Vektor er til stede i de tidligere versioner af Java som en ældre klasse.

3. Vektor

Som vi allerede har en udvidet vejledning omArrayList, vi diskuterer ikke dets API og muligheder her. På den anden side præsenterer vi nogle kerneoplysninger om Vektor.

Kort fortalt, -en Vektor er en størrelse, der kan ændres. Det kan vokse og krympe, når vi tilføjer eller fjerner elementerne.

Vi kan oprette en vektor på typisk måde:

Vektorvektor = ny vektor ();

Standardkonstruktøren opretter en tom Vektor med en indledende kapacitet på 10.

Lad os tilføje et par værdier:

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

Og endelig, lad os gentage værdierne ved hjælp af Iterator grænseflade:

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

Eller vi kan krydse Vektor ved brug af Optælling:

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

Lad os nu udforske nogle af deres unikke funktioner mere dybtgående.

4. Samtidighed

Vi har allerede nævnt det ArrayList og Vektor er forskellige i deres samtidige strategi, men lad os se nærmere på. Hvis vi skulle dykke ned i Vektorer metodesignaturer, ser vi, at hver har det synkroniserede nøgleord:

offentlig synkroniseret E get (int-indeks)

Kort fortalt, dette betyder, at kun en tråd kan få adgang til en given vektor ad gangen.

Virkelig skal denne synkronisering på operationsniveau alligevel overlejres med vores egen synkronisering til sammensatte operationer.

Så i modsætning hertil ArrayList tager en anden tilgang. Dens metoder er ikke synkroniseret, og denne bekymring er opdelt i klasser, der er afsat til samtidighed.

For eksempel kan vi bruge CopyOnWriteArrayList eller Collections.synchronizedList at få en lignende effekt som Vektor:

vector.get (1); // synkroniseret Collections.synchronizedList (arrayList) .get (1); // også synkroniseret

5. Ydeevne

Som vi allerede diskuterede ovenfor, Vektor er synkroniseret, hvilket har en direkte indvirkning på ydeevnen.

For at se præstationsforskellen mellem Vektor imod ArrayList operationer, lad os skrive en simpel JMH benchmark test.

Tidligere har vi set på tidens kompleksitet af ArrayList'S operationer, så lad os tilføje testcases for Vektor.

Først, lad os teste få() metode:

@Benchmark offentlig Medarbejder testGet (ArrayListBenchmark.MyState-tilstand) {return state.employeeList.get (state.employeeIndex); } @Benchmark offentlig medarbejder testVectorGet (ArrayListBenchmark.MyState-tilstand) {return state.employeeVector.get (state.employeeIndex); }

Vi konfigurerer JMH til at bruge tre tråde og 10 opvarmnings-iterationer.

Og lad os rapportere om den gennemsnitlige tid pr. Operation på nanosekund-niveau:

Benchmark Mode Cnt Score Fejlenheder ArrayListBenchmark.testGet avgt 20 9.786 ± 1.358 ns / op ArrayListBenchmark.testVectorGet avgt 20 37.074 ± 3.469 ns / op

Det kan vi se ArrayList # få fungerer cirka tre gange hurtigere end Vector # få.

Lad os nu sammenligne resultaterne af indeholder() operation:

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

Og udskriv resultaterne:

Benchmark Mode Cnt Score Fejlenheder ArrayListBenchmark.testContains avgt 20 8.665 ± 1.159 ns / op ArrayListBenchmark.testContainsVector avgt 20 36.513 ± 1.266 ns / op

Som vi kan se, for indeholder() drift, ydelsestid for Vektor er meget længere end ArrayList.

6. Resume

I denne artikel har vi kigget på forskellene mellem Vektor og ArrayList klasser i Java. Derudover præsenterede vi også Vektor funktioner i flere detaljer.

Som sædvanlig er den komplette kode til denne artikel tilgængelig på GitHub.