Java ArrayList vs Vector

oversigt

i denne tutorial vil vi fokusere på forskellene mellem ArrayList og vektor klasser. De hører begge til Java-Samlingsrammen og implementerer java.util.Liste interface.

disse klasser har dog betydelige forskelle i deres implementeringer.

Hvad er anderledes?

som en hurtig start, lad os præsentere de vigtigste forskelle i ArrayList og vektor. Derefter vil vi diskutere nogle af punkterne mere detaljeret:

• synkronisering – den første store forskel mellem disse to. Vector er synkroniseret, og ArrayList er ikke.
• størrelsesvækst – en anden forskel mellem de to er den måde, de ændrer størrelse på, mens de når deres kapacitet. Vektoren fordobler sin størrelse. I modsætning hertil øges ArrayList kun med halvdelen af dens længde
• iteration – og vektor kan bruge Iterator og optælling til at krydse over elementerne. På den anden side kan ArrayList kun bruge Iterator.
• ydeevne – hovedsageligt på grund af synkronisering er Vektoroperationer langsommere sammenlignet med ArrayList
• ramme – også ArrayList er en del af Samlingsrammen og blev introduceret i JDK 1.2. I mellemtiden er Vector til stede i de tidligere versioner af Java som en arvsklasse.

Vector

da vi allerede har en udvidet guide om ArrayList, vil vi ikke diskutere dens API og kapaciteter her. På den anden side præsenterer vi nogle kernedetaljer om Vector.

kort sagt, en vektor er et array, 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:

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

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("example");

og endelig, lad os gentage gennem værdierne ved hjælp af iteratorgrænsefladen:

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

eller vi kan krydse vektoren ved hjælp af Enumeration:

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

lad os nu undersøge nogle af deres unikke funktioner mere dybtgående.

samtidighed

vi har allerede nævnt, at ArrayList og vektor er forskellige i deres samtidighedsstrategi, men lad os se nærmere på. Hvis vi skulle dykke ned i vektorens metodesignaturer, ville vi se, at hver har det synkroniserede søgeord:

public synchronized E get(int index)

kort sagt betyder det, 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 tager ArrayList en anden tilgang. Dens metoder er ikke synkroniseret, og denne bekymring er adskilt i klasser, der er afsat til samtidighed.

for eksempel kan vi bruge Tekstforfatterraylist eller samlinger.synkroniseret liste for at få en lignende effekt som Vector:

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

ydeevne

som vi allerede har diskuteret ovenfor, er Vector synkroniseret, hvilket medfører en direkte indvirkning på ydeevnen.

for at se præstationsforskellen mellem vektor versus Arraylistoperationer, lad os skrive en simpel JMH benchmark test.

tidligere har vi set på tidskompleksiteten af Arraylists operationer, så lad os tilføje testcases for Vector.

lad os først teste get () – metoden:

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

vi konfigurerer JMH til at bruge tre tråde og 10 opvarmninger.

og lad os rapportere om den gennemsnitlige tid pr. operation på nanosekundniveau:

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

vi kan se, at ArrayList # get fungerer cirka tre gange hurtigere end Vector#get.

lad os nu sammenligne resultaterne af funktionen indeholder ():

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

og udskrive resultaterne:

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

som vi kan se, for funktionen indeholder (), er præstationstiden for Vector meget længere end ArrayList.

Resume

i denne artikel kiggede vi på forskellene mellem vektor-og Arraylistklasserne i Java. Derudover præsenterede vi også vektorfunktioner i flere detaljer.

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