قائمة Java LinkedList

في هذا الدليل، سنكتشف فئة LinkedList بشكل مفصل من خلال العديد من الأمثلة.

يقدم فئة LinkedList في إطار Java Collections قائمة من وظائف بنية البيانات للقوائم.

واجهة تم تنفيذها باستخدام LinkedList

• Java List واجهة

• واجهة Queue في Java

• Java Deque واجهة

تنفيذ LinkedList في Java

يقدم فئة LinkedList في Java تنفيذًا للقائمة المزدوجة الاتجاه.

كل عنصر في قائمة الروابط يُدعىالنقطة. إنه يحتوي على 3 حقول:

• Prev - تخزين عنوان العنصر السابق في القائمة. العنصر الأول هو null.

• Next - تخزين عنوان العنصر التالي في القائمة. العنصر الأخير هو null.

• Data - تخزين البيانات الفعلية.

لا يتم تخزين العناصر في قائمة الروابط بشكل ترتيبي. على العكس من ذلك، إنها موزعة وتتصل عبر الروابط (Prev وNext).

في هذا السياق، تحتوي قائمة الروابط على 3 عناصر.

• Dog - سيعين العنصر الأول عنوان السابق null، وعنوان Cat كعنوان التالي

• Cat - سيعين العنصر الثاني عنوان Dog كعنوان السابق، وعنوان Cow كعنوان التالي

• Cow - سيعين العنصر الأخير عنوان Cat كعنوان السابق، وسيكون العنصر التالي null

إنشاء LinkedList

هذا هو كيفية إنشاء قائمة الروابط باستخدام Java:

LinkedList<Type> linkedList = new LinkedList<>();

في هذا المكان، Type يمثل نوع قائمة الارتباط. على سبيل المثال،

// إنشاء قائمة من نوع Integer
// إنشاء قائمة من نوع Integer
// إنشاء قائمة من نوع String
LinkedList<String> linkedList = new LinkedList<>();

إنشاء LinkedList باستخدام واجهة

دعونا نأخذ مثالاً.

List<String> animals1 = new LinkedList<>();

في هذا المكان، نستخدم واجهة List لإنشاء قائمة animals1، القائمة يمكنها الوصول فقط إلى طرق واجهة List.

دعونا نأخذ مثالاً آخر.

Queue<String> animals2 = new LinkedList<>();
Deque<String> animals3 = new LinkedList<>();

في هذا المكان، يمكن لـ animal2 الوصول إلى طرق واجهة Queue.

لكن animal3 يمكنه الوصول فقط إلى طرق واجهة Deque و Queue. هذا لأن Deque هي واجهة فرعية لـ Queue.

طرق LinkedList

يقدم LinkedList العديد من الطرق التي تمكننا من تنفيذ مختلف العمليات في القائمة.

إضافة العناصر إلى LinkedList

1. إضافة العناصر:استخدام طريقة add()

لإضافة عنصر (النقطة) إلى نهاية القائمة، نستخدم طريقة add(). على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　// إضافة العناصر إلى LinkedList
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Cat, Horse]

2. إضافة العناصر: إضافة العناصر باستخدام مؤشر

يمكننا أيضًا إضافة العناصر إلى القائمة باستخدام المؤشر. على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　// إضافة العناصر باستخدام المؤشر
　　　　　　　　animals.add(0, "كلب");
　　　　　　　　animals.add(1, "قط");
　　　　　　　　animals.add(2, "حصان");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Cat, Horse]

3. إضافة العناصر: إضافة قائمة إلى قائمة أخرى

لإضافة جميع عناصر قائمة إلى قائمة أخرى، نستخدم طريقة addAll(). على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> mammals = new LinkedList<>();
　　　　　　　　mammals.add("كلب");
　　　　　　　　mammals.add("قط");
　　　　　　　　mammals.add("حصان");
　　　　　　　　System.out.println("مammals: " + mammals);
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Crocodile");
　　　　　　　　// إضافة جميع العناصر من mammals إلى animals
　　　　　　　　animals.addAll(mammals);
　　　　　　　　System.out.println("Animals: " + animals);
　　　　{}
{}

نتائج الإخراج

Mammals: [Dog, Cat, Horse]
Animals: [Crocodile, Dog, Cat, Horse]

4. إضافة العناصر: باستخدام طريقة listIterator()

