شرح مفصل لفئة المجموعات في جافا

بشكل عام ، تشمل هياكل البيانات في الكتب المدرسية صفائف وقوائم واحدة مرتبطة ومكدسًا وأشجارًا ورسومًا بيانية. بنية البيانات التي أؤكد إليها هنا هي مسألة كيفية تمثيل كائن. في بعض الأحيان ، لا يمكن إعلان متغير واحد عديمة الفائدة ، مثل int أو سلسلة أو مزدوجة أو حتى صفائف أحادية البعد والمصفوفات ثنائية الأبعاد لا يمكن أن تعبر تمامًا عن ما تريد التعبير عنه ، ومن المزعج للغاية تحديد فئة الفصل. في هذا الوقت ، يمكنك التفكير في استخدام فئة المجموعات في Java. باستخدام فئة المجموعات ، يجب أن تعلن استيراد java.util.* في رأس الملف ؛

1. ديناميكية ، مرتبة ، متغيرة الحجم ناقل أحادي البعد و arraylist

تتضمن فئة المجموعات المتجهات الديناميكية والمرتبة والمتغيرة ذات الحجم أحادي البعد و ArrayList.

الفرق الوحيد بين Vector و ArrayList هو: Vector يأتي مع مؤشرات الترابط بشكل متبادل ، وسوف ترمي مؤشرات الترابط المتعددة استثناءات للقراءة والكتابة ، بينما تتيح ArrayList مؤشرات ترابط متعددة للقراءة والكتابة ، والأجزاء الأخرى هي نفسها تمامًا. بمعنى آخر ، إذا كان موضوع واحد يقرأ ويكتب ، فلا يوجد فرق بين استخدام المتجه و arraylist ، ولكن الآن البرمجة هي في الأساس arraylist ، واستخدام المتجه غير مُحسّن قليلاً.
1. استخدام المتجه هو كما يلي:

 يعني void static void vectortest () {// vector <boutt> أن هذا المتجه يمكنه فقط تخزين Double // Vector <String> أن هذا المتجه يمكنه فقط تخزين السلسلة // على الرغم من أن المتجه <object> Vector = new Vector <Object> () ؛ يعادل المتجه المتجه = جديد // ناقلات () ؛ ومع ذلك ، فإن كتابة هذا في Eclipse ستحذرك ، مما يشير إلى أن المتجه الخاص بك ليس موحدًا ، () المتجه <object> Vector = new Vector <Object> () ؛ Vector.Add (1.6) ؛ Vector.Add (2.06) ؛ Vector.Add (1) ؛ System.out.println ("إضافة بسيطة تعني إضافة عناصر من النهاية:" + متجه) ؛ System.out.println ("size () يمكن أن تجد عدد العناصر الموجودة في المتجه:" + vector.size ()) ؛ Vector.remove (1) ؛ System.out.println ("إزالة (1) يعني حذف العنصر الأول ، لأن العدد يبدأ من 0 ، أي العنصر 2.06:" + ناقل) ؛ Vector.Remove (Vector.LastElement ()) ؛ System.out.println ("المتجه الذي يحذف العنصر الأخير هو:" + متجه) ؛ Vector.Add (0 ، 1.8888) ؛ System.out.println ("إضافة 1.8888 هذا العنصر في الموضع 0:" + ناقل) ؛ Vector.set (0 ، "A") ؛ System.out.println ("تغيير الموضع 0:" + متجه) ؛ }

إذا تم استدعاء هذه الطريقة في الوظيفة الرئيسية:

 System.out.println ("======== اختبار بدء بنية بيانات المتجه ==========") ؛ vectortest () ؛ system.out.println ("======== اختبار نهاية بنية بيانات المتجه =============) ؛

نتائج التشغيل كما يلي:
======== بدء تشغيل بنية بيانات المتجه ======
إضافة بسيطة تعني إضافة عناصر من النهاية: [1.6 ، 2.06 ، 1]
يمكن أن يجد الحجم () عدد العناصر الموجودة في المتجه: 3
إزالة (1) يعني حذف العنصر الأول. منذ أن يبدأ العدد من 0 ، أي العنصر 2.06: [1.6 ، 1]
المتجه الذي يحذف العنصر الأخير هو: [1.6]
أضف العنصر 1.8888 في الموضع 0: [1.8888 ، 1.6]
قم بتغيير العنصر في الموضع 0 إلى A: [A ، 1.6]
========= اختبار نهاية بنية بيانات المتجه ======

2. ArrayList

 public static void arraylisttest () {ArrayList <borted> ArrayList = new ArrayList <borted> () ؛ ArrayList.add (1.0) ؛ ArrayList.add (4.0) ؛ ArrayList.add (5.0) ؛ ArrayList.add (2.3) ؛ System.out.println ("إضافة بسيطة تعني إضافة عناصر من النهاية:" + ArrayList) ؛ System.out.println ("size () يمكن أن تجد عدد العناصر الموجودة:" + ArrayList.size ()) ؛ ArrayList.Remove (1) ؛ System.out.println ("إزالة (1) تعني حذف العنصر الأول. منذ أن يبدأ العدد من 0 ، أي العنصر 4:" + ArrayList) ؛ ArrayList.Remove (ArrayList.size () - 1) ؛ System.out.println ("ArrayList لحذف العنصر الأخير هو:" + ArrayList) ؛ ArrayList.add (0 ، 1.8888) ؛ System.out.println ("إضافة عنصر 1.8888 في الموضع 0:" + ArrayList) ؛ ArrayList.set (0 ، 9.0) ؛ System.out.println ("تغيير العنصر في الموضع 0 إلى A:" + ArrayList) ؛ Collections.sort (ArrayList) ؛ System.out.println ("يتم دعم الفرز إذا لم يكن ArrayList نوعًا تجريديًا" + ArrayList) ؛ }

هنا يمكنك أن ترى أن طريقة حذف ArrayList تختلف العنصر الأخير عن المتجه. السبب الرئيسي هو أن ArrayList ليس لديه طريقة LastElement () لإزالة العنصر الأخير. يمكن استخدام () فقط لتحديد موضع العنصر الأخير. إذا تم استدعاء هذه الطريقة في الوظيفة الرئيسية مثل هذه:

 System.out.println ("========= اختبار بدء تشغيل ArrayList بنية بيانات ArrayList =========") ؛ ArrayListTest () ؛ System.out.println ("======== اختبار نهاية ArrayList بنية بيانات ArrayList ================) ؛

ثم يتم الحصول على نتائج التشغيل التالية:
======= اختبار بدء تشغيل ArrayList بنية بيانات ======
إضافة بسيطة تعني إضافة عناصر من النهاية: [1.0 ، 4.0 ، 5.0 ، 2.3]
يمكن أن يجد الحجم () عدد العناصر الموجودة: 4
إزالة (1) يعني حذف العنصر الأول. منذ أن يبدأ العدد من 0 ، أي العنصر 4: [1.0 ، 5.0 ، 2.3]
قائمة ArrayList لحذف العنصر الأخير هي: [1.0 ، 5.0]
أضف العنصر 1.8888 في الموضع 0: [1.8888 ، 1.0 ، 5.0]
قم بتغيير العنصر في الوضع 0 إلى A: [9.0 ، 1.0 ، 5.0]
إذا لم يكن ArrayList نوعًا تجريديًا ، فسيتم دعم الفرز [1.0 ، 5.0 ، 9.0]
========= اختبار نهاية ArrayList هيكل بيانات ======

من مثالين أعلاه ، يمكننا أن نرى أن المتجه وقائمة ArrayList أكثر من مجرد صفيف عادي ، أي الصفيف أحادي البعد يتم تدريسه في صفيف int للكتب المدرسية [] = {8 ، 7 ، 100 ، 88 ، 6 ، 4 ، 5 ، 33 ، 7} ؛ إنه أقوى بكثير. يمكنك إدراج عناصر في أي موضع ، أو يمكنك حذف العناصر في موضع محدد دون اجتياز الصفيف. بالطبع ، لا تزال بحاجة إلى معرفة كيفية اجتياز هذه الصفيف لك. في الواقع ، يمكن تحويل ArrayList والمصفوفات أحادية البعد العادية بالكامل ، ويمكن أيضًا استخدام ArrayList لفرز الصفيف مباشرة دون كتابة نوع الفقاعة على الصفيف. يمكنك فرز المصفوفة مباشرة مع collections.sort () ؛ ثم استخدم collections.reverse () ؛ لتحقيق فرز عكسي. بالطبع ، لا يزال نفس الجملة. بالنسبة لك ، لا تزال بحاجة إلى معرفة كيفية فرز هذه الصفيف.

على سبيل المثال ، تنفذ الطريقة التالية الفرز والفرز العكسي لمصفوفة int أحادية البعد [] = {8 ، 7 ، 100 ، 88 ، 6 ، 4 ، 5 ، 33 ، 7} ؛ قم أولاً بتحويل المصفوفة إلى ArrayList ثم فرزها باستخدام collections.sort () ؛ and Collections.reverse () ؛ ، وأخيراً تحويل محتوى ArrayList إلى صفيف أحادي البعد:

 ArrayListsort public static void () {int array [] = {8 ، 7 ، 100 ، 88 ، 6 ، 4 ، 5 ، 33 ، 7} ؛ ArrayList <integer> ArrayList = new ArrayList <integer> () ؛ لـ (int i = 0 ؛ i <array.length ؛ i ++) system.out.print (Array [i]+"،") ؛ لـ (int i = 0 ؛ i <array.length ؛ i ++) ArrayList.add (Array [i]) ؛ Collections.sort (ArrayList) ؛ لـ (int i = 0 ؛ i <array.length ؛ i ++) ArrayList.add (Array [i]) ؛ Collections.sort (ArrayList) ؛ لـ (int i = 0 ؛ i <array.length ؛ i <array.length ؛ i ++) ArrayList.add (array [i]) ؛ Collections.sort (ArrayList) ؛ لـ (int i = 0 ؛ i <array.length ؛ i <array.length ؛ i ++) ArrayList.add (array [i]) ؛ Collections.sort (ArrayList) ؛ لـ (int i = 0 ؛ i <array.length ؛ i ++) Array [i] = ArrayList.get (i) ؛ System.out.print ("صفيف فرز:") ؛ لـ (int i = 0 ؛ i <array.length ؛ i ++) system.out.print (Array [i]+"،") ؛ collections.reverse (ArrayList) ؛ لـ (int i = 0 ؛ i <array.length ؛ i ++) Array [i] = ArrayList.get (i) ؛ System.out.print ("صفيف مصنّف عكسيًا:") ؛ لـ (int i = 0 ؛ i <array.length ؛ i ++) system.out.print (Array [i]+"،") ؛ // تدمير قائمة ArrayList بعد الفرز. arraylist = null ؛ // تشير هذه الجملة إلى أن جافا إعادة تدوير القمامة على الفور. بالطبع ، ما إذا كانت هذه الجملة على ما يرام أم لا ، ستقوم Java تلقائيًا بإزالة القمامة أثناء عملية التشغيل ؛ }

في الوظيفة الرئيسية ، تسمى الطريقة مثل هذا:

 System.out.println ("=========== Java Array sort start =========") ؛ arraylistsort () ؛ System.out.println ("=============== Java Array sort ends =========) ؛

يمكنك الحصول على نتائج التشغيل التالية:
========= يبدأ فرز مجموعة Java ======
8،7،100،88،6،4،5،33،7 ، صفيف فرز: 4،5،6،7،8،33،88،100 ، صفيف مصنّف عكسيًا: 100،88،33،8،7،6،6،5،4 ،
========= Java Array Forting نهايات ======
بالإضافة إلى ذلك ، ينطبق الشيء نفسه على "مقدمة موجزة لاستخدام القائمة في Java" (انقر لفتح الرابط)

2. مجموعة التجزئة
بالإضافة إلى ذلك ، هناك مجموعة من مجموعة التجميع ، والتي هي بالضبط نفس مفهوم جمع الرياضيات. تسمى مجموعة مكونة من عنصر أو أكثر مجموعة. Hashset لديه:
1. الحتمية . يجب أن تكون العناصر في المجموعة حتمية. هذا هراء. يجب أن تكون حتمية. هل لا يزال بإمكاني وضع شيء غير مؤكد فيه؟
2. الجنس المتبادل ، العناصر في المجموعة مختلفة. على سبيل المثال: تعيين A = {1 ، A} ، ثم لا يمكن أن يكون A يساوي 1 ، أي إذا وضعت اثنين 1S في مجموعة التجزئة ، فسيصبح تلقائيًا 1
3. الاضطراب ، لا يوجد ترتيب للعناصر في المجموعة. لذلك ، يجب ألا تقوم Hashset بعمليات الفرز ، على سبيل المثال ، الطريقة التالية:

 HashSettest static static static () {hashset <Object> hashset = new hashset <Object> () ؛ hashset.add (1) ؛ hashset.add (1) ؛ hashset.add (5) ؛ hashset.add (2.3) ؛ System.out.println ("إضافة بسيطة تعني إضافة عناصر من النهاية:" + hashset) ؛ System.out.println ("size () يمكن أن تجد عدد العناصر الموجودة:" + hashset.size ()) ؛ hashset.remove (1) ؛ System.out.println ("إزالة (1) يعني حذف العنصر" 1 ":" + hashset) ؛ hashset.remove ("ASD") ؛ System.out.println ("إذا لم يكن هناك عنصر" ASD "، فإن REMOME لا يفعل شيئًا:" + hashset) ؛ hashset.add (1.8888) ؛ system.out.println ("إضافة 1.8888 عنصر:" + hashset) ؛ }

في الوظيفة الرئيسية ، اتصل بهذه الطريقة:

 System.out.println ("========= اختبار بدء Hashset بنية بيانات =========") ؛ HashSettest () ؛ System.out.println ("========== اختبار نهاية Hashset بنية بيانات ===============) ؛

النتائج كما يلي:
======= يبدأ الاختبار بهيكل بيانات hashset ======
إضافة بسيطة تعني إضافة عناصر من النهاية: [1 ، 5 ، 2.3]
يمكن أن يجد الحجم () عدد العناصر الموجودة: 3
إزالة (1) تعني حذف العنصر "1": [5 ، 2.3]
بدون عنصر "ASD" ، لا يفعل الإزالة شيئًا: [5 ، 2.3]
أضف العنصر 1.8888: [5 ، 1.8888 ، 2.3]
========= اختبار نهاية بيانات Hashset =======
Hashset لديه طريقة add () وطريقة إزالة (). العناصر المضافة لإضافة () بالترتيب. قد تكون النتائج المطبوعة باستخدام system.out.println () في أوامر مختلفة. لا يمكن أن تكون هي نفسها المتجه و arraylist أعلاه. طالما أن العناصر المخزنة ليست كائنًا ، collections.sort (ArrayList) ؛ يمكن استخدامها لفرزها.

3. HASHMAP المزدوج
طريقة الاستخدام هنا هي نفس البيانات أعلاه ، كما أنها بسيطة للغاية. إنه وضع الكائن في الخريطة ، ويمكن الحصول على الكائنات الموجودة في الخريطة ، ولكن من الخطأ محاولة استخدام hashmap الثنائي في ثلاثية. إذا كان كائن يحتوي على الكثير من العناصر ، فيجب عليك التفكير في استخدام الفصول. بدلاً من أن تكون مهووسًا بفئة مجموعات Java التي تتداخل بين المتغيرات العادية وفئات الفصل.
على سبيل المثال ، تعرض الطريقة التالية تشغيل الخطأ لمحاولة تغيير HashMap إلى Triple:

 public static void maptest () {system.out.println ("============== بدء استخدام خطأ الخريطة ================) ؛ hashmap <string ، string> map = new hashmap <string ، string> () ؛ hashmap <string ، string >> () map.put ؛ System.out.println (BigMap.get ("test1"). GET ("key1") ؛ System.out.println (BigMap.get ("Test2"). GET ("key2")) ؛ بشكل غير صحيح ============================================================================================================================================== =========================================================== ============================================================= =========================================================== ============================================================= ============================================================= =============================================================

يمنح استدعاء هذا الرمز في الوظيفة الرئيسية نتيجة التشغيل التالية:
======== يبدأ الاختبار بهيكل بيانات الخريطة ======
======== بدء استخدام خطأ الخريطة ======
{test1 = {key2 = 4 ، key1 = 3} ، test2 = {key2 = 4 ، key1 = 3}}
3
4
3
4
======= نهاية استخدام خطأ الخريطة ======
========= بدء الاستخدام الصحيح للخريطة ======
{key3 = 3 ، key2 = 2 ، key1 = 1}
======== نهاية الاستخدام الصحيح للخريطة ======
========= اختبار نهاية بنية بيانات الخريطة =======
كان من المفترض في الأصل أن يكون هذا البرنامج واضحًا للغاية ، في محاولة لبناء {test1 ، key1،1} ، {test1 ، key2،2} ، {test2 ، key3،3} ، {test2 ، key4،4}
ومع ذلك ، فإن كل BigMap لا يزال لديه تلك الخريطة. بمجرد مسح الخريطة ، سيتم أيضًا مسح الخريطة في Test1. حاول شخص ما إنشاء MAP1 ، MAP2 ، ... ثم يمكنك أيضًا استخدام فئة بسيطة لتبدو أكثر وضوحًا ، ويمكنك كتابة أساليب في الفصل في المستقبل والورث

4. ملاحظات
عند إنشاء متجه جديد أو ArrayList أو Hashset أو HashMap ، يمكنك كتابته على النحو التالي:
Collection <Tring> a = new ArrayList <String> () ؛
قائمة <Tring> a = new vector <string> () ؛
نظرًا لوجود ArrayList و Vector و LinkedList و Hashset و Treeset التي ترث من واجهة التجميع ، و hashmap و hashtable التي ترث من واجهة الخريطة ، فهذه مشكلة من الميراث ، تعدد الأشكال ، التغليف وغيرها من الفئات في Java. بالطبع ، لكي يرى رفاقك بشكل أكثر وضوحًا ، لا تلعب تسمية خيالية هنا ، اكتب قائمة ArrayList واضحة <integer> arraylist = new ArrayList <integer> () ؛ لا أحد يجرؤ على القول أنك لا تفهم الفصول الدراسية في جافا.

ما سبق هو كل محتوى هذه المقالة. آمل أن يكون ذلك مفيدًا لتعلم الجميع وآمل أن يدعم الجميع wulin.com أكثر.