تجزیه و تحلیل دقیق کلاس ArrayList [بخش 1]

این مقاله نگاهی دقیق به کلاس ArrayList از مجموعه مجموعه ها خواهد داشت، که شاید به دلیل اینکه بر اساس یک آرایه معمولی ساخته شده است، درک ساده ترین آنها باشد. تقریباً مطمئناً در مصاحبه از شما سؤالی در مورد این کلاس و پیاده سازی آن در جاوا پرسیده می شود. در قسمت دوم روش‌های باقی‌مانده را تحلیل می‌کنیم و پیاده‌سازی خودمان از یک آرایه پویا برای اعداد را می‌نویسیم. کلاس ArrayList از کلاس AbstractList ارث می برد و رابط های زیر را پیاده سازی می کند: List، RandomAccess، Cloneable، Serializable. تجزیه و تحلیل دقیق کلاس ArrayList [قسمت 2] کلاس ArrayList از آرایه های پویا پشتیبانی می کند که می توانند در صورت نیاز گسترش یابند. ضرورت و اثربخشی آن با این واقعیت توضیح داده می‌شود که یک آرایه منظم دارای طول ثابتی است: هنگامی که ایجاد می‌شود، نمی‌تواند رشد کند یا کوچک شود، که اگر معلوم نباشد آرایه چقدر بزرگ است، محدودیت‌هایی ایجاد می‌کند. اساساً، کلاس ArrayList یک آرایه فهرست با طول متغیر از مراجع شی است. درک این نکته مهم است که اندازه (تعداد سلول ها) آرایه داخلی به طور خودکار با حذف عناصر از آن کاهش نمی یابد. در واقع مقدار متغیر sizeکه تعداد عناصر موجود در آرایه را نشان می دهد کاهش می یابد. فرض کنید یک شی جدید از کلاس ArrayList ایجاد می کنیم و 5 عنصر به آن اضافه می کنیم. به طور پیش فرض، آرایه ای از 10 عنصر ایجاد می شود. در این حالت، به اصطلاح ظرفیت (اندازه/حجم) شی ما برابر با 10 خواهد بود، اما مقدار متغیر sizeبرابر با پنج خواهد بود. و وقتی عناصر را حذف می کنیم، تغییراتی را در مقدار متغیر مشاهده می کنیم size، زیرا .lengthنمی توانیم به آرایه داخلی کلاس ArrayList دسترسی پیدا کنیم و طول آن را بفهمیم. اندازه را می توان با استفاده از یک روش اضافی کاهش داد trimToSize()که در زیر مورد بحث قرار خواهد گرفت. بیایید به فیلدهای کلاس نگاه کنیم.

• فیلد مسئول حجم پیش فرض آرایه پویا:

  private static final int DEFAULT_CAPACITY = 10

  هنگام ایجاد یک شی جدید ArrayList<>() (سازنده بدون پارامتر)، آرایه ای از 10 عنصر در داخل ایجاد می شود.

• فیلدی که تمام عناصر مجموعه در آن ذخیره می شود:

  transient Object[] elementData

  با یک کلمه کلیدی مشخص شده است transient- هنگام استفاده از الگوریتم سریال سازی استاندارد، فیلد در جریان بایت نوشته نمی شود. شایان ذکر است که فیلد با کلمه کلیدی علامت گذاری نشده است private، اما این کار به منظور تسهیل دسترسی به این فیلد از کلاس های تو در تو (به عنوان مثال SubList) انجام شده است.

• یک فیلد شمارنده که تعداد عناصر موجود در آرایه را ذخیره می کند:

  private int size

  هنگام انجام عملیاتی مانند درج و حذف، مقدار افزایش/کاهش می‌یابد.

3 فیلد دیگر در کلاس وجود دارد، اما در اصل آنها اضافی هستند، بنابراین در نظر گرفتن آنها فایده ای ندارد. کلاس دارای سه سازنده است:

