ArrayList klase sa Java

Kamusta! Sa mga nakaraang lektura, sinuri namin nang detalyado ang tulad ng isang istraktura ng data bilang isang array at tumingin sa mga karaniwang halimbawa ng pagtatrabaho sa kanila. Ngunit ang istraktura ng data na ito ay may isang bilang ng mga disadvantages. Ang sagot sa kanila sa Java ay ang hitsura ng ArrayList. Upang ilagay ito nang simple hangga't maaari, ang isang ArrayList sa Java ay isang "na-upgrade" na array na may maraming mga bagong tampok.

Paano naiiba ang Java Arraylist sa mga regular na array?

Sa pangkalahatan, ang mga array ay medyo maginhawa at, tulad ng napansin mo na, maaari kang gumawa ng maraming bagay sa kanila :) Gayunpaman, ang mga array ay mayroon ding ilang mga disadvantages.

• Limitadong laki. Kailangan mong malaman na sa yugto ng paglikha ng isang array kung gaano karaming mga cell ang dapat itong maglaman. Kung minamaliit mo ang kinakailangang halaga, hindi magkakaroon ng sapat na espasyo. Kung i-overestimate mo ito, ang array ay mananatiling kalahating walang laman, at hindi iyon masama. Pagkatapos ng lahat, lumalabas na maglalaan ka rin ng mas maraming memorya para dito kaysa sa kinakailangan.
• Ang isang array ay walang mga pamamaraan para sa pagdaragdag ng mga elemento. Palagi mong kailangang tahasang tukuyin ang index ng cell kung saan mo gustong idagdag ang elemento. Kung hindi mo sinasadyang tukuyin ang isang na-occupy na cell na may ilang gustong halaga, ito ay ma-overwrite.
• Walang mga paraan upang alisin ang isang elemento. Ang halaga ay maaari lamang "zeroed".

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Hippopotamus");
       cats[2] = new Cat("Philip Markovich");

       cats[1] = null;



       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

Konklusyon:

[Cat{name='Томас'}, null, Cat{name='Фorпп Маркович'}]

Ang lahat ng mga pagkukulang na ito ay maaaring alisin gamit ang ArrayList. Ito ay nilikha nang napakasimple:

ArrayList<Cat> cats = new ArrayList<Cat>();

Ngayon kami ay gumawa ng isang listahan upang mag - imbak ng mga bagay Cat. Bigyang-pansin:hindi namin tinukoy ang laki ng ArrayList dahil awtomatiko itong napapalawak. Paano ito posible? Madali. Magugulat ka, ngunit ang ArrayList ay batay sa isang ordinaryong array :) Oo, sa loob nito ay mayroong isang array kung saan ang aming mga elemento ay naka-imbak. Ngunit ang ArrayList ay may espesyal na mekanismo para sa pagtatrabaho dito:

• Kapag puno na ang panloob na array na ito, gagawa ang ArrayList ng bagong array sa loob mismo nito. Ang laki nito = (laki ng lumang array * 1.5) +1.
• Ang lahat ng data ay kinopya mula sa lumang array patungo sa bago
• Ang lumang hanay ay inalis ng tagakolekta ng basura.

Salamat sa mekanismong ito, ang isang ArrayList (kumpara sa isang array) ay nagpapatupad ng isang paraan para sa pagdaragdag ng isang bagong elemento. Ito ay isang pamamaraan add().

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Hippopotamus"));
}

Ang bagong elemento ay idinagdag sa dulo ng listahan. Ngayon ay walang panganib ng pag-apaw, kaya ang mekanismong ito ay ganap na ligtas. Sa pamamagitan ng paraan, ArrayList ay hindi lamang maaaring maghanap para sa isang bagay sa pamamagitan ng index, ngunit din sa kabaligtaran - maaari itong mahanap ang index ng isang bagay sa ArrayList sa pamamagitan ng pagtukoy sa bagay! Upang gawin ito, ipinapatupad nito ang pamamaraan indexOf(): Ipinapasa namin dito ang isang link sa nais na bagay, at indexOf()ibinabalik nito sa amin ang index nito:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

Konklusyon:

0

Iyan ay tama, ang bagay thomasay aktwal na naka-imbak sa cell 0. Ang mga array ay hindi lamang mga disadvantages, kundi pati na rin ang hindi mapag-aalinlanganan na mga pakinabang. Ang isa sa mga ito ay naghahanap ng isang elemento ayon sa index. Dahil itinuturo namin ang isang index, iyon ay, sa isang tiyak na address sa memorya, ang gayong paghahanap ng array ay napakabilis. Magagawa rin ito ng ArrayList sa Java! Upang gawin ito, nagpapatupad ito ng isang pamamaraan get():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

Konklusyon:

Cat{name='Бегемот'}

Gayundin, madali mong malalaman kung ang isang ArrayList ay naglalaman ng isang partikular na bagay o hindi. Ginagawa ito gamit ang pamamaraan contains():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.remove(pushok);
   System.out.println(cats.contains(pushok));
}

Sinusuri ng pamamaraan kung ang elemento ay nakapaloob sa panloob na array ng ArrayList, at ibinabalik ang resulta sa form boolean- trueo false. Konklusyon:

false

At isa pang mahalagang bagay tungkol sa pagpasok. Pinapayagan ka ng ArrayList na magpasok ng data hindi lamang sa dulo ng array, kundi pati na rin sa anumang cell ayon sa index. Mayroon itong dalawang pamamaraan para dito:

• add(int index, Cat element)
• set(int index, Cat element)

Sa pareho, ipapasa mo ang index ng cell kung saan mo gustong ipasok, at isang link sa mismong object. Ang pagkakaiba ay ang pag-paste sa pamamagitan ng set()pag-overwrite sa lumang halaga na nakaimbak sa cell. At ang pagpasok sa pamamagitan ng add()unang paglilipat ng lahat ng mga elemento simula [index]sa dulo ng array, at idinaragdag ang bagay na kailangan mo sa nagresultang walang laman na cell. Narito ang isang halimbawa:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, philipp);//Now we have a list of 2 cats. We add the 3rd via set:

   System.out.println(cats.toString());
}

Konklusyon:

[[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фorпп Маркович'}, Cat{name='Бегемот'}]

Mayroon kaming isang listahan ng 2 pusa, nagpasok kami ng isa pa sa pamamagitan ng pamamaraan set()sa cell 0. Bilang resulta, ang lumang halaga na nakaimbak sa cell na ito ay pinalitan ng bago.

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, philipp);//Now we have a list of 2 cats. Add the 3rd via add

   System.out.println(cats.toString());
}

Ngunit ito ay add()nagtrabaho nang iba. Inilipat niya ang lahat ng mga elemento sa kanan at pagkatapos ay isinulat ang bagong halaga sa cell 0. Konklusyon:

[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фorпп Маркович'}, Cat{name='Томас'}, Cat{name='Бегемот'}]

Upang ganap na i-clear ang listahan, gamitin ang pamamaraan clear():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.clear();

   System.out.println(cats.toString());
}

Konklusyon:

[]

Ang lahat ng nilalaman ay inalis sa listahan. Sa pamamagitan ng paraan, bigyang-pansin: hindi tulad ng mga array, sa ArrayList ang toString() na paraan ay na-override at agad na ipinapakita ang listahan sa string na format. Sa kaso ng mga array, kinailangan naming gamitin ang klase ng Arrays para dito. At dahil naalala namin ang Arrays: sa Java madali kang "lumipat" sa pagitan ng array at ArrayList, ibig sabihin, i-convert ang isa sa isa. Ang klase ng Arrays ay may pamamaraan para dito, Arrays.asList(). Sa tulong nito, nakukuha namin ang mga nilalaman ng array bilang isang listahan at ipinapasa ito sa constructor ng aming ArrayList:

public static void main(String[] args) {

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   Cat[] catsArray = {thomas, behemoth, philipp, pushok};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

Konklusyon:

[Cat{name='Томас'}, Cat{name='Бегемот'}, Cat{name='Фorпп Маркович'}, Cat{name='Пушок'}]

Maaari mong gawin ang kabaligtaran - kumuha ng array mula sa isang ArrayList object. Upang gawin ito, gamitin ang toArray() na pamamaraan:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

Pakitandaan: nagpasa kami ng isang walang laman na array sa toArray() method. Hindi ito isang pagkakamali. Sa loob ng klase ng ArrayList, ang pamamaraang ito ay ipinatupad sa paraang ang pagpasa sa isang walang laman na hanay ay nagpapataas ng pagganap nito. Sa ngayon, tandaan lamang ito para sa hinaharap (ngunit maaari ka ring maglipat ng isang partikular na laki, gagana ito). Speaking of size. Ang kasalukuyang laki ng listahan ay matatagpuan gamit ang pamamaraan size():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

Mahalagang maunawaan dito na, hindi katulad ng lengtharray property, ang ArrayList.size() na paraan ay nagbabalik ng eksaktong bilang ng mga elemento, at hindi ang paunang kapasidad, dahil hindi namin ito tinukoy kapag gumagawa ng ArrayList. Sa pamamagitan ng paraan, sa pangkalahatan ay posible na ipahiwatig ito. Ang ArrayList ay may kaukulang constructor. Ngunit ang pag-uugali nito sa mga tuntunin ng pagdaragdag ng mga bagong elemento ay hindi magbabago:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);//create an ArrayList with an initial capacity of 2


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

Output ng console:

4

Gumawa kami ng listahan na may 2 elemento, ngunit kapag kailangan namin ito, madali itong lumawak. Ang isa pang bagay ay kung sa una ay lumikha kami ng isang napakaliit na listahan, kakailanganin nitong isagawa ang pagpapalawak ng operasyon nang mas madalas, at ito ay kumonsumo ng isang tiyak na halaga ng mga mapagkukunan. Sa lecture na ito, halos hindi namin nahawakan ang proseso ng pag-alis ng mga elemento mula sa isang ArrayList. Siyempre, hindi ito dahil sa pagkalimot. Ang paksang ito ay pinaghiwalay sa isang hiwalay na panayam, na maaari mong basahin nang higit pa :)