Detalyadong pagsusuri ng klase ng ArrayList [Bahagi 1]

Ang artikulong ito ay magkakaroon ng isang detalyadong pagtingin sa klase ng ArrayList mula sa Collections Framework, na marahil ang pinakamadaling maunawaan, dahil sa katotohanan na ito ay batay sa isang regular na array. Halos tiyak na tatanungin ka tungkol sa klase na ito at sa pagpapatupad nito sa Java sa panayam. Sa ikalawang bahagi ay susuriin natin ang mga natitirang pamamaraan at isusulat ang sarili nating pagpapatupad ng isang dynamic na array para sa mga numero. Ang klase ng ArrayList ay nagmamana mula sa klase ng AbstractList at ipinapatupad ang mga sumusunod na interface: List, RandomAccess, Cloneable, Serializable. Isang detalyadong pagsusuri ng klase ng ArrayList [Bahagi 2] Ang klase ng ArrayList ay sumusuporta sa mga dynamic na array na maaaring palawakin kung kinakailangan. Ang pangangailangan at pagiging epektibo nito ay ipinaliwanag sa pamamagitan ng katotohanan na ang isang regular na array ay may isang nakapirming haba: kapag ito ay nilikha, hindi ito maaaring lumaki o lumiliit, na nagpapataw ng mga paghihigpit kung hindi alam kung gaano kalaki ang array na kakailanganin. Mahalaga, ang ArrayList class ay isang variable-length na hanay ng listahan ng mga object reference. Mahalagang maunawaan na ang laki (bilang ng mga cell) ng panloob na hanay ay hindi awtomatikong bumababa kapag ang mga elemento ay tinanggal mula dito. Sa katunayan, ang halaga ng variable size, na nagpapahiwatig ng bilang ng mga elemento na aktwal na naroroon sa array, ay nabawasan. Sabihin nating lumikha tayo ng bagong object ng klase ng ArrayList at magdagdag ng 5 elemento dito. Bilang default, isang hanay ng 10 elemento ang nilikha. Sa kasong ito, ang tinatawag na kapasidad (laki/volume) ng ating bagay ay magiging katumbas ng 10, ngunit ang halaga ng variable sizeay magiging katumbas ng lima. At kapag nagtanggal kami ng mga elemento, nakikita namin ang mga pagbabago sa halaga ng variable size, dahil .lengthhindi namin ma-access ang panloob na hanay ng klase ng ArrayList at malaman ang haba nito. Maaaring bawasan ang laki gamit ang karagdagang paraan trimToSize(), na tatalakayin sa ibaba. Tingnan natin ang mga patlang ng klase.

• Field na responsable para sa default na volume ng dynamic na array:

  private static final int DEFAULT_CAPACITY = 10

  Kapag lumilikha ng isang bagong bagay na bagong ArrayList<>() (tagabuo na walang mga parameter), isang hanay ng 10 elemento ay nilikha sa loob.

• Isang field kung saan nakaimbak ang lahat ng elemento ng koleksyon:

  transient Object[] elementData

  Minarkahan ng isang keyword transient- ang field ay hindi nakasulat sa byte stream kapag ginagamit ang karaniwang serialization algorithm. Kapansin-pansin na ang field ay hindi minarkahan ng keyword private, ngunit ginawa ito upang mapadali ang pag-access sa field na ito mula sa mga nested na klase (halimbawa, SubList).

• Isang counter field na nag-iimbak ng bilang ng mga elemento na aktwal sa array:

  private int size

  Ang halaga ay dinaragdagan/binababa kapag nagsasagawa ng mga operasyon gaya ng pagpasok at pagtanggal.

Mayroong 3 higit pang mga patlang sa klase, ngunit mahalagang mga ito ay karagdagang, kaya walang saysay na isaalang-alang ang mga ito. Ang klase ay may tatlong constructor:

1. public ArrayList()- lumilikha ng isang walang laman na hanay ng listahan ng 10 elemento;
2. public ArrayList(Collection < ? extends E > c)– lumilikha ng isang hanay ng listahan na sinimulan ng mga elemento mula sa naipasa na koleksyon (kung gusto nating lumikha ng bagong ArrayList batay sa ilang koleksyon);
3. public ArrayList(int initialCapacity)– lumilikha ng isang hanay ng listahan na may paunang kapasidad. Kung ang naipasa na parameter initialCapacity ay mas malaki kaysa sa 0, pagkatapos ay isang array ng tinukoy na laki ay nilikha (ang panloob na field elementData ay itinalaga ng isang link sa isang bagong array ng uri Object ng laki initialCapacity). Kung ang parameter ay 0, pagkatapos ay isang walang laman na array ay nilikha. Kung ang tinukoy na parameter ay mas mababa sa 0, pagkatapos ay itatapon ang isang IllegalArgumentException.

Paglikha ng isang Bagay

List < String> list = new ArrayList<>();

Ang bagong likhang bagay listay naglalaman ng mga katangian (mga patlang) elementDataat size. Ang isang value store elementDataay hindi hihigit sa isang array ng isang partikular na uri (tinukoy sa generic – <>), sa aming kaso String[]. Kung ang isang constructor na walang mga parameter ay tinatawag, pagkatapos ay sa pamamagitan ng default isang array ng 10 mga elemento ng uri Object ay malilikha (na may isang cast sa uri, siyempre). Pagdaragdag ng mga elemento Ang klasikong pagdaragdag ng mga elemento sa isang list array ay ginagawa gamit ang mga overloaded na variant ng add().

public boolean add(E элемент)

Buweno, idagdag natin: list.add("0"); Sa loob ng pamamaraang ito, ang isang overloaded na bersyon ng pamamaraan ay add()tinatawag, na minarkahan bilang private, na kung saan ay tumatagal ng tatlong parameter bilang input: ang elementong idaragdag, ang panloob na hanay at ang laki nito. Sa pribadong paraan, may tseke na nangyayari: kung ang naipasa na parameter ng laki ay katumbas ng haba ng panloob na hanay (iyon ay, ang array ay puno), pagkatapos ay ang array ay itinalaga ang resulta ng pamamaraan grow(int minCapacity)(ang kasalukuyang halaga ng field Ang laki + 1 ay ipinapasa sa pamamaraan, dahil kinakailangang isaalang-alang ang elementong idinaragdag), kung saan ang panloob na array ay itinalaga ng isang link sa bagong nilikha na array na nakuha sa pamamagitan ng pagkopya sa mga elemento ng orihinal na array:

Arrays.copyOf(elementData, newCapacity(minCapacity))

Bilang pangalawang parameter ng pamamaraan, copyOfipinapahiwatig namin ang resulta ng pamamaraan newCapacity(int minCapacity), kung saan kinakalkula ang bagong laki ng array. Kinakalkula ito gamit ang sumusunod na formula: int newCapacity = oldCapacity + (oldCapacity >> 1) Para sa isang array na may default na laki, ang mga sumusunod ay magiging totoo: >> 1– bitwise shift sa kanan ng isa (isang operator na binabawasan ang isang numero sa kalahati nito). Sa esensya, nangangahulugan ito ng paghahati ng 2 sa kapangyarihan ng 1. Lumalabas na hinahati natin ang 10 sa 2 at idinagdag ang 10. Sa kabuuan, ang bagong kapasidad ng array ay 15, ngunit dahil idinaragdag natin ang ika-11 elemento, pagkatapos ay 15 + 1 = 16. Bumalik tayo sa ating listahan at ipagpalagay na nakapagdagdag na tayo ng 10 elemento dito at subukang magdagdag ng 11. Ipapakita ng tseke na walang puwang sa array. Alinsunod dito, ang isang bagong array ay nilikha at tinatawag na Arrays.copyOf, na panloob na gumagamit ng system method System.arraycopy(). O narito ang isang malinaw na halimbawa mula sa isang artikulo sa JavaRush: Pagkatapos ng lahat ng mga pagsusuring ito at pagdaragdag ng laki ng array kung kinakailangan, pagkatapos ay sa isang pribadong paraan, add()isang bagong elemento ang idinaragdag sa dulo ng array, at ang kasalukuyang parameter sizeay nadagdagan ng isa . Ang lumang hanay ay pagkatapos ay ipoproseso ng tagakolekta ng basura. Ganito gumagana ang isang dynamic na array: kapag nagdagdag kami ng mga elemento, tinitingnan namin kung may puwang pa rito. Kung may espasyo, idagdag lang namin ang elemento sa dulo ng array. Ang dulo ay hindi nangangahulugang ang huling cell sa array, ngunit ang cell na tumutugma sa halaga size. Idinagdag namin ang unang elemento sa array; inilalagay ito sa cell na may index [0]. Ang halaga ng patlang sizeay tumaas ng isa at = 1. Idinagdag namin ang susunod na elemento: nakikita namin na size = 1, ayon dito ay inilalagay namin ang elemento sa cell na may index [1] at iba pa. Mayroong overloaded na bersyon ng pamamaraan na may dalawang parameter:

public void add(int index, E element)

Maaari naming tukuyin ang posisyon (index) ng cell kung saan gusto naming idagdag ang elemento. Una, sinusuri ang kawastuhan ng tinukoy na halaga ng index, dahil may posibilidad na matukoy ang isang maling index, na magtuturo sa isang cell kung saan walang anuman, o kung saan ay wala. Sinusuri ang mga index: index > size || index < 0– kung ang tinukoy na index ay mas malaki kaysa sa kasalukuyang laki ng array o ito ay mas mababa sa 0, pagkatapos ay isang exception ang itinapon IndexOutOfBoundsException. Pagkatapos, kung kinakailangan, ang laki ng array ay tataas, katulad ng halimbawa sa itaas. Marahil ay narinig mo na sa panahon ng pagdaragdag/pag-alis ng mga pagpapatakbo sa isang array, may naililipat sa isang lugar (sa kanan man o sa kaliwa). Kaya, ang paglilipat ay isinasagawa sa pamamagitan ng pagkopya ng array: System.arraycopy(elementData, index, elementData, index + 1, s - index); Ang lahat ng mga elemento na matatagpuan sa kanan ng tinukoy na index ay ililipat ng isang posisyon sa kanan (index+1). At pagkatapos lamang na ang isang bagong elemento ay idinagdag sa panloob na hanay sa tinukoy na index. Dahil inilipat namin ang bahagi ng array sa kanan ng isa (isang bagong array ay hindi nilikha), ang cell na kailangan namin ay libre para sa pagsusulat. Ang link sa lumang hanay ay nabura at sa hinaharap ay kukunin ito ng tagakolekta ng basura. Idikit ang "maserati" sa cell [3], na inookupahan na: Kaya, kapag ang isang elemento ay ipinasok sa index at walang mga libreng puwang sa array, ang tawag System.arraycopy()ay mangyayari nang dalawang beses: ang una sa grow(), ang pangalawa sa mismong pamamaraan add(index, value), na malinaw na makakaapekto sa bilis ng buong operasyon ng pagdaragdag. Bilang isang resulta, kapag kinakailangan na magsulat ng isa pang elemento sa panloob na hanay, ngunit walang puwang doon, kung gayon ito ang mangyayari sa loob ng ArrayList:

• Ang isang bagong array ay nilikha na may sukat na 1.5 beses na mas malaki kaysa sa orihinal, kasama ang isang elemento.
• Ang lahat ng mga elemento mula sa lumang array ay kinopya sa bagong array
• Ang bagong array ay naka-imbak sa panloob na variable ng ArrayList object, at ang lumang array ay idineklara na basura.

Ang kapasidad ng mga bagay ng uri ng ArrayList ay maaaring manu-manong dagdagan gamit ang pamamaraan:

public void ensureCapacity(int minCapacity)

