streamalism.org

1. Oversikt

I denne veiledningen, vi skal fokusere på forskjellene mellom ArrayList og Vector klasser. De tilhører begge Java Collections Framework og implementerer java.util.Liste grensesnitt.

Derimot, disse klassene har betydelige forskjeller i deres implementeringer.

2. Hva er annerledes?

Som en rask start, la oss presentere de viktigste forskjellene i ArrayList og Vector. Deretter vil vi diskutere noen av punktene mer detaljert:

• synkronisering - Den første store forskjellen mellom disse to. Vector er synkronisert og ArrayList ikke er det.
• størrelsesvekst - En annen forskjell mellom de to er måten de endrer størrelse på når de når kapasiteten. De Vector dobler størrelsen. I motsetning, ArrayList øker bare med halvparten av lengden
• iterasjon - Og Vector kan bruke Iterator og Oppregning å krysse over elementene. På den andre siden, ArrayList kan bare bruke Iterator.
• ytelse - Stort sett på grunn av synkronisering, Vector operasjonene går langsommere sammenlignet med ArrayList
• rammeverk - Også, ArrayList er en del av rammeverket for samlinger og ble introdusert i JDK 1.2. I mellomtiden, Vector er til stede i de tidligere versjonene av Java som en eldre klasse.

3. Vector

Som vi allerede har en utvidet guide omArrayList, vi vil ikke diskutere API-en og funksjonene her. På den annen side vil vi presentere noen kjernedetaljer om Vector.

For å si det enkelt, en Vector er en størrelse som kan endres. Den kan vokse og krympe når vi legger til eller fjerner elementene.

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

Vector vektor = ny Vector ();

Standardkonstruktøren oppretter en tom Vector med en innledende kapasitet på 10.

La oss legge til noen få verdier:

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

Og til slutt, la oss gjenta verdiene ved å bruke Iterator grensesnitt:

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

Eller vi kan krysse Vector ved hjelp av Oppregning:

Oppregning e = vector.elements (); while (e.hasMoreElements ()) {Strengelement = e.nextElement (); // ...}

La oss nå utforske noen av deres unike funksjoner i mer dybde.

4. Samtidighet

Vi har allerede nevnt det ArrayList og Vector er forskjellige i sin samtidige strategi, men la oss se nærmere på. Hvis vi skulle dykke inn i Vektorer metodesignaturer, vil vi se at hver har det synkroniserte nøkkelordet:

offentlig synkronisert E get (int-indeks)

For å si det enkelt, dette betyr at bare en tråd kan få tilgang til en gitt vektor om gangen.

Virkelig, skjønt, må denne synkroniseringen på operasjonsnivå legges uansett med vår egen synkronisering for sammensatte operasjoner.

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

For eksempel kan vi bruke CopyOnWriteArrayList eller Collections.synchronizedList å få en lignende effekt til Vector:

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

5. Ytelse

Som vi allerede har diskutert ovenfor, Vector er synkronisert som forårsaker en direkte innvirkning på ytelsen.

For å se ytelsesforskjellen mellom Vector mot ArrayList operasjoner, la oss skrive en enkel JMH referansetest.

Tidligere har vi sett på tidskompleksiteten til ArrayList'S operasjoner, så la oss legge til testtilfellene for Vector.

Først, la oss teste få() metode:

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

Vi konfigurerer JMH til å bruke tre tråder og 10 oppvarmings-iterasjoner.

Og la oss rapportere om gjennomsnittlig tid per operasjon på nanosekundnivå:

Referansemodus Cnt Score feilenheter ArrayListBenchmark.testGet avgt 20 9.786 ± 1.358 ns / op ArrayListBenchmark.testVectorGet avgt 20 37.074 ± 3.469 ns / op

Vi kan se det ArrayList # få fungerer omtrent tre ganger raskere enn Vector # get.

La oss nå sammenligne resultatene av inneholder () operasjon:

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

Referansemodus Cnt Score feilenheter 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 inneholder () drift, ytelsestiden for Vector er mye lenger enn ArrayList.

6. Sammendrag

I denne artikkelen så vi på forskjellene mellom Vector og ArrayList klasser i Java. I tillegg presenterte vi også Vector funksjoner i flere detaljer.

Som vanlig er den komplette koden for denne artikkelen tilgjengelig på GitHub.