1. public ArrayList()- یک آرایه لیست خالی از 10 عنصر ایجاد می کند.
2. public ArrayList(Collection < ? extends E > c)– یک آرایه فهرستی ایجاد می کند که با عناصر مجموعه ارسال شده مقداردهی اولیه شده است (اگر بخواهیم یک ArrayList جدید بر اساس مجموعه ای ایجاد کنیم).
3. public ArrayList(int initialCapacity)- یک آرایه لیست با ظرفیت اولیه ایجاد می کند. اگر پارامتر گذرانده شده initialCapacity بزرگتر از 0 باشد، آرایه ای با اندازه مشخص ایجاد می شود (به عنصر فیلد داخلیData پیوندی به آرایه جدیدی از نوع Object of size initialCapacity اختصاص داده می شود). اگر پارامتر 0 باشد، یک آرایه خالی ایجاد می شود. اگر پارامتر مشخص شده کمتر از 0 باشد، یک IllegalArgumentException پرتاب می شود.

ایجاد یک شی

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

شی جدید ایجاد شده listحاوی خواص (فیلدها) elementDataو size. ذخیره ارزش elementDataچیزی بیش از یک آرایه از یک نوع خاص (مشخص شده در عمومی – <>) در مورد ما نیست String[]. اگر یک سازنده بدون پارامتر فراخوانی شود، به طور پیش فرض یک آرایه از 10 عنصر از نوع Object ایجاد می شود (البته با ریخته گری به نوع). افزودن عناصر به طور کلاسیک افزودن عناصر به آرایه فهرست با استفاده از انواع بارگذاری شده از add().

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

خوب، اجازه دهید اضافه کنیم: list.add("0"); در داخل این روش، یک نسخه بارگذاری شده از متد فراخوانی می شود add()که با علامت گذاری شده است private، که به نوبه خود سه پارامتر را به عنوان ورودی می گیرد: عنصری که باید اضافه شود، آرایه داخلی و اندازه آن. در روش خصوصی، یک بررسی رخ می دهد: اگر پارامتر اندازه ارسال شده برابر با طول آرایه داخلی باشد (یعنی آرایه پر است)، آنگاه نتیجه روش grow(int minCapacity)(مقدار فعلی فیلد) به آرایه اختصاص داده می شود. اندازه + 1 به روش منتقل می شود، زیرا لازم است عنصر اضافه شده را در نظر بگیریم)، ​​که در آن آرایه داخلی پیوندی به آرایه ایجاد شده جدید که با کپی کردن عناصر آرایه اصلی به دست آمده است، اختصاص می دهد:

Arrays.copyOf(elementData, newCapacity(minCapacity))

به عنوان پارامتر دوم روش، copyOfنتیجه روش را نشان می‌دهیم newCapacity(int minCapacity)که در آن اندازه آرایه جدید محاسبه می‌شود. با استفاده از فرمول زیر محاسبه می‌شود: int newCapacity = oldCapacity + (oldCapacity >> 1) برای آرایه‌ای با اندازه پیش‌فرض، موارد زیر صادق خواهد بود: >> 1- شیفت بیتی به سمت راست توسط یک (عملگری که یک عدد را به نصف آن کاهش می‌دهد). در اصل، این به معنای تقسیم بر 2 به توان 1 است. معلوم می شود که 10 را بر 2 تقسیم می کنیم و 10 را اضافه می کنیم. در مجموع، ظرفیت جدید آرایه 15 است، اما از آنجایی که عنصر یازدهم را اضافه می کنیم، 15 + 1 است. = 16. بیایید به لیست خود بازگردیم و فرض کنیم که قبلاً 10 عنصر به آن اضافه کرده ایم و سعی می کنیم 11 را اضافه کنیم. بررسی نشان می دهد که هیچ فضایی در آرایه وجود ندارد. بر این اساس، یک آرایه جدید ایجاد و نامیده می شود Arrays.copyOfکه به صورت داخلی از متد system استفاده می کند System.arraycopy(). یا در اینجا یک مثال واضح از یک مقاله در JavaRush آورده شده است: پس از همه این بررسی ها و افزایش اندازه آرایه در صورت لزوم، سپس در یک روش خصوصی add()یک عنصر جدید به انتهای آرایه اضافه می شود و پارامتر فعلی sizeیک افزایش می یابد. . آرایه قدیمی متعاقباً توسط جمع کننده زباله پردازش می شود. یک آرایه پویا به این صورت کار می کند: وقتی عناصر را اضافه می کنیم، بررسی می کنیم که آیا هنوز در آن جا وجود دارد یا خیر. اگر فضا وجود داشته باشد، به سادگی عنصر را به انتهای آرایه اضافه می کنیم. پایان به معنای آخرین سلول آرایه نیست، بلکه سلولی است که با مقدار مطابقت دارد size. اولین عنصر را به آرایه اضافه کردیم؛ این عنصر در سلولی با شاخص [0] قرار می گیرد. مقدار فیلد sizeیک و = 1 افزایش یافته است. عنصر بعدی را اضافه می کنیم: می بینیم که size = 1بر این اساس عنصر را در سلول با شاخص [1] و غیره قرار می دهیم. یک نسخه اضافه بار از روش با دو پارامتر وجود دارد:

public void add(int index, E element)

می توانیم موقعیت (شاخص) سلولی را که می خواهیم عنصر را در آن اضافه کنیم مشخص کنیم. ابتدا صحت مقدار شاخص مشخص شده بررسی می شود، زیرا این احتمال وجود دارد که یک نمایه نادرست مشخص شود، که به سلولی اشاره می کند که در آن چیزی وجود ندارد یا به سادگی وجود ندارد. بررسی شاخص ها: index > size || index < 0– اگر اندیس مشخص شده بزرگتر از اندازه فعلی آرایه باشد یا کمتر از 0 باشد، یک استثنا ایجاد می شود IndexOutOfBoundsException. سپس در صورت لزوم اندازه آرایه مانند مثال بالا افزایش می یابد. احتمالاً شنیده اید که در حین عملیات افزودن/حذف در یک آرایه، چیزی به جایی (به راست یا چپ) منتقل می شود. بنابراین، جابجایی با کپی کردن آرایه انجام می شود: System.arraycopy(elementData, index, elementData, index + 1, s - index); تمام عناصر واقع در سمت راست شاخص مشخص شده یک موقعیت به سمت راست منتقل می شوند (شاخص +1). و تنها پس از آن یک عنصر جدید به آرایه داخلی در شاخص مشخص شده اضافه می شود. از آنجایی که بخشی از آرایه را یکی به راست منتقل کرده ایم (آرایه جدیدی ایجاد نمی شود)، سلولی که نیاز داریم برای نوشتن آزاد خواهد بود. پیوند به آرایه قدیمی پاک می شود و در آینده توسط جمع کننده زباله تصاحب خواهد شد. «maserati» را در سلول [3]، که قبلاً اشغال شده است، بچسبانید: بنابراین، هنگامی که یک عنصر در شاخص درج می شود و هیچ فضای خالی در آرایه وجود ندارد، فراخوانی System.arraycopy()دو بار اتفاق می افتد: اولی در grow()، دومی در خود روش add(index, value)، که به وضوح بر سرعت کل عملیات اضافه کردن تأثیر می گذارد. در نتیجه، زمانی که لازم است عنصر دیگری در آرایه داخلی بنویسید، اما در آنجا فضایی وجود ندارد، در ArrayList چنین اتفاقی می‌افتد:

• یک آرایه جدید با اندازه 1.5 برابر بزرگتر از آرایه اصلی به اضافه یک عنصر ایجاد می شود.
• تمام عناصر آرایه قدیمی در آرایه جدید کپی می شوند
• آرایه جدید در متغیر داخلی شی ArrayList ذخیره می شود و آرایه قدیمی زباله اعلام می شود.

ظرفیت اشیاء از نوع ArrayList را می توان به صورت دستی با استفاده از روش افزایش داد:

public void ensureCapacity(int minCapacity)