يمكننا أيضًا استخدام طريقة listsIterator() لضمان العناصر في قائمة الاتصال. لاستخدامها، يجب علينا استيراد حزمة java.util.ListIterator. على سبيل المثال،

استيراد java.util.ArrayList;
استيراد java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//إنشاء عنصر ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.add("Dog");
　　　　　　　　listIterate.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Cat]

زيارة عناصر LinkedList

1. زيارة العناصر: باستخدام طريقة get()

لزيارة العناصر في قائمة الاتصال، يمكننا استخدام طريقة get(). على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　// الحصول على العنصر من قائمة الاتصال
　　　　　　　　String str = animals.get(1);
　　　　　　　　System.out.print("العنصر في المكان 1: " + str);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Horse, Cat]
العنصر في المكان 1: Horse

2. زيارة العناصر: باستخدام طريقة iterator()

لتمرير عناصر قائمة الاتصال، يمكننا استخدام طريقة iterator(). يجب علينا استيراد حزمة java.util.Iterator لاستخدام هذه الطريقة. على سبيل المثال،

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　// إنشاء عميل Iterator
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(يتم تنفيذ iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

نتائج الإخراج

LinkedList: Dog, Cat, Horse,

في هذا السياق،

• hasNext() - إذا كان هناك عنصر تالي، العودة إلى true

• next() - العودة إلى العنصر التالي

3. زيارة العناصر: باستخدام طريقة listIterator()

يمكننا أيضًا استخدام طريقة listIterator() لتمرير عناصر قائمة الاتصال. لاستخدام هذه الطريقة، يجب علينا استيراد حزمة java.util.ListIterator.

طريقة listsIterator() أكثر ملاءمة للاستخدام في قوائم الاتصال. هذا لأنه يمكن للعنصر في listIterator() التمرير إلى الأمام أيضًا. على سبيل المثال

import java.util.LinkedList;
استيراد java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//إنشاء عنصر ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(listIterate.hasNext()) {
　　　　　　　　　　　　System.out.print(listIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　　　　　// تمرير إلى الأمام
　　　　　　　　System.out.print("\nتراجع LinkedList: ");
　　　　　　　　while(listIterate.hasPrevious()) {
　　　　　　　　　　　　System.out.print(listIterate.previous());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

نتائج الإخراج

LinkedList: الكلب، الحصان، القط،
LinkedList بالاتجاه المعكوس: القط، الحصان، الكلب،

في هذا السياق،

• hasNext() - إذا كان هناك عنصر تالي، العودة إلى true

• next() - العودة إلى العنصر التالي

• hasPrevious() - إذا كان هناك عنصر سابق، العودة إلى true

• previous() - العودة إلى العنصر السابق

البحث عن عناصر LinkedList

1. البحث عن العنصر: باستخدام طريقة contains()

للبحث عن ما إذا كانت قائمة الروابط تحتوي على عنصر معين، نستخدم طريقة contains(). على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//تحقق من وجود الكلب في القائمة
　　　　　　　　if(animals.contains("الكلب")) {
　　　　　　　　　　　　System.out.println("الكلب في LinkedList.");
　　　　　　　　{}
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Horse, Cat]
الكلب في LinkedList.

2. البحث عن العنصر: باستخدام طريقة indexOf()

• indexOf() - العودة إلى فهرس أول ظهور للعنصر

• lastIndexOf() - العودة إلى فهرس آخر ظهور للعنصر

على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//إضافة العنصر إلى القائمة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//أول ظهور للكلب
　　　　　　　　int index1 = animals.indexOf("الكلب");
　　　　　　　　System.out.println("فهرس أول ظهور للكلب: " + index1);
　　　　　　　　//آخر ظهور للكلب
　　　　　　　　int index2 = animals.lastIndexOf("الكلب");
　　　　　　　　System.out.println("فهرس آخر ظهور للكلب: " + index2);
　　　　{}
{}

نتائج الإخراج

LinkedList: [الكلب، الحصان، القط، الكلب]
فهرس أول ظهور للكلب: 0
فهرس آخر ظهور للكلب: 3

ملاحظة:إذا لم يتم العثور على العنصر المحدد، تعود indexOf() وlastIndexOf() بـ -1.

تعديل عناصر LinkedList

1. تعديل العنصر: باستخدام طريقة set()

لإجراء تعديل العناصر في قائمة الروابط، يمكننا استخدام طريقة set(). على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//تعديل عنصر القيمة عند الفهرس 3
　　　　　　　　animals.set(3, "الفيل القارص");
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [الكلب، الحصان، القط، الكلب]
LinkedList الجديدة: [الكلب، الحصان، القط، الفيل القارص]

2. تعديل العناصر: باستخدام طريقة listIterator()

يمكننا أيضًا استخدام طريقة listIterator() لتعديل العناصر في قائمة الاتصال. على سبيل المثال،

استيراد java.util.ArrayList;
استيراد java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//إضافة العنصر إلى القائمة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//إنشاء عنصر ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//تعديل العنصر المُرجع إلى next()
　　　　　　　　listIterate.set("Cow");
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Cat, Horse]
LinkedList جديدة: [Cow, Cat, Horse]

إزالة عناصر LinkedList

1. إزالة العناصر: باستخدام طريقة remove()

لإزالة العناصر من قائمة الاتصال، يمكننا استخدام طريقة remove(). على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Zebra");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//إزالة العنصر عند الرقم 1
　　　　　　　　String str = animals.remove(1);
　　　　　　　　System.out.println("إزالة العنصر: " + str);
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Horse, Cat, Zebra]
إزالة العنصر: Horse
LinkedList جديدة: [Dog, Cat, Zebra]

2. إزالة العناصر: باستخدام طريقة listIterator()

يمكننا أيضًا استخدام طريقة listsIterator() لإزالة العناصر من قائمة الاتصال. على سبيل المثال،

استيراد java.util.ArrayList;
استيراد java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//إنشاء عنصر ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//إزالة العنصر المُرجع إلى next()
　　　　　　　　listIterate.remove();
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Cat, Horse]
LinkedList جديدة: [Cat, Horse]

