Java ArrayList vs Vector

Oversikt

i denne opplæringen skal vi fokusere på forskjellene Mellom ArrayList – og Vektorklassene. De tilhører Begge Java Collections Framework og implementerer java.util.Liste grensesnitt.

disse klassene har imidlertid betydelige forskjeller i deres implementeringer.

Hva Er Annerledes?

som en rask start, la oss presentere de viktigste forskjellene I ArrayList og Vektor. Deretter diskuterer vi noen av punktene mer detaljert:

• synkronisering – den første store forskjellen mellom disse to. Vektoren er synkronisert og ArrayList er ikke.
• størrelse vekst – en annen forskjell mellom de to er måten de endrer størrelse mens de når sin kapasitet. Vektoren dobler sin størrelse. ArrayList øker derimot bare med halvparten av lengden
• iterasjon – Og Vector kan bruke Iterator og Opplisting for å krysse over elementene. På Den annen side Kan ArrayList bare bruke Iterator.
• ytelse-Hovedsakelig på grunn av synkronisering, Vektoroperasjoner er tregere sammenlignet Med ArrayList
• framework-ArrayList er Også en del Av Collections framework og ble introdusert I JDK 1.2. I mellomtiden Er Vector til stede i Tidligere versjoner Av Java som en eldre klasse.

Vector

som vi allerede har en utvidet guide om ArrayList, diskuterer vi ikke API og evner her. På den annen side presenterer vi noen kjernedetaljer Om Vektor.

Enkelt Sagt, En Vektor er en resizable array. Det kan vokse og krympe når vi legger til eller fjerner elementene.

Vi kan lage en vektor på typisk måte:

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

standardkonstruktøren lager en tom Vektor med en innledende kapasitet på 10.

La oss legge til noen verdier:

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

og til slutt, la oss iterere gjennom verdiene ved å bruke Iteratorgrensesnittet:

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

Eller vi kan krysse Vektoren ved Hjelp Av Opplisting:

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

nå, la oss utforske noen av deres unike egenskaper i mer dybde.

Samtidighet

Vi har allerede nevnt At ArrayList og Vector er forskjellige i deres samtidighetsstrategi, men la oss ta en nærmere titt. Hvis vi skulle dykke inn I Vektorens metodesignaturer, ville vi se at hver har det synkroniserte søkeordet:

public synchronized E get(int index)

Enkelt sagt betyr dette at bare en tråd kan få tilgang til en gitt vektor om gangen.

Egentlig, men denne synkroniseringen på operasjonsnivå må overlayes uansett med vår egen synkronisering for sammensatte operasjoner.

så I kontrast tar ArrayList en annen tilnærming. Dens metoder er ikke synkronisert, og den bekymringen er skilt ut i klasser som er viet til samtidighet.

for eksempel kan Vi bruke CopyOnWriteArrayList Eller Samlinger.synchronizedList for å få en lignende effekt Til Vektor:

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

Ytelse

Som vi allerede diskuterte ovenfor, Er Vektor synkronisert som gir en direkte innvirkning på ytelsen.

For å se ytelsesforskjellen Mellom Vektor versus ArrayList operasjoner, la oss skrive en enkel jmh benchmark test.

tidligere har vi sett på tidskompleksiteten Til Arraylists operasjoner, så la oss legge til testtilfellene For Vector.

Først, la oss 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 vil konfigurere JMH å bruke tre tråder og 10 warmup iterasjoner.

og, la oss rapportere om gjennomsnittlig tid per operasjon på nanosekund nivå:

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 omtrent tre ganger raskere Enn Vektor # get.

la oss nå sammenligne resultatene av contains () – operasjonen:

@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 skrive ut resultatene:

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 contains () – operasjonen, er ytelsestiden For Vector mye lengre Enn ArrayList.

Sammendrag

i denne artikkelen så vi på forskjellene Mellom Vektor-og ArrayList-klassene I Java. I tillegg presenterte Vi Også Vektorfunksjoner i flere detaljer.

som vanlig er den komplette koden for denne artikkelen tilgjengelig over På GitHub.