با افزایش ظرفیت آرایه از قبل، می توانید بعداً از تخصیص مجدد RAM اضافی جلوگیری کنید. این روش اندازه آرایه داخلی را افزایش می دهد تا تعداد عناصر ارسال شده به را در خود جای دهد minCapacity. این روش ensureCapacity()بر فیلد تأثیر نمی گذارد size، روی capacity(اندازه) آرایه داخلی تأثیر می گذارد. یک بار دیگر تاکید می کنم که sizeهر دو چیز متفاوتی هستند capacityو خیلی مهم است که آنها را اشتباه نگیرید! اگر می خواهید اندازه آرایه زیرینی که ArrayList از آن ساخته شده است را به تعداد فعلی عناصر ذخیره شده واقعی کاهش دهید، باید شماره را فراخوانی کنید trimToSize(). پس از حذف عناصر از مجموعه، size()تعداد عناصر واقعی موجود را نشان می دهد و capacityکاهش نمی یابد! فرض کنید: ما 100 عنصر را وارد کرده ایم، 50 عنصر اول را حذف می کنیم، sizeبرابر با 50 می شود و بنابراین capacity100 باقی می ماند. برای کاهش و capacityباید از روشی استفاده کنیم trimToSize()که کل ظرفیت ما را به اندازه فعلی تنظیم می کند. چگونه مناسب است؟ آرایه ما را طوری کپی می کند که هیچ سلول خالی باقی نماند (طول آرایه جدید به سادگی برابر با فیلد اندازه است). همچنین می توانید با استفاده از addAll.

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

گزینه اول به شما امکان می دهد تمام عناصر مجموعه مشخص شده در پارامتر متد (مثلاً یک برگه دیگر) را به مجموعه اصلی (درج در انتها) که فراخوانی متد برای آن انجام شده است اضافه کنید. مجموعه ارسال شده (همچنین می تواند یک مجموعه باشد) با استفاده از toArray(). طبیعتاً عملیات افزودن نیز با استفاده از کپی انجام می شود. دوم این است که همه عناصر را collectionبه لیست اضافه کنید، از فهرست شروع کنید index. در این حالت، همه عناصر با تعداد عناصر موجود در لیست به سمت راست منتقل می شوند collection. حذف عناصر ابتدا، بیایید به گزینه های کلاسیک برای حذف عناصر از ArrayList نگاه کنیم.

public E remove(int index)

حذف توسط ایندکس را انجام می دهد و تمام عناصر بعدی (بعد از عنصر در شاخص مشخص شده) را به سمت چپ منتقل می کند، در نتیجه "سوراخ ها" را می بندد. همچنین عنصر حذف شده (E) را که قبلاً قبل از حذف بر روی یک متغیر اضافی نوشته شده بود برمی گرداند که مقدار آن را در نتیجه فراخوانی متد به دست می آوریم. برای درک اینکه E چیست، باید با انواع به اصطلاح عمومی آشنا شوید. علامت E نشان می دهد که روش، نوع داده ای را که هنگام ایجاد شی ArrayList مشخص شده است، برمی گرداند (به یاد داشته باشید: List <String> listبر این اساس، در این مورد، E "جایگزین" می شود String). برای درک کلی، من قویاً توصیه می کنم که با انواع عمومی آشنا شوید. صحت ایندکس وارد شده بررسی می شود و سپس در داخل متد، عنصر به طور کامل حذف نمی شود، بلکه یک متد خصوصی فراخوانی می شود fastRemove(Object[] es, int i)که در آن حذف قبلاً رخ داده است. آرایه خود و اندیس مشخص شده را به عنوان ورودی به متد ارسال می کنیم. عناصر با استفاده از کپی می شوند System.arraycopy()، اندازه آرایه کاهش می یابد و سپس null را به آخرین عنصر اختصاص می دهیم. شایان ذکر است که آرایه جدیدی ایجاد نمی شود: System.arraycopy(es, i + 1, es, i, size - 1 - i); بخشی که در سمت راست موقعیت در زیر شاخص مشخص شده (i+1) قرار دارد در آرایه اصلی (es) ما کپی می شود و از همان موقعیت شروع می شود. (i) جایی که عنصر برای حذف قرار داشت. بنابراین، ما یک تغییر به چپ انجام دادیم و عنصر خود را پاک کردیم. بیایید سعی کنیم عنصر موجود در شاخص 3 را از آرایه زیر حذف کنیم: بیایید نسخه دوم روش را در نظر بگیریم:

public boolean remove(Object o)