3. إزالة العناصر: باستخدام طريقة clear()

لإزالة جميع العناصر من قائمة الاتصال، نستخدم طريقة clear(). على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//إزالة جميع العناصر
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Cat, Horse]
LinkedList جديدة: []

ملاحظة:يمكننا أيضًا استخدام طريقة removeAll() ل�除 جميع العناصر. ولكن، طريقة clear() أكثر كفاءة من طريقة removeAll().

4. إزالة العنصر: باستخدام طريقة removeIf()

إذا كان العنصر ي满足了 معين الشروط، يمكننا أيضًا إزالة العناصر من السلسلة. لهذا، نستخدم طريقة removeIf(). على سبيل المثال،

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<Integer> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add(2);
　　　　　　　　animals.add(3);
　　　　　　　　animals.add(4);
　　　　　　　　animals.add(5);
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　// إزالة جميع العناصر الأقل من 4
　　　　　　　　animals.removeIf((Integer i)->i < 4);
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　　　　/** هنا نستخدم تعبير lambda
　　　　　　　* الآن تذكر
　　　　　　　* 参数 removeIf() هو شرط
　　　　　　　*/
　　　　{}
{}

نتائج الإخراج

LinkedList: [2, 3, 4, 5]
LinkedList جديدة: [4, 5]

ملاحظة: (Integer i)->i<4 هو تعبير lambda. للحصول على معلومات حول تعبير lambda، يرجى زيارةJava Lambda Expression

LinkedList كDeque وQueue

بما أن LinkedList قد وفرت أيضًا واجهات Queue وDeque، لذا يمكنها تنفيذ هذه الواجهات أيضًا. إليك بعض الطرق الشائعة:

طريقة addFirst() وaddLast()

• addFirst() - يضيف العنصر المحدد إلى بداية قائمة الاتصال

• addLast() - يضيف العنصر المحدد إلى نهاية قائمة الاتصال

على سبيل المثال،

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　// إضافة العنصر في بداية LinkedList
　　　　　　　　animals.addFirst("Cow");
　　　　　　　　animals.addFirst("Dog");
　　　　　　　　animals.addFirst("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//إضافة عنصر في نهاية LinkedList
　　　　　　　　animals.addLast("Zebra");
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Cat, Dog, Cow]
LinkedList جديدة: [Cat, Dog, Cow, Zebra]

طريقة getFirst() وgetLast()

• getFirst() - يعود إلى العنصر الأول

• getLast() - يعود إلى العنصر الأخير

على سبيل المثال،

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//إضافة العنصر إلى القائمة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　// من حزمة السلسلة الحصول على العنصر الأول
　　　　　　　　String str1 = animals.getFirst();
　　　　　　　　System.out.println("العنصر الأول: " + str1);
　　　　　　　　//الحصول على العنصر الأخير من القائمة
　　　　　　　　String str2 = animals.getLast();
　　　　　　　　System.out.println("العنصر الأخير: " + str2);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Horse, Cat]
العنصر الأول: Dog
العنصر الأخير: Cat

