Java ArrayList vs Vector

översikt

i denna handledning kommer vi att fokusera på skillnaderna mellan ArrayList-och Vektorklasserna. De tillhör båda Java Collections Framework och implementerar java.util.Lista gränssnitt.

dessa klasser har emellertid betydande skillnader i deras implementeringar.

Vad är annorlunda?

som en snabb start, låt oss presentera de viktigaste skillnaderna i ArrayList och vektor. Sedan diskuterar vi några av punkterna mer detaljerat:

• synkronisering – den första stora skillnaden mellan dessa två. Vector är synkroniserad och ArrayList är inte.
• storlekstillväxt – en annan skillnad mellan de två är hur de ändrar storlek medan de når sin kapacitet. Vektorn fördubblar sin storlek. Däremot ökar ArrayList endast med hälften av dess längd
• iteration – och Vector kan använda Iterator och uppräkning för att korsa över elementen. Å andra sidan kan ArrayList bara använda Iterator.
• prestanda-till stor del på grund av synkronisering är Vektoroperationerna långsammare jämfört med ArrayList
• framework – ArrayList är också en del av Samlingsramen och introducerades i JDK 1.2. Under tiden finns Vector i de tidigare versionerna av Java som en äldre klass.

Vector

eftersom vi redan har en utökad guide om ArrayList kommer vi inte att diskutera dess API och funktioner här. Å andra sidan presenterar vi några kärndetaljer om Vector.

enkelt uttryckt är en vektor en resizable array. Det kan växa och krympa när vi lägger till eller tar bort elementen.

vi kan skapa en vektor på typiskt sätt:

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

standardkonstruktören skapar en tom vektor med en initial kapacitet på 10.

Låt oss lägga till några värden:

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

och slutligen, låt oss iterera genom värdena genom att använda Iterator-gränssnittet:

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

eller vi kan korsa vektorn med uppräkning:

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

låt oss nu utforska några av deras unika egenskaper mer ingående.

samtidighet

vi har redan nämnt att ArrayList och Vector är olika i sin samtidighetsstrategi, men låt oss ta en närmare titt. Om vi skulle dyka in i Vectors metodsignaturer ser vi att var och en har det synkroniserade sökordet:

public synchronized E get(int index)

enkelt uttryckt betyder det att endast en tråd kan komma åt en given vektor åt gången.

egentligen måste dessa synkroniseringar på operationsnivå överlappas ändå med vår egen synkronisering för sammansatta operationer.

så däremot tar ArrayList ett annat tillvägagångssätt. Dess metoder är inte synkroniserade och denna oro separeras i klasser som ägnas åt samtidighet.

till exempel kan vi använda CopyOnWriteArrayList eller samlingar.synkroniseradlista för att få en liknande effekt som vektor:

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

prestanda

som vi redan diskuterat ovan synkroniseras vektorn vilket medför en direkt inverkan på prestanda.

för att se prestandaskillnaden mellan vektor kontra ArrayList-operationer, låt oss skriva ett enkelt JMH benchmark-test.

tidigare har vi tittat på tidskomplexiteten hos Arraylists verksamhet, så låt oss lägga till testfallen för Vector.

låt oss först testa 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 konfigurerar JMH för att använda tre trådar och 10 warmup-iterationer.

och, låt oss rapportera om den genomsnittliga tiden per operation på nanosekundnivå:

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 att ArrayList # get fungerar ungefär tre gånger snabbare än Vector # get.

låt oss nu jämföra resultaten av funktionen innehåller() :

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

och skriv ut resultaten:

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, för funktionen innehåller() är prestandatiden för Vector mycket längre än ArrayList.

sammanfattning

i den här artikeln tittade vi på skillnaderna mellan Vector-och ArrayList-klasserna i Java. Dessutom presenterade vi också Vektorfunktioner i mer detaljer.

som vanligt är den fullständiga koden för den här artikeln tillgänglig över på GitHub.