این روش، عنصر ارسال شده را از لیست o، یا به طور دقیق تر، شی موجود در پیوند مشخص شده را حذف می کند. اگر عنصری در لیست وجود داشته باشد، حذف می شود و همه عناصر به سمت چپ منتقل می شوند. اگر عنصر در لیست وجود داشته باشد و با موفقیت حذف شود، روش true و در غیر این صورت، false را برمی گرداند. مشابه گزینه حذف با شاخص، متد نامیده می شود fastRemove()که دقیقاً همان اقدامات را در آن انجام می دهد. تفاوت این است که متد remove(Object o)علاوه بر این، شی مورد نظر را از طریق متدی equals()از کلاس Object جستجو می کند. هنگام حذف بر اساس مقدار، حلقه از تمام عناصر لیست می گذرد تا زمانی که مطابقت پیدا شود. فقط اولین عنصر یافت شده حذف خواهد شد. بیایید خلاصه کنیم: هنگام حذف عناصر از یک آرایه پویا، هیچ حفره ای مانند یک آرایه معمولی باقی نمی ماند (سلول حذف شده خالی نخواهد بود). تمام عناصر بعدی (که در سمت راست شاخص قرار داشتند) یک موقعیت به چپ منتقل می شوند. چندین روش اضافی وجود دارد که می توان برای حذف عناصر از لیست به درجات مختلف استفاده کرد. بیایید به طور خلاصه به آنها نگاه کنیم. تمیز کردن مجموعه ما:

public void clear()

یک حلقه ساده forدر تمام عناصر یک آرایه تکرار می شود و به هر عنصر null اختصاص می دهد. شما می توانید آن عناصر را از مجموعه ما که در مجموعه انتقال یافته دیگری مانند این وجود دارد حذف کنید:

public boolean removeAll(Collection< ?> c)

اگر نیاز به حذف چندین عنصر دارید، احتمالاً نباید این کار را در یک حلقه شرطی انجام دهید: استفاده از روش راحت تر و ایمن تر است removeAll(). مجموعه ای از عناصر را می پذیرد که از لیست حذف می شوند. مجموعه باید حاوی عناصری از همان نوع باشد که لیست هدف ذخیره می کند. در غیر این صورت دور ریخته می شود ClassCastException. اگر لیست در نتیجه فراخوانی متد تغییر کرده باشد، این متد true خواهد شد. عناصری را که به مجموعه ارسال شده تعلق ندارند حذف می کند:

public boolean retainAll(Collection< ?> c)

فرض کنید یک مجموعه داریم:

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

و دومی:

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

سپس بعد از listSecond.retainAll(listFirst)در listSecondباقی خواهد ماند:

"White"
"Red"

از آنجایی که "سبز" حذف شد، که در نیست listFirst. اما پس از listSecond.removeAll(listFirst)آن listSecondباقی خواهد ماند:

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

عدم تعلق به مجموعه ارسال شده - به این معنی است که اگر عناصری در مجموعه ارسال شده وجود ندارند، باید آنها را از اولین (که روش برای آن اعمال می شود) حذف کنید. متعلق به مجموعه منتقل شده - بر این اساس، اگر عنصری در هر دو مجموعه اول و دوم (انتقال شده) وجود داشته باشد، نسخه تکراری از اول از بین می رود.

protected void removeRange(int fromIndex, int toIndex)

تمام عناصری را که بین شاخص مشخص شده آغازین (شامل) و نمایه مشخص شده پایانی (غیرشامل) قرار دارند را از لیست حذف می کند. شایان ذکر است که متد را نمی توان مستقیماً روی یک شی ArrayList فراخوانی کرد. برای استفاده از آن باید از آن ارث ببرید AbstractList/ArrayList. این روش همچنین توسط روش دیگری (subList که بعداً مورد بحث قرار خواهد گرفت) استفاده می شود.

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

عناصر را از یک مجموعه بر اساس یک محمول معین حذف می کند. محمول خود تابع/الگوریتم/شرط معینی است که بر اساس آن یک یا چند عنصر مربوط به یک شرط معین حذف می شود. Predicate- یک رابط کاربردی (شامل تنها یک روش است، بنابراین می توان از آن به عنوان لامبدا استفاده کرد)، بر اساس اصل "دریافت یک پارامتر - بولی بازگشتی" کار می کند. اساساً، این روش پیاده‌سازی را از رابط لغو می‌کند Collectionو «استراتژی» زیر را پیاده‌سازی می‌کند: از میان عناصر حلقه می‌زند و آن‌هایی را که مطابق با ما هستند علامت‌گذاری می‌کند Predicate. سپس برای حذف (و جابجایی) عناصری که در تکرار اول علامت گذاری شده بودند، برای بار دوم اجرا می شود. بیایید یک رابط پیاده سازی کنیم Predicateکه اگر دو شی مساوی باشند، true را باز می گرداند:

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