Sa pamamagitan ng pagpapataas ng kapasidad ng array nang maaga, maiiwasan mo ang karagdagang muling pamamahagi ng RAM sa ibang pagkakataon. Pinapataas ng pamamaraan ang laki ng panloob na hanay upang mapaunlakan ang bilang ng mga elementong ipinasa sa minCapacity. Ang pamamaraan ensureCapacity()ay hindi nakakaapekto sa field size, ito ay nakakaapekto sa capacity(laki ng) panloob na array. Muli kong binibigyang-diin na ang sizedalawa ay capacitymagkaibang bagay at napakahalaga na huwag malito ang mga ito! Kung gusto mong bawasan ang laki ng pinagbabatayan na hanay kung saan binuo ang ArrayList sa kasalukuyang bilang ng mga elementong aktwal na nakaimbak, dapat mong tawagan ang trimToSize(). Pagkatapos mag-alis ng mga elemento mula sa koleksyon, size()ipapakita nito ang bilang ng aktwal na umiiral na mga elemento, at capacityhindi bababa! Ipagpalagay na: nagpasok kami ng 100 elemento, tinanggal ang unang 50, sizemagiging katumbas ito ng 50, at sa gayon capacityay mananatili itong 100. Upang bawasan at capacity, kailangan naming gamitin ang paraan trimToSize(), na nag-aayos ng aming buong kapasidad sa kasalukuyang laki. Paano ito magkasya? Kinokopya ang aming array upang walang mga walang laman na cell na natitira (ang haba ng bagong array ay katumbas lang ng laki ng field). Maaari ka ring magdagdag ng mga elemento sa aming koleksyon gamit ang addAll.

public boolean addAll(Collection< ? extends E> c)
public boolean addAll(int index, Collection< ? extends E> collection);

Ang unang opsyon ay nagbibigay-daan sa iyo upang idagdag ang lahat ng mga elemento mula sa koleksyon na tinukoy sa parameter ng pamamaraan (halimbawa, isa pang sheet) sa orihinal na koleksyon (insert sa dulo) kung saan ginawa ang method call. Ang naipasa na koleksyon (maaari din itong isang set) ay na-convert sa isang array gamit ang toArray(). Naturally, ang pagdaragdag ng operasyon ay isinasagawa din gamit ang pagkopya. Ang pangalawa ay idagdag ang lahat ng elemento collectionsa listahan, simula sa index index. Sa kasong ito, lahat ng elemento ay lilipat sa kanan sa pamamagitan ng bilang ng mga elemento sa listahan collection. Pag-alis ng mga elemento Una, tingnan natin ang mga klasikong opsyon para sa pag-alis ng mga elemento mula sa isang ArrayList.

public E remove(int index)

Nagsasagawa ng pagtanggal sa pamamagitan ng index at inililipat ang lahat ng kasunod (pagkatapos ng elemento sa tinukoy na index) na mga elemento sa kaliwa, at sa gayon ay isinasara ang "mga butas". Ibinabalik din nito ang tinanggal na elemento (E), na dati ay isinulat sa isang karagdagang variable bago ang pagtanggal, ang halaga na nakuha natin bilang resulta ng method call. Upang maunawaan kung ano ang E, kakailanganin mong maging pamilyar sa tinatawag na mga generic na uri. Ang notasyong E ay nagpapahiwatig na ang pamamaraan ay nagbabalik ng uri ng data na tinukoy sa paggawa ng ArrayList object (tandaan: List <String> list, nang naaayon, sa kasong ito, ang E ay "papalitan" String). Para sa pangkalahatang pag-unawa, lubos kong inirerekumenda na pamilyar ka sa mga generic na uri. Ang katumpakan ng ipinasok na index ay nasuri, at pagkatapos ay sa loob ng pamamaraan, ang elemento ay hindi ganap na natanggal, ngunit isang pribadong paraan ang tinatawag na fastRemove(Object[] es, int i), kung saan ang pagtanggal ay nangyayari na. Ipinapasa namin ang aming array at ang tinukoy na index sa pamamaraan bilang input. Ang mga elemento ay kinopya gamit ang System.arraycopy(), ang laki ng array ay binabawasan, at pagkatapos ay itinalaga namin ang null sa huling elemento. Dapat tandaan na ang isang bagong array ay hindi nilikha: System.arraycopy(es, i + 1, es, i, size - 1 - i); Ang bahagi na nasa kanan ng posisyon sa ilalim ng tinukoy na index (i+1) ay kinopya sa aming orihinal na array (es), at ito ay matatagpuan simula sa mismong posisyon. (i) kung saan matatagpuan ang elemento na tatanggalin. Kaya, nagsagawa kami ng shift sa kaliwa at binura ang aming elemento. Subukan nating tanggalin ang elemento sa index 3 mula sa array sa ibaba: Isaalang-alang natin ang pangalawang bersyon ng pamamaraan:

public boolean remove(Object o)

Inaalis ng pamamaraan ang naipasa na elemento mula sa listahan o, o mas tiyak, ang bagay sa tinukoy na link. Kung ang isang elemento ay naroroon sa listahan, ito ay aalisin at ang lahat ng mga elemento ay inilipat sa kaliwa. Kung ang elemento ay umiiral sa listahan at matagumpay na naalis, ang pamamaraan ay nagbabalik ng totoo; kung hindi, mali. Katulad ng opsyon sa pagtanggal sa pamamagitan ng index, ang pamamaraan ay tinatawag na fastRemove(), kung saan ang eksaktong parehong mga aksyon ay nangyayari. Ang pagkakaiba ay ang paraan ay remove(Object o)karagdagang naghahanap para sa nais na bagay sa pamamagitan ng isang paraan equals()ng klase ng Bagay. Kapag nag-aalis ayon sa halaga, ang loop ay dumadaan sa lahat ng elemento ng listahan hanggang sa makahanap ng tugma. Tanging ang unang elementong natagpuan ang tatanggalin. Ibuod natin: kapag nagtatanggal ng mga elemento mula sa isang dynamic na array, walang mga butas na natitira tulad ng sa isang regular na array (ang tinanggal na cell ay hindi magiging walang laman). Ang lahat ng kasunod na elemento (na nasa kanan ng index) ay inilipat sa isang posisyon sa kaliwa. Mayroong ilang mga karagdagang pamamaraan na maaaring magamit upang alisin ang mga elemento mula sa listahan sa iba't ibang antas. Tingnan natin sila sa madaling sabi. Nililinis ang aming koleksyon:

public void clear()

Ang isang simpleng loop foray umuulit sa lahat ng mga elemento ng isang array, na nagtatalaga ng null sa bawat elemento. Maaari mong alisin ang mga elementong iyon mula sa aming koleksyon na nasa isa pang inilipat na koleksyon tulad nito:

public boolean removeAll(Collection< ?> c)

Kung kailangan mong mag-alis ng ilang elemento, malamang na hindi mo ito dapat gawin sa isang conditional loop: mas maginhawa at mas ligtas na gamitin ang paraan removeAll(). Tumatanggap ito ng koleksyon ng mga elemento na aalisin sa listahan. Ang koleksyon ay dapat maglaman ng mga elemento ng parehong uri na iniimbak ng listahan ng target. Kung hindi ay itatapon ito ClassCastException. Magbabalik ng totoo ang pamamaraan kung binago ang listahan bilang resulta ng tawag sa pamamaraan. Inaalis ang mga elementong hindi kabilang sa naipasa na koleksyon:

public boolean retainAll(Collection< ?> c)

Sabihin nating mayroon tayong koleksyon:

List< String> listFirst = new ArrayList<>();
listFirst.add("White");
listFirst.add("Black");
listFirst.add("Red");

At ang pangalawa:

List< String> listSecond = new ArrayList<>();
listSecond.add("Green");
listSecond.add("Red");
listSecond.add("White");

Pagkatapos pagkatapos listSecond.retainAll(listFirst)ay listSecondmananatili:

"White"
"Red"

Dahil ang "Berde" ay inalis, na wala sa listFirst. Ngunit pagkatapos nito ay mananatili listSecond.removeAll(listFirst)ito :listSecond

"Green"
Удалorсь все элементы, которые есть в listFirst.

Hindi kabilang sa naipasa na koleksyon - nangangahulugan na kung may mga elemento na wala sa naipasa na koleksyon, kailangan mong alisin ang mga ito mula sa una (kung saan inilapat ang pamamaraan). Nabibilang sa inilipat na koleksyon - nang naaayon, kung mayroong isang elemento sa una at pangalawa (inilipat) na mga koleksyon, pagkatapos ay ang duplicate mula sa una ay nawasak.

protected void removeRange(int fromIndex, int toIndex)

Inaalis mula sa listahan ang lahat ng elemento na nasa pagitan ng panimulang tinukoy na index (kabilang) at ang pagtatapos na tinukoy na index (hindi kasama). Kapansin-pansin na ang pamamaraan ay hindi matatawag nang direkta sa isang ArrayList object. Upang magamit ito kailangan mong magmana mula sa AbstractList/ArrayList. Ang pamamaraan ay ginagamit din ng isa pang pamamaraan (subList, na tatalakayin sa ibang pagkakataon).

public boolean removeIf(Predicate< ? super E> filter)

Tinatanggal ang mga elemento mula sa isang koleksyon batay sa isang ibinigay na panaguri. Ang predicate mismo ay isang tiyak na function/algorithm/kondisyon na batayan kung saan ang isa o higit pang mga elemento na tumutugma sa isang partikular na kundisyon ay aalisin. Predicate— isang functional na interface (naglalaman lamang ng isang paraan, kaya maaari itong magamit bilang isang lambda), gumagana sa prinsipyong "nakatanggap ng isang parameter - ibinalik ang boolean". Sa esensya, ang pamamaraan ay nag-o-override sa pagpapatupad mula sa interface Collectionat nagpapatupad ng sumusunod na "diskarte": umuulit ito sa mga elemento at minarkahan ang mga tumutugma sa aming Predicate; pagkatapos ay tatakbo ito sa pangalawang pagkakataon upang alisin (at ilipat) ang mga elemento na minarkahan sa unang pag-ulit. Magpatupad tayo ng interface Predicatena magbabalik ng true kung magkapantay ang dalawang object:

class SamplePredicate< T> implements Predicate< T>{
  T varc1;
  public boolean test(T varc){
     if(varc1.equals(varc)){
       return true;
  }
  return false;
  }
}

Sa isa pang klase, gumawa tayo ng ArrayList mula sa Stringat isang object ng ating klase na nagpapatupad ng Predicate:

ArrayList< String> color_list = new ArrayList<> ();
SamplePredicate< String> filter = new SamplePredicate<> ();

varc1Isulat natin ang value na "White" sa variable :

filter.varc1 = "White";

Magdagdag tayo ng ilang linya sa listahan:

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

Ipatupad natin ang pamamaraan sa list removeIf, kung saan ipapasa natin ang ating object na may kondisyon:

color_list.removeIf(filter);

Bilang resulta, ang lahat ng row na may value na "Puti" ay aalisin sa listahan, dahil ang aming "predicate" ay ikinukumpara ang mga ito para sa pagkakapantay-pantay. Panghuling listahan: [Itim, Pula, Dilaw]. Pagpapalit ng mga elemento

public E set(int index, E element)

Pinapalitan ang elemento sa tinukoy na posisyon indexng nakapasa element. Ang index ay dapat ding mas malaki kaysa sa zero at mas mababa sa index ng huling elemento, kung hindi, isang exception ang itatapon IndexOutOfBoundsException. Walang mga kopya ng panloob na array na nagaganap. Simple lang, sa halip na ang elemento sa tinukoy na index, isang bagong elemento ang ipinapasok, i.e. i-overwrite ang halaga.