الطريقة removeFirst() و removeLast()

• removeFirst() - إزالة العنصر الأول

• removeLast() - إزالة العنصر الأخير

على سبيل المثال،

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//إضافة العنصر إلى القائمة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//إزالة العنصر الأول من LinkedList
　　　　　　　　String str1 = animals.removeFirst();
　　　　　　　　System.out.println("العنصر المزيل: " + str1);
　　　　　　　　//إزالة العنصر الأخير من LinkedList
　　　　　　　　String str2 = animals.removeLast();
　　　　　　　　System.out.println("العنصر المزيل: " + str2);
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Horse, Cat]
العنصر المزيل: Dog
العنصر المزيل: Cat
القائمة LinkedList الجديدة: [Horse]

الطريقة peek()

الطريقة peek() تعيد العنصر الأول من القائمة المرتبطة (الرأس). على سبيل المثال،

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//زيارة العنصر الأول من LinkedList
　　　　　　　　String str = animals.peek();
　　　　　　　　System.out.println("زيارة العنصر: " + str);
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Horse, Cat]
زيارة العنصر: Dog
الLinkedList الجديدة: [Dog, Horse, Cat]

الطريقة poll()

الطريقة poll() تعيد ويزيل العنصر الأول من القائمة المرتبطة. على سبيل المثال،

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//يعيد ويزيل العنصر الأول
　　　　　　　　String str = animals.poll();
　　　　　　　　System.out.println("العنصر المزيل: " + str);
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Horse, Cat]
العنصر المزيل: Dog
القائمة LinkedList الجديدة: [Horse, Cat]

الطريقة offer()

الطريقة offer() ستضيف العنصر المحدد إلى نهاية القائمة المرتبطة. على سبيل المثال،

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//إضافة عنصر في القائمة المرتبة
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//إضافة عنصر في نهاية LinkedList
　　　　　　　　animals.offer("Cat");
　　　　　　　　System.out.println("الLinkedList الجديدة: " + animals);
　　　　{}
{}

نتائج الإخراج

LinkedList: [Dog, Horse]
الLinkedList الجديدة: [Dog, Horse, Cat]

مرور على LinkedList الموجه

1.استخدام الدالة forEach لمرور

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//إنشاء قائمة مرتبة
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//استخدام الدالة forEach
　　　　　　　　System.out.println("استقبال عناصر القائمة المرتبة:");
　　　　　　　　for(String animal: animals) {
　　　　　　　　　　　　System.out.print(animal);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

نتائج الإخراج

LinkedList: [Cow،Cat，Dog]
استقبال عناصر القائمة المرتبة:
ال cow،ال قط،ال كلب،

2.استخدام الدوال الدائرية

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//إنشاء قائمة مرتبة
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//استخدام الدوال الدائرية
　　　　　　　　System.out.println("استقبال عناصر القائمة المرتبة:");
　　　　　　　　for(int i = 0; i < animals.size(); i++) {
　　　　　　　　　　　　System.out.print(animals.get(i));
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

نتائج الإخراج

LinkedList: [Cow،Cat，Dog]
استقبال عناصر القائمة المرتبة:
ال cow،ال قط،ال كلب،

في هذين المثالين، كنا نستخدم الدوال الدائرية لاستقبال عناصر القائمة المرتبة.

3.استخدام طريقة iterator()

يمكننا استخدام طريقة iterator() لاستقبال عناصر القائمة المرتبة. من أجل استخدام هذا الأسلوب، يجب علينا استيراد مكتبة java.util.Iterator.

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//إنشاء قائمة مرتبة
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " + animals);
　　　　　　　　//استخدام طريقة iterator()
　　　　　　　　System.out.println("استخدام طريقة iterator() من LinkedList:");
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　while(يتم تنفيذ iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　{}
　　　　{}
{}

نتائج الإخراج

LinkedList: [Cow،Cat，Dog]
استخدام LinkedList iterator() طريقة:
ال cow،ال قط،ال كلب،

LinkedList مقابل ArrayList

LinkedList و ArrayList كلاهما يحققان واجهة List من إطار Collections. ولكن، هناك بعض الاختلافات بينهما.