در کلاس دیگر، بیایید یک ArrayList از Stringو یک شی از کلاس خود ایجاد کنیم که Predicate:

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

varc1بیایید مقدار "White" را برای متغیر بنویسیم:

filter.varc1 = "White";

بیایید چند خط به لیست اضافه کنیم:

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

بیایید متد موجود در لیست را اجرا کنیم removeIfکه شیء خود را با شرط به آن پاس می دهیم:

color_list.removeIf(filter);

در نتیجه، تمام ردیف‌های دارای مقدار "سفید" از لیست حذف می‌شوند، زیرا "مقدم" ما آنها را برای برابری مقایسه می‌کند. لیست نهایی: [سیاه، قرمز، زرد]. جایگزینی عناصر

public E set(int index, E element)

عنصر را در موقعیت مشخص شده indexبا عنصر پاس شده جایگزین می کند element. شاخص همچنین باید بزرگتر از صفر و کوچکتر از شاخص آخرین عنصر باشد، در غیر این صورت یک استثنا ایجاد می شود IndexOutOfBoundsException. هیچ کپی از آرایه داخلی رخ نمی دهد. به سادگی، به جای عنصر در شاخص مشخص شده، یک عنصر جدید درج می شود، یعنی. مقدار را بازنویسی کنید

public void replaceAll(UnaryOperator<e> operator)

همه عناصر مجموعه را تغییر می دهد (ممکن است با یک شرط). بیشتر در ترکیب با لامبدا یا یک کلاس ناشناس استفاده می شود (اما برای وضوح، در مثال ما به سادگی از کلاسی استفاده می کنیم که رابط را پیاده سازی می کند) که اینترفیس را پیاده سازی می کند UnaryOperatorو متدهای آن را تعریف می کند. بیایید رابط را پیاده سازی کنیم:

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

در کلاس دیگر، بیایید یک ArrayList از Stringو یک شی از کلاس خود ایجاد کنیم که UnaryOperator:

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

varc1بیایید مقدار "White" را برای متغیر بنویسیم:

operator.varc1 = "White";

بیایید چند خط به لیست اضافه کنیم:

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

بیایید یک متد را در لیست اجرا کنیم replaceAllکه شی خود را به آن پاس می دهیم operator:

color_list.replaceAll(operator);

در نتیجه، تمام مقادیر موجود در لیست با "سفید" جایگزین شدند: [سفید، سفید، سفید، سفید، سفید، سفید]. و به این ترتیب، برای مثال، می توانید تمام فاصله ها را از رشته های موجود در مجموعه حذف کنید:

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

روش‌های دیگر: می‌توانید آرایه فهرست ArrayList را با استفاده از روش زیر به یک آرایه معمولی تبدیل کنید:

public Object[] toArray()

یا

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

- در اینجا نوع آرایه برگشتی تعیین می شود runtime این روش اجازه می دهد:

1. سرعت بخشیدن به برخی عملیات؛
2. ارسال یک آرایه به عنوان پارامتر به روشی که برای پذیرش مستقیم مجموعه، بیش از حد بارگذاری نشده باشد.
3. ادغام کدهای جدید مبتنی بر مجموعه با کدهای قدیمی که مجموعه ها را شناسایی نمی کند.

یک شیء کپی آرایه را برگردانید:

public Object clone()

لطفاً توجه داشته باشید که متد clone()نوع Object را برمی‌گرداند، بنابراین پس از فراخوانی آن، باید به کلاس مورد نیاز ارسال کنید. شبیه سازی یک شی مستقل جدید ایجاد می کند. مجموعه را برای وجود یک شی بررسی کنید:

public boolean contains(Object o)

وجود یک شی را در لیست بررسی می کند (به طور داخلی با استفاده از متد برابر از کلاس Object، به عنوان مثال مراجع را مقایسه می کند)، بسته به نتیجه، true/false را برمی گرداند. علاوه بر حلقه‌های معمول، می‌توانید با استفاده از:

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

