bagong ArrayList(????) paano at saan mas mahusay na simulan

Ang pagsulat ng code nang hindi ginagamit ang balangkas ng mga koleksyon ay magiging baliw. Ito ay isang kahanga-hangang piraso ng Java na may maraming maayos na solusyon. Higit sa lahat, hindi tulad ng mga array, hindi mo kailangang mag-alala tungkol sa mga laki. Lalago ang ArrayList hanggang sa maubusan ito ng memorya. Ang developer ay hindi kailangang mag-alala tungkol sa paunang laki at ang ArrayIndexOutOfBoundsException error . Ngunit paano kung mayroong isang kondisyon upang masubaybayan ang dami ng memorya? Magagamit ba natin ang memorya nang mahusay kapag nagtatrabaho sa mga koleksyon?
Ang isang karaniwang tanong ay lumitaw: kung paano simulan ang isang listahan? Hindi gagana ang code sa ibaba: Magreresulta ito sa isang error sa compilation: Maaaring hindi pa nasimulan ang mga lokal na pangalan ng variable . Ang pagtutukoy ng Java ay nangangailangan na ang lahat ng mga lokal na variable (ang mga umiiral sa stack) ay masimulan na may naaangkop na mga halaga. Ito ay kung paano mo ito magagawa: Walang alinlangan, ang listahan ay dapat masimulan. Maaari kang lumikha ng listahan sa unang linya, o maaari kang gumawa ng mas matalinong bagay at gumamit ng tamad na pagsisimula tulad ng ginawa namin sa getAllNames() na pamamaraan . Sa kasong ito, ang listahan ay gagawin lamang kapag kinakailangan - kung ang mga unang kundisyon ay hindi natutugunan, ang listahan ay hindi kailanman lalabas sa heap. Narito tayo sa pangunahing tanong: anong sukat ang dapat nating itakda para sa listahan? Ang pinakamagandang opsyon ay ibigay sa kanya ang eksaktong sukat. Halimbawa: Sa kasong ito, eksaktong n mga pangalan ang dapat ibalik, at bilang kinahinatnan, isang koleksyon ng n elemento ay nilikha. Gayunpaman, ang eksaktong halaga ng n ay hindi palaging nalalaman. Kahit na sa halimbawang ibinigay, paano kung n=1000 at mayroon lamang 100 mga pangalan na magagamit? Kapag nagtatrabaho sa mga koleksyon, ang pinakasikat na paraan ay ang pagtawag sa default na tagabuo. Kung titingnan mo ang source code ng Java (bersyon 1.6) Gaya ng nakikita mo, bilang default, isang listahan ng 10 elemento ay nilikha . Ibig sabihin, ligtas naming magagamit ang default na constructor kapag hindi namin planong mag-imbak ng higit sa 10 elemento sa listahan. Ano ang mangyayari kung susubukan mong idagdag ang ika-11 elemento? Well, walang masama... matagumpay na maidaragdag ang elemento. Tingnan ang paraan: Ang laki ng array ay kinokontrol ng ensureCapacity method . Ang laki ay tumataas ng 1.5 beses . Ang isang bagong array ay nilikha at ang mga elemento ay inilipat dito. Kung itinakda namin ang laki sa 10, pagkatapos ay sa ika-11 na elemento:
public List getAllNames() { List names; if (/*необходимые условия выполнены*/) { names = new ArrayList (); /*заполнение списка*/ } return names; }
List names = null; List names = new ArrayList (); List names = new ArrayList (0); List names = new ArrayList (size);
public List getTopNames (int n) { List names = null; if ( /*необходимые условия выполнены*/) { names = new ArrayList (n); /*заполнение списка*/ } return names; }
names = new ArrayList ();

/** * Конструирует пустой список с указанной начальной емкостью. * * @param initialCapacity начальная емкость списка * @exception IllegalArgumentException если указанная начальная емкость отрицательна * */ public ArrayList(int initialCapacity) { super(); if (initialCapacity < 0) this.elementData = new Object[initialCapacity]; } /** * Конструирует пустой список с начальной емкостью, равной 10. */ public ArrayList() { this(10); }
public Boolean add(E e) { ensureCapacity(size + 1); //увеличивает modCount!! elementData[size++] = e; return true; } public void ensureCapacity (int minCapacity) { modCount++; int oldCapacity = elementData.length; if (minCapacity > oldCapacity) { throw new IllegalArgumentException(“Illegal Capacity: ” + initialCapacity); Object oldData[] = elementData; int newCapacity = (oldCapacity * 3) / 2 + 1; if (newCapacity < minCapacity) newCapacity = minCapacity; // minCapacity обычно ближе к размеру, так что это беспроигрышно: elementData = Arrays.copyOf(elementData, newCapacity); } }

• nagbabago ang laki sa 10 * 3 / 2 + 1 = 16
• susunod na pagtaas = 16 * 3 / 2 + 1 = 25
• susunod na pagtaas = 25 * 3 / 2 + 1 = 39 at iba pa.

Sa kaso ng 100 elemento, ang JVM ay kailangang gumawa ng bagong array nang maraming beses at kopyahin ang mga elemento dito. Isinasaalang-alang ito, kung mayroong isang pagpapalagay tungkol sa kinakailangang laki ng array, mas mahusay na itakda ang paunang kapasidad na malapit dito. Narito ang ilang mga alituntunin para sa pagkilos:

1. Lumikha lamang ng isang koleksyon kapag kailangan mo ito , kung hindi man ay simulan ito sa null o gamitin ang Collections.EMPTY_LIST .
2. Kung alam mo ang eksaktong sukat na kinakailangan , tukuyin ito sa tagabuo ng koleksyon.
3. Kung sigurado ka na ang bilang ng mga elemento ay hindi lalampas sa 10 , huwag mag-atubiling gamitin ang default na constructor.
4. Ang panganib na nauugnay sa paglikha ng isang zero-size na koleksyon ay ang dalas ng paggawa ng mga bagong array at pagkopya ng data ay maaaring mas mataas. Kailangan mong pag-isipang mabuti kung ang pakinabang ng paggamit ng mga zero-size na koleksyon ay talagang napakaganda .
5. Kung pinasimulan mo ang isang koleksyon na masyadong malaki sa simula ng pamamaraan at gusto mong bawasan ito, mayroong trimToSize() na paraan .

Siyempre, nalalapat ang mga alituntuning ito kapag nagtatrabaho sa mga koleksyon na nakabatay sa array, at wala sa mga ito ang makatuwiran sa kaso ng isang naka-link na listahan. Sa katunayan, ang mga problemang ito ay malamang na hindi mamamatay sa programa, ngunit kung may pagkakataon na gumawa ng mas mahusay, bakit hindi ito gamitin. Mayroon ka bang iba pang kapaki-pakinabang na tip? Nakakita ka na ba ng mga paraan upang gawing mas mahusay ang mga bagay? O ang lahat ng ito ay hindi kailangan? Ano sa tingin mo?