public void replaceAll(UnaryOperator<e> operator)

Binabago ang lahat ng elemento ng koleksyon (posibleng may kundisyon). Kadalasang ginagamit sa kumbinasyon ng mga lambdas o isang hindi kilalang klase (ngunit para sa kalinawan, sa halimbawa ay gagamit lang kami ng isang klase na nagpapatupad ng interface) na nagpapatupad ng interface UnaryOperatorat tumutukoy sa mga pamamaraan nito. Ipatupad natin ang interface:

class MyOperator< T> implements UnaryOperator< T>{
   T varc1;
   public T apply(T varc){
     return varc1;
  }
}

Sa isa pang klase, gumawa tayo ng ArrayList mula sa Stringat isang object ng ating klase na nagpapatupad ng UnaryOperator:

ArrayList< String> color_list = new ArrayList<> ();
MyOperator< String> operator = new MyOperator<> ();

varc1Isulat natin ang value na "White" sa variable :

operator.varc1 = "White";

Magdagdag tayo ng ilang linya sa listahan:

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

Magsagawa tayo ng isang paraan sa listahan replaceAllkung saan ipapasa natin ang ating object operator:

color_list.replaceAll(operator);

Bilang resulta, ang lahat ng mga halaga sa listahan ay pinalitan ng "Puti": [Puti, Puti, Puti, Puti, Puti, Puti]. At ito ay kung paano, halimbawa, maaari mong alisin ang lahat ng mga puwang mula sa mga string na nasa koleksyon:

ArrayList< String> list = new ArrayList<>(Arrays.asList("A   ", "  B  ", "C"));
list.replaceAll(String::trim);

Iba pang mga pamamaraan: Maaari mong i-convert ang ArrayList list array sa isang regular na array gamit ang pamamaraan:

public Object[] toArray()

o

public < T> T[] toArray(T[] a)

- dito ang uri ng ibinalik na array ay tinutukoy sa runtime Paraang ito ay magbibigay-daan:

1. pabilisin ang ilang mga operasyon;
2. magpasa ng array bilang parameter sa isang paraan na hindi na-overload para direktang tanggapin ang koleksyon;
3. Pagsasama ng bagong code na nakabatay sa koleksyon sa legacy na code na hindi kumikilala sa mga koleksyon.

Ibalik ang isang kopya ng object ng array:

public Object clone()

Pakitandaan na clone()ibinabalik ng pamamaraan ang uri ng Bagay, kaya pagkatapos itong tawagan ay kakailanganin mong mag-cast sa kinakailangang klase. Ang pag-clone ay lumilikha ng isang bagong independiyenteng bagay. Suriin ang koleksyon para sa pagkakaroon ng isang bagay:

public boolean contains(Object o)

Sinusuri ang presensya ng isang bagay sa listahan (internal na gumagamit ng katumbas na paraan ng klase ng Bagay, ibig sabihin, naghahambing ng mga sanggunian), nagbabalik ng totoo/mali depende sa resulta. Bilang karagdagan sa karaniwang mga loop, maaari kang umulit sa pamamagitan ng (i-access ang bawat elemento, pati na rin magsagawa ng ilang aksyon) isang koleksyon gamit ang:

public void forEach(Consumer< ? super E> action)

Ito ay kung paano namin maipapakita ang aming listahan:

List< Integer> numbers = new ArrayList<>(Arrays.asList(10, 20, 50, 100, -5));
numbers.forEach((number)-> System.out.println(number));

Nang hindi gumagamit ng lambdas kailangan mong gumamit ng hindi kilalang klase at i-override ang paraan ng acceptinterface Consumer:

numbers.forEach(new Consumer< Integer>() {
  @Override
   public void accept(Integer integer) {
      System.out.println(integer);
          }
});

Kumuha ng isang elemento sa pamamagitan ng index nito:

public E get(int index)

Ginagamit para sa random na pag-access sa mga elemento ng koleksyon. Ibinabalik ang elementong matatagpuan sa listahan sa tinukoy na index. Kung index < 0o index >=ang maximum na bilang ng mga elemento sa listahan, isang pagbubukod ang itatapon IndexOutOfBoundsException. Ito ang pangunahing paraan ng pagkuha ng isang elemento mula sa isang listahan, at ang oras upang makuha ang isang elemento sa pamamagitan ng index ay palaging magiging pareho, anuman ang laki ng ArrayList, dahil ina-access nito ang isang partikular na array cell. Paghahanap ng mga index para sa mga tinukoy na bagay:

public int indexOf(Object o);
public int lastIndexOf(Object o);

Ang mga pamamaraan ay nagbabalik ng index ng una (kapag ang ibinigay na bagay ay unang nakatagpo) o huling pangyayari (kapag ang ibinigay na bagay ay huling nakatagpo) na elemento sa listahan. Kung ang elemento ay hindi umiiral sa listahan, ang mga pamamaraan ay babalik -1. Suriin ang koleksyon para sa mga elemento:

public boolean isEmpty();

Ang pamamaraan ay nagbabalik ng totoo kung ang listahan ay walang laman (tumingin upang makita kung ang patlang ay pantay size 0), kung hindi man ay mali. Kung ang listahan ay naglalaman lamang ng mga null na elemento, ang pamamaraan ay magbabalik ng mali. Sa madaling salita, ang mga null na elemento ay isinasaalang-alang din ng pamamaraang ito. Alamin ang bilang ng mga elemento sa isang listahan:

public int size();

Ibinabalik ang bilang ng mga elemento sa listahan (mga halaga ng field ng laki). Ang bilang ng mga elemento ay maaaring mag-iba sa listahan ng kapasidad (kapasidad). Kumuha ng iterator para sa isang listahan:

public Iterator< E> iterator();

Ibinabalik ang isang iterator para sa isang listahan para magamit sa ibang pagkakataon sa isang loop o anumang iba pang pagproseso. Ang iterator ay nagpapatupad ng mabilis na pag-uugali. Kung ito ay tumatakbo sa koleksyon at napansin ang ilang mga pagbabago dito (na hindi nakuha gamit ang mga pamamaraan ng iterator), agad itong naghagis ng isang pagbubukod ConcurrentModificationException. Ang iterator ay may tinatawag na modification count. Kapag umuulit ang iterator sa koleksyon pagkatapos ng bawat next/hasNext/remove, sinusuri nito ang counter na ito. Kung hindi ito tumutugma sa inaasahan ng iterator na makita, ito ay naghagis ng isang pagbubukod. Hindi ko isasaalang-alang nang detalyado ang mga iterator dito.

public ListIterator< E> listIterator() и public ListIterator< E> listIterator(int index)

Nagbabalik ng list iterator para sa isang listahan para magamit sa ibang pagkakataon sa isang loop o anumang iba pang pagproseso. Pinapalawak ng interface ListIteratorang interface Iteratorpara sa two-way traversal ng listahan at pagbabago ng mga elemento nito. Sa overloaded na bersyon, maaari mong ipasa ang index kung saan magsisimula ang "traversal". Ang index sa kasong ito ay tumutukoy sa unang elemento kung saan magsisimula ang pamamaraan sa trabaho nito next(), at kapag tinawag ang pamamaraan, previous()magsisimula ang traversal mula sa elemento sa ilalim ng index na "passed index - 1".

public Spliterator <E> spliterator()

Ipinakilala ng Java 8 ang isang bagong uri ng late binding at fail-fast iterator na tinatawag na delimiter iterator. Binibigyang-daan ka ng mga separator iterator na umulit sa isang pagkakasunud-sunod ng mga elemento, ngunit ginagamit ang mga ito sa ibang paraan. Ang pinakamahalagang tampok ng interface ng Spliterator ay ang kakayahang suportahan ang parallel na pag-ulit ng mga indibidwal na bahagi ng isang sequence ng mga elemento, at samakatuwid ay parallel programming.