به این صورت می توانیم لیست خود را نمایش دهیم:

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

بدون استفاده از lambdas باید از یک کلاس ناشناس استفاده کنید و روش acceptرابط را لغو کنید Consumer:

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

یک عنصر را با شاخص آن دریافت کنید:

public E get(int index)

برای دسترسی تصادفی به عناصر مجموعه استفاده می شود. عنصر واقع در لیست را در نمایه مشخص شده برمی گرداند. اگر حداکثر تعداد عناصر در لیست index < 0باشد یا باشد ، یک استثنا ایجاد می شود . این روش اساسی برای بازیابی یک عنصر از یک لیست است، و زمان بازیابی یک عنصر بر اساس شاخص، صرف نظر از اندازه ArrayList، همیشه یکسان خواهد بود، زیرا به یک سلول آرایه خاصی دسترسی دارد. یافتن شاخص برای اشیاء مشخص شده: index >=IndexOutOfBoundsException

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

متدها شاخص اولین عنصر (زمانی که شی داده شده برای اولین بار با آن مواجه می شود) یا آخرین رخداد (زمانی که شی داده شده آخرین بار با آن مواجه می شود) را در لیست برمی گرداند. اگر عنصر در لیست وجود نداشته باشد، متدها -1 را برمی‌گردانند. مجموعه را برای عناصر بررسی کنید:

public boolean isEmpty();

اگر لیست خالی باشد، متد true را برمی گرداند (به نظر می رسد که آیا فیلد برابر است یا خیر size 0)، در غیر این صورت false. اگر لیست فقط حاوی عناصر null باشد، متد false را برمی گرداند. به عبارت دیگر عناصر تهی نیز در این روش در نظر گرفته می شوند. تعداد عناصر موجود در یک لیست را بیابید:

public int size();

تعداد عناصر موجود در لیست (مقادیر فیلد اندازه) را برمی گرداند. ممکن است تعداد عناصر با ظرفیت (ظرفیت) فهرست متفاوت باشد. یک تکرار کننده برای یک لیست دریافت کنید:

public Iterator< E> iterator();

یک تکرار کننده برای یک لیست برای استفاده بعدی در یک حلقه یا هر پردازش دیگری برمی گرداند. تکرار کننده رفتار سریع شکست را پیاده سازی می کند. اگر در مجموعه اجرا شود و متوجه تغییراتی در آن شود (که با استفاده از روش‌های تکرارکننده به دست نیامده‌اند)، بلافاصله یک استثنا ایجاد می‌کند ConcurrentModificationException. تکرار کننده چیزی به نام دارد modification count. هنگامی که تکرار کننده پس از هر یک از مجموعه تکرار می کند next/hasNext/remove، این شمارنده را بررسی می کند. اگر با آنچه تکرارکننده انتظار داشت مطابقت نداشته باشد، یک استثنا ایجاد می کند. من تکرار کننده ها را به طور مفصل در اینجا در نظر نخواهم گرفت.

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

یک تکرار کننده لیست را برای یک لیست برای استفاده بعدی در یک حلقه یا هر پردازش دیگری برمی گرداند. رابط، ListIteratorرابط را Iteratorبرای پیمایش دو طرفه لیست و اصلاح عناصر آن گسترش می دهد. در نسخه بارگذاری شده، می توانید شاخصی را که "پیمایش" از آن آغاز می شود، عبور دهید. ایندکس در این حالت نشان دهنده اولین عنصری است که روش کار خود را از آن آغاز می کند next()و هنگامی که متد فراخوانی می شود، previous()پیمایش از عنصر زیر شاخص "شاخص عبور - 1" آغاز می شود.

public Spliterator <E> spliterator()

جاوا 8 نوع جدیدی از تکرارکننده دیرهنگام و سریع با شکست را به نام تکرارکننده جداکننده معرفی می‌کند. تکرار کننده های جداکننده به شما امکان می دهند روی یک دنباله از عناصر تکرار کنید، اما آنها به روشی متفاوت استفاده می شوند. مهمترین ویژگی رابط Spliterator توانایی آن در پشتیبانی از تکرار موازی بخش های جداگانه یک دنباله از عناصر و در نتیجه برنامه نویسی موازی است.