4 العنصر الرابع : سلسلة تعلم الجافا من الصفر"تجميعة الفريمورك تبع الجافا"

 قبل التعمق في شرحنا عن array  وغيرها ما علينا معرفته هو  تجميعة الفريم ورك تبع الجافا ، حيث تعرف تجميعة الجافا عبارة  عن كلاسات  class  او تجميعة هياكل بينات data  structures اي انها تتيح لنا تخزين  عدة عناصر ithem  في وحدة  واحدة . بشكل ديناميكي بحيث تحتوي على  كل من (Hashtable,HashSet,HashMap,LinkedList,Vector,Stack,ArrayList) جميعها مجمعة كوحدة  تسما الفريم ورك تبع الجافا Collection Framework التي تفرض بدورها سلوك  موحد لجميع الطبقات المبنية عليها هذا  الفريم ورك



قبل متابعة الدرس  انصحك اخي  الكريم  بالاطلاع على الدروس  السابقة  حتى يسهل عليك  فهم الدروس  التالية: 

1 العنصر الأول: سلسلة تعلم لغة الجافا من الصفر " تعريف ".

2 العنصر الثاني : سلسلة تعلم الجافا من الصفر "أساسيات الجافا".

3 العنصر الثالث : سلسلة تعلم الجافا من الصفر "هياكل البينات"


بالنسبة لاغلب التطبيقات ، كمطور ارغب بالتحكم  وانشاء مجموعة من الكائنيات المتصلة فيما بينها.  هناك خياران لتجميع الكائنات: عن طريق إنشاء مصفوفات  creating arrays من الكائنات ،أو إنشاء مجموعات  creating collections من الكائنات. توفر المجموعات طريقة أكثر مرونة للعمل مع مجموعات الكائنات. على عكس المصفوفات ، هذه المجموعة من الكائنات قوية ويمكن أن تتحكم فيها  بسهولة دون الحاجة إلى إعادة تعريفها. بالنسبة لبعض المجموعات ، يمكنك تعيين مفتاح لأي كائن تضعه في المجموعة بحيث يمكنك استرداد الكائن بسرعة باستخدام  ذلك المفتاح. إن تخطيط السعة والخوارزميات algorithms المحددة مسبقًا للفرز والبحث والمعالجة تجعلها سهلة الاستخدام. المصفوفة ، مع ذلك ، لا تدعم ما يسمى بالتخصيص الديناميكي dynamic allocation - لها طول ثابت لا يمكن تغييره بمجرد تخصيصه. علاوة على ذلك ، المصفوفة هي بنية خطية بسيطة. قد تتطلب العديد من التطبيقات بنية بيانات أكثر تعقيدًا مثل القائمة المرتبطة أو المكدس أو جدول التجزئة أو المجموعات أو الأشجار

شرح مبسط عن هياكل  البينات المكدس 


تحتوي الجافا على   حزمة تجميعة الفريم  ورك (java.util) التالي: 

  • واجهات  Interfaces
  • تطبيق  Implementations
  • الخوارزميات Algorithms

الواجهة interface

توفر واجهات Java Collections Framework نوع البيانات المجردة لتمثيل المجموعة. تُعرف هياكل البيانات المشتقة من واجهة المجموعة باسم إطار عمل المجموعات. java.util.Collection هي الواجهة الجذرية لـ Collections Framework. إنها في أعلى التسلسل الهرمي لإطار عمل المجموعات. اثنين من الواجهات الفرعية الرئيسية هي قائمة List  وتعيينSet . يتم تجاوز طرق واجهة المجموعة بواسطة فئات مختلفة بطرق مختلفة وفقًا لمتطلباتهم. لا تقبل بعض فئات المجموعة القيم المكررة مثل HashSet و TreeSet. تأتي واجهة المجموعة مع العديد من الطرق بحيث يمكن استخدام كل فئة مشتقة بشكل جيد. يحتوي على بعض الطرق المهمة مثل ا ()size(), iterator(), add(), remove(), clear التي يجب على كل فئة مجموعة تنفيذها. تبقى فقط الخريطة هي الواجهة الوحيدة التي لا ترث من واجهة المجموعة ولكنها جزء من إطار عمل المجموعات. جميع واجهات إطار عمل المجموعات موجودة في حزمة java.util.


تطبيق  Implementations


يأتي إطار عمل مجموعات Java مع العديد من فئات التنفيذ للواجهات. يمكننا استخدامها لإنشاء أنواع مختلفة من المجموعات في برنامج جافا. التطبيقات الأكثر شيوعًا هي ArrayList و HashMap و HashSet. بعض فئات المجموعات الهامة الأخرى هي LinkedList و TreeMap و TreeSet. هذه هي التطبيقات الملموسة لواجهات المجموعة. في جوهرها ، هي هياكل بيانات قابلة لإعادة الاستخدام. تحل هذه الفئات معظم احتياجات البرمجة لدينا ، ولكن إذا احتجنا إلى فئة مجموعة خاصة ، فيمكننا توسيعها لإنشاء فئة المجموعة المخصصة الخاصة بنا. استخدام تطبيق شائع حالي يجعل التعليمات البرمجية أقصر وأسرع في التنزيل. أيضًا ، يضمن استخدام Core Java Code Core الحالي أن أي تحسينات على الكود الأساسي ستعمل أيضًا على تحسين أداء التعليمات البرمجية الخاصة بك. جاء Java 1.5 مع فئات تجميع خيط آمنة سمحت بتعديل المجموعات أثناء التكرار عليها ، وبعضها CopyOnWriteArrayList و ConcurrentHashMap و CopyOnWriteArraySet. هذه الفئات موجودة في الحزمة java.util.concurrent. جميع فئات المجموعة موجودة في الحزمة java.util و java.util.concurrent.


الخوارزميات Algorithms

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

المصفوفات القائمية  ArrayList 

المصفوفات  هي عبارة  عن كائن  احتوائي على قيم محددة من نفس النوع.، لنفترض انه لديك  عدد من القيم الاعداد الصحيحة  وقيم عبارة  عن string  سلاسل (ارقام وحروف .. ألخ) في الغالب ستحتاج  الى انشاء مصفوفة  للاعداد الصحيحة  ومصفوفة للسلاسل  وهذا سيقوض  عملية الترتيب ، لكن  كيف سندمج بين هذه القيم  المختلفة  وكيف سنضيف حجم المصفوفة بعد الانتهاء  هنا  يقع الحل  الامثل لاستخدام ArrayList 

ArrayList  او المصفوفات القائمية هي عبارة  عن فئة تهتم بواجهة القائمة واكثر مرونة في المجموعة  framwork للجافا ، فهي تضيف بشكل ديناميكي حجم المصفوفة  وتحتوي على اكبر عدد من القيم المختلفة  والغير  المتجانسة ويمكنها ان تحتوي على  عناصر مكررة ايضا ويمكن الوصول  الى  هذه المصفوفة القائمية  من خلال فهرس مكون  من الاعداد  الصحيحة الطبيعية جدول يظهر دريقة الفهرسة بالادراج اعتبارا من العدد 0 هو القيمة  التي انطلف منها الفهرسة 


كيف تضيف عنصر داخل مصفوفة قائمية  ArrayList  

import java.util.*;
class TestClass
{
 public static void main (String[] argsthrows java.lang.Exception
 {
  // هنا تم انشاء كائن  جديد
   ArrayList aList = new ArrayList(); 
//0العنصر المضاف له قيمة 
   aList.add("الأحد"); 
//1العنصر المضاف له قيمة
   aList.add("الاثنين");  
//العنصر المضاف له قيمة 2
   aList.add("الثلثاء"); 
 }
}


طريقة طباعة المصفوفة  

import java.util.*;
class TestClass
{
 public static void main (String[] argsthrows java.lang.Exception
 {
   // هنا تم انشاء كائن  جديد
   ArrayList aList = new ArrayList();
 //0 العنصر المضاف له قيمة
   aList.add("الأحد"); 
//1 العنصر المضاف له قيمة
   aList.add("الاثنين"); 
//2 العنصر المضاف له قيمة 
   aList.add("الثلثاء");  
   //طباعة قائمة المصفوفة القائمية 
   Iterator ir=aList.iterator();
   while(ir.hasNext()){
 System.out.println(ir.next());

}
}


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

  ArrayList aList = new ArrayList(); 

//0 العنصر المضاف له قيمة
   aList.add("الأحد"); 
//1 العنصر المضاف له قيمة
   aList.add("الاثنين"); 
//2 العنصر المضاف له قيمة 
   aList.add("الثلثاء");
 //معرفة حجم  مصفوفة في الجافا
   System.out.println(aList.size())

عند استخدام الاسلوب او method size فاننا بكل سهولة نستطيع  تحديد  حجم المصفوفة  ويمكن ارجاع القيمة  داخل  كائن المصفوفة  .

طريقة  طباعة  قيمة  محددة  من المصفوفة 

  //جلب قيمة  محددة من المصفوفة 
   System.out.println(aList.get(1));
 //وهذه الطريقة لجلب القيمة الاولى اي مصفوفة
   System.out.println(aList.get(0));


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

System.out.println(aList.get(aList.size()-1));

بما ان alist.get  تاتي بالاندكس للمصفوفة اي القيمة الاولى المتمثلة في 0 فان slist.size  تاتي بالحجم الخاص باكبر قيمة في المصفوفة  الخدعة في وضع ناقص واحد لكي تعود الى اخر المصفوفة  

 خواص  الازالة  والحذف 

تقريبا لهما نفس الدور  حت  عند التجربة  تعطيك نفس النتيجة  

ArrayList aList = new ArrayList(); // هنا تم انشاء كائن  جديد
//0 العنصر المضاف له قيمة
   aList.add("الأحد"); 
//1 العنصر المضاف له قيمة
   aList.add("الاثنين"); 
//2 العنصر المضاف له قيمة 
   aList.add("الثلثاء");

System.out.println(aList.size());//طباعة حجم القائمة
aList.clear();//ازالة القائمة
System.out.println(aList.size());



ArrayList aList = new ArrayList(); // هنا تم انشاء كائن  جديد
//0 العنصر المضاف له قيمة
   aList.add("الأحد"); 
//1 العنصر المضاف له قيمة
   aList.add("الاثنين"); 
//2 العنصر المضاف له قيمة 
   aList.add("الثلثاء");
System.out.println(aList.size());//طباعة حجم القائمة
aList.removeAll(aList);//حدف القائمة
System.out.println(aList.size());


لهمنا نفس النتيجة  وهي  3  ثم 0   في المخرج  

الفرق الوحيد بينهما انه clear  اسرع  من remove  لانه تختصر الوقت وتتعمل مع كل عنصر داخل  المصفوفة وتضبط كل مدخل  في المصفوفة  من قيمته 

طريقة الازالة عبر  الكائن object 

ArrayList aList = new ArrayList(); // هنا تم انشاء كائن  جديد
//0 العنصر المضاف له قيمة
   aList.add("الأحد"); 
//1 العنصر المضاف له قيمة
   aList.add("الاثنين"); 
//2 العنصر المضاف له قيمة 
   aList.add("الثلثاء");
//ازالة الكائن
aList.remove("الاثنين");

وهناك  طريقة اخرى  عبر  الاندكس ولنفترض اننا  نريد  ازالة الاثنين من المصفوفة  

ArrayList aList = new ArrayList(); // هنا تم انشاء كائن  جديد
//0 العنصر المضاف له قيمة
aList.add("الأحد"); 
//1 العنصر المضاف له قيمة
   aList.add("الاثنين"); 
//2 العنصر المضاف له قيمة 
   aList.add("الثلثاء");
//ازالة الكائن
aList.remove("1");


مذا لو اردنا تخزين هذه المصفوفة  

ArrayList aList = new ArrayList();
aList.add("الأحد"); 
aList.add("الاثنين"); 
 aList.add("الثلثاء");
System.out.println("قبل التخزين......");
Iterator ir=aList.iterator();
while(ir.hasNext()){
  System.out.println(ir.next());
}
Collections.sort(aList);
System.out.println("بعد التخزين.......");
ir=aList.iterator();
while(ir.hasNext()){
  System.out.println(ir.next());
}


المخرج يكون كالتالي 

قبل التخزين........

لاحد الاثنين الثلاثاء 

بعد التخزين  ......

الاثنين الاحد  الثللاثاء 

مع العلم اني وضعت بدل  الاحرف  اللاتنية عربية  فالعربية لن  يتعرف عليها المترجم  فقط لتبسيط الدروس 

وهذه الطريقة  لقلب المصفوفة  بالعكس 

Collections.sort(aList,Collections.reverseOrder());
Iterator ir=aList.iterator();
while(ir.hasNext()){
  System.out.println(ir.next());
}


طرق البحث  في  المصفوفة القائمية  

// انشاء كائن جديد
ArrayList aList = new ArrayList();
aList.add("الاثنين");
aList.add("الثلثاء");
aList.add("الاربعاء");
//استخدام اسلوب الاحتواء
if (aList.contains("الاثنين")) {
  System.out.println("تم الايجاد");
else {
  System.out.println("لم يتم الايجاد");
}
//استخدام اسلوب الاندكس او الفهرسة
int val = aList.indexOf("الاثنين");
if (val !=-1) {
  System.out.println("تم الايجاد");
else {
  System.out.println("لم يتم الايجاد");
}
//استخدام اسلوب اخر للفهرسة
int val = aList.lastIndexOf("الاثنين");
if (val !=-1) {
  System.out.println("تم الايجاد");
else {
  System.out.println("لم يتم الايجاد");
}


تحويل مصفوفة قائمية لمصفوفة  

// انشاء كائن جديد
ArrayList aList = new ArrayList();
aList.add("الاثنين");
aList.add("الثلثاء");
aList.add("الاربعاء");
//عملية التحويل
String[] arr = (String[])aList.toArray(new String[aList.size()]);
for(String item : arr)
  System.out.println(item);


وهذه  عملية تحويل معاكسة  لمصفوفة عادية  الى  مصفوفة قائمية  

String days[]={"الاثنين""الثلثاء""الاربعاء"};
ArrayList < StringarrListnew ArrayList < String>(Arrays.asList(days));
for(String item : arrList)
  System.out.println(item);


وبامكانك ايضا تحويلها  الى سلاسل string

ArrayList aList = new ArrayList();
aList.add("الاثنين");
aList.add("الثلثاء");
aList.add("الاربعاء");
//عملية التحويل
String result = String.join(",", aList);
System.out.println(result);


وايضا يمكنك انشاء قائمة بكل بساطة  

// انشاء كائن جديد
ArrayList aList = new ArrayList();
aList.add("الاثنين");
aList.add("الثلثاء");
aList.add("الاربعاء");
//عملية التحويل
List list = aList;
Iterator ir=list.iterator();
while(ir.hasNext()){
  System.out.println(ir.next());


هنا  برنامج  فيه كل ما  شرحناه  عن المصفوفة القائمية 

import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
    //انشاء كائن جديد
      ArrayList aList = new ArrayList();
      aList.add("الإثنين");
      aList.add("الثلاثاء");
      aList.add("الاربعاء");
      //استخدام  عملية التكرار لمعرفة  عناصر المصفوفة القائمية 
      Iterator < Stringitr = aList.iterator();
          while(itr.hasNext()){
          System.out.println(itr.next());
      }
      //اضافة عنصر الى مصفوفة  محددة
      aList.add(2,"الخميس");
      System.out.println(aList);
      //استرجاع عنصر من المصفوف  من خلال الفهرس
      System.out.println(aList.get(2));
      //البحث عن  عنصر في المصفوفة
      if(aList.contains("الثلاثاء"))
          System.out.println("تم اجاد العنصر");
      else
          System.out.println("لا يوجد هذا  العنصر");
      //ازالة عنصر واحد من المصفوفة 
      aList.remove(1);
      System.out.println(aList);
      //ازالة كل  العناصر من المصفوفة 
      aList.clear();
      //التاكد من ان المصفوفة  فارغة 
      if(aList.isEmpty())
          System.out.println("المصفوفة  فارغة");
      else
          System.out.println("المصفوفة تحتوي على: " + aList.size() + " عنصر  !!");
  }
}


hashmap

في الهاش ماب يمكننا تخزين قيمة الكائن  من خلال  مفتاح  للقيمة  k  نعني  بها المفتاح  و v القيمة  وهما اختصارل  key& value 

HashMap<K,V>

طريقة اضافة  عنصر داخل الهاش ماب 

import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
     //انشاء هاش ماب
     HashMap<Integer,Stringdays = new HashMap<Integer,String>();
     //هنا اضافة المفتاح مع القيمة
     days.put(1,"الاحد");
     days.put(2,"الاثنين");
     days.put(3,"الثلاثاء");
     days.put(4,"الاربعاء");
}
}

لمعرفة  حجم الهاش ماب نضيف السطر التالي 

import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
     //انشاء هاش ماب
     HashMap<Integer,Stringdays = new HashMap<Integer,String>();
     //هنا اضافة المفتاح مع القيمة
     days.put(1,"الاحد");
     days.put(2,"الاثنين");
     days.put(3,"الثلاثاء");
     days.put(4,"الاربعاء");
     //لطباعة حجم الهاش ماب
     System.out.println("حجم الهاش ماب: "days.size());
}
}

هناك  عدة طرق  لاظهار العناصر من الهاش ماب 

     //انشاء هاش ماب
     HashMap<Integer,Stringdays = new HashMap<Integer,String>();
     //هنا اضافة المفتاح مع القيمة
     days.put(1,"الاحد");
     days.put(2,"الاثنين");
     days.put(3,"الثلاثاء");
     days.put(4,"الاربعاء");
     //لطباعة حجم الهاش ماب
     Set<Map.Entry<Integer,String>> set = days.entrySet();
     for (Map.Entry<Integer,Stringsg : set) {
       System.out.println("Key :"+sg.getKey() + "   Value :"+days.get(sg.getKey()));
     }

Key :1   Value :الاحد

Key :2   Value :الاثنين

Key :3   Value :الثلاثاء

Key :4   Value :الاربعاء

ويمكننا  استخدام  for loop  بشكل مختصر 

     for(Integer key: days.keySet()){
        System.out.println(key  +" :: "days.get(key));
      }


1  ::الاحد

 2  : :الاثنين

3   : :الثلاثاء

4  : :الاربعاء


استخدام while loop 

     Set set = days.entrySet();
     Iterator i = set.iterator();
     while(i.hasNext()) {
        Map.Entry me = (Map.Entry)i.next();
        System.out.print(me.getKey() + ": ");
        System.out.println(me.getValue());
     }


ازالة  عنصر من الهاش ماب 

     //انشاء هاش ماب
     HashMap<Integer,Stringdays = new HashMap<Integer,String>();
     //هنا اضافة المفتاح مع القيمة
     days.put(1,"الاحد");
     days.put(2,"الاثنين");
     days.put(3,"الثلاثاء");
     days.put(4,"الاربعاء");
     //لطباعة حجم الهاش ماب
     days.remove(3);
     System.out.println("القيمة المزالة: "days);


القيمة المزالة : {1=الاحد، 2=الاثنين،4=الاربعاء}

يمكنك تغيير القيمة لكن حسب حجم الهاش ماب

طريقة  ازالة جميع الداتا من الهاش ماب

     //انشاء هاش ماب
     HashMap<Integer,Stringdays = new HashMap<Integer,String>();
     //هنا اضافة المفتاح مع القيمة
     days.put(1,"الاحد");
     days.put(2,"الاثنين");
     days.put(3,"الثلاثاء");
     days.put(4,"الاربعاء");
     System.out.println("قبل الازالة: "days.size());
     // ازالة الكل من الهاش ماب
     days.clear();
     System.out.println("بعد الازالة: "days.size());
}

طريقة البحث   عن  مفتاح  محدد في  الهاش ماب 

     Integer key=4;
     if(days.containsKey(key)){
       System.out.println("Key " + key + " found");
     }else{
       System.out.println("Key " + key" does not exist");
     }


ويمكنك  ايضا اجاد مفتاح  محدد  من خلال  القيمة   في  الهاش  ماب 

import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
     //انشاء هاش ماب
     HashMap<Integer,Stringdays = new HashMap<Integer,String>();
     //هنا اضافة المفتاح مع القيمة
     days.put(1,"الاحد");
     days.put(2,"الاثنين");
     days.put(3,"الثلاثاء");
     days.put(4,"الاربعاء");
     Integer keynull;
     String value="الثلاثاء";
     for(Map.Entry entry: days.entrySet()){
         if(value.equals(entry.getValue())){
             key = (Integer)entry.getKey();
             break
         }
     }
     System.out.println("المفتاج : "key +" القيمة: " + value);
}
}


البرنامج التالي  فيه  كل ما تحتاج  معرفته في الهاش ماب 

import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
    //انشاء هاش ماب
    HashMap <Integer,Stringdays = new HashMap <Integer,String>();
    //اضافة مفاتيح وقيم
    days.put(1,"الاحد");
    days.put(2,"الاثنين");
    days.put(3,"الثلاثاء");
    days.put(4,"الاربعاء");
    days.put(5,"الخميس");
    days.put(6,"الجمعة");
    days.put(7,"السبت");
    //طريقة استخراج العناصر من الهاش ماب
    for(Map.Entry m:days.entrySet()){
        System.out.println(m.getKey()+" "+m.getValue());
    }
    //ازالة عنصر محدد من الهاش ماب
    days.remove(3);
  Set<Map.Entry<Integer,String>> set = days.entrySet();
  for (Map.Entry<Integer,Stringsg : set) {
    System.out.println("Key :"+sg.getKey() + "   Value :"+days.get(sg.getKey()));
  }
  //البحث  من خلال  المفتاح 
  Integer key=4;
  if(days.containsKey(key)){
    System.out.println("Key " + key + " found");
  }else{
    System.out.println("Key " + key" does not exist");
  }
  //البحث عن المفتاح  من خلال  القيمة
    Integer iKeynull;
    String value="Monday";
    for(Map.Entry entry: days.entrySet()){
      if(value.equals(entry.getValue())){
        iKey = (Integer)entry.getKey();
        break
      }
    }
    System.out.println("Found Key : "iKey +" value: " + value);
    //ازالة جميع العناص من الهاش ماب
    days.clear();
    //احتساب حجم الهاش ماب بعد الازالة 
    System.out.println("After remove: "days.size());
  }
}


  • الهاش ماي غير متزامن وهذا يجعله افضل  للتطبيقات الغير المترابطة  حيث الكائم الغير المتزامن يؤدي دائما عمل  افضل من تلك المتزامنة 
  • يسمح الهاش ماب بمفتاح واحد فارغ وأي عدد من القيم الخالية
  • في الهاش ماب ، يمكنك إزالة العنصر أثناء التكرار بأمان
  • يمكنك بسهولة تبديل الهاش ماب بـ LinkedHashMap.
  • بالنظر إلى الأداء ، فإن الهاش ماب أسرع بكثير ويستخدم ذاكرة أقل


hashtable


Hashtable هي بنية بيانات تُستخدم لتنفيذ مصفوفة ترابطية ، وهي بنية يمكنها تعيين المفاتيح للقيم. يمكن أن يوفر طريقة فعالة للغاية للبحث عن العناصر بكميات كبيرة من البيانات ، وخاصة البيانات التي لا يمكن البحث عنها بسهولة. يمكن أن يحتوي Hashtable على عناصر فريدة فقط وقد لا يحتوي على أي مفتاح أو قيمة خالية. إنه مشابه تقريبًا لـ HashMap ، ولكنه متزامن. القاموس هو فئة أساسية مجردة من Hashtable. ومع ذلك



تُستخدم خوارزمية التجزئة لتوليد فهرس في تلك المصفوفة بناءً على قيم العنصر الذي سيتم تخزينه في المصفوفة. عادةً ما يكون الحد الأقصى لحجم هذه المصفوفة أصغر من عدد العناصر في مجموعة القيم الممكنة لنوع البيانات المخزنة في علامة التجزئة. عند إضافة عنصر إلى Hashtable ، يتم وضع العنصر في حاوية استنادًا إلى كود التجزئة الخاص بالمفتاح. يمكن أن تحتوي كل مجموعة على سجلات متعددة منظمة بترتيب معين. تستخدم عمليات البحث اللاحقة للمفتاح رمز التجزئة الخاص بالمفتاح للبحث في مساق معين واحد فقط ، وبالتالي تقليل عدد المقارنات الرئيسية المطلوبة للعثور على عنصر بشكل كبير. يحدد عامل تحميل جدول التجزئة الحد الأقصى لنسبة العناصر إلى المجموعات. تتسبب عوامل التحميل الأصغر في متوسط ​​أوقات البحث الأسرع على حساب زيادة استهلاك الذاكرة. يحتوي مثيل Hashtable على معلمتين تؤثران على أدائه: السعة الأولية وعامل التحميل. السعة هي عدد الحاويات في جدول التجزئة ، والسعة الأولية هي ببساطة السعة في وقت إنشاء جدول التجزئة

import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
        //انشاء هاش تيبل?
        Hashtable <Integer,Stringdays = new Hashtable <Integer,String>();
        //اضافة قيمة ومفتاح
        days.put(1,"الاثنين");
        days.put(2,"الثلاثاء");
        days.put(3,"الاربعاء");
        days.put(4,"الخميس");
        days.put(5,"الجمعة");
        days.put(6,"السبت");
        days.put(7,"الاحد");
        //استخراج عناصر من الهاش تيبل 
        for(Map.Entry m:days.entrySet()){
            System.out.println(m.getKey()+" "+m.getValue());
        }
        //طريقة الازالة من الهاش تيبل 
        days.remove(3);
        Set<Map.Entry<Integer,String>> set = days.entrySet();
        for (Map.Entry<Integer,Stringsg : set) {
          System.out.println("Key :"+sg.getKey() + "   Value :"+days.get(sg.getKey()));
        }
        //البحث من خلال مفتاح  محدد
        Integer key=4;
        if(days.containsKey(key)){
            System.out.println("Key " + key + " found");
        }else{
            System.out.println("Key " + key" does not exist");
        }
        //جلب قيمة المفتاح  من خلال عنصر
        Integer iKeynull;
        String value="الثلاثاء";
        for(Map.Entry entry: days.entrySet()){
            if(value.equals(entry.getValue())){
                iKey = (Integer)entry.getKey();
                break//breaking because its one to one map
            }
        }
        System.out.println("Found Key : "iKey +" value: " + value);
        //ازالة الكل
        days.clear();
        //طباعة حجم الهاش تيبل 
        System.out.println("After remove: "days.size());
    }
}


tree map

تطبق فئة TreeMap واجهة Map مشابهة لفئة HashMap. يحافظ على إدخالاته بترتيب تصاعدي ، مرتبة وفقًا للترتيب الطبيعي للمفاتيح ، أو وفقًا لمقارن يعتمد على السيط المُنشئ. بخلاف LinkedHashMap و HashMap ، لا يستخدم TreeMap التجزئة لتخزين المفاتيح. يستخدم بنية بيانات تسمى شجرة الأحمر والأسود

تنفيذ TreeMap غير متزامن. إذا كانت عدة مؤشرات ترابط تصل إلى TreeMap بشكل متزامن ، ويقوم واحد على الأقل من العناصر بتعديل TreeMap هيكليًا ، يجب مزامنته خارجيًا. تعتبر فئة TreeMap مثالية لاجتياز المفاتيح بترتيب مصنف. يمكن فرز المفاتيح باستخدام الواجهة المقارنة أو واجهة المقارنة. يمكنك تحديد ترتيب الفرز أثناء إنشاء TreeMap من خلال توفير مقارنة صريحة لـ TreeMap. علاوة على ذلك ، فإنه يوفر الطريقتين firstKey () و lastKey () لإعادة المفتاحين الأول والأخير في الخريطة ، و headMap (toKey) و tailMap (fromKey) لإعادة جزء من الخريطة تكون مفاتيحه أقل من toKey وأكبر من أو يساوي fromKey.

import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
        //انشاء هاش تيبل?
        TreeMap  <Integer,Stringdays = new TreeMap  <Integer,String>();
        //اضافة قيمة ومفتاح
        days.put(1,"الاثنين");
        days.put(2,"الثلاثاء");
        days.put(3,"الاربعاء");
        days.put(4,"الخميس");
        days.put(5,"الجمعة");
        days.put(6,"السبت");
        days.put(7,"الاحد");
        //استخراج عناصر من الهاش تيبل 
        for(Map.Entry m:days.entrySet()){
            System.out.println(m.getKey()+" "+m.getValue());
        }
        //طريقة الازالة من الهاش تيبل 
        days.remove(3);
        Set<Map.Entry<Integer,String>> set = days.entrySet();
        for (Map.Entry<Integer,Stringsg : set) {
          System.out.println("Key :"+sg.getKey() + "   Value :"+days.get(sg.getKey()));
        }
        //البحث من خلال مفتاح  محدد
        Integer key=4;
        if(days.containsKey(key)){
            System.out.println("Key " + key + " found");
        }else{
            System.out.println("Key " + key" does not exist");
        }
        //جلب قيمة المفتاح  من خلال عنصر
        Integer iKeynull;
        String value="الثلاثاء";
        for(Map.Entry entry: days.entrySet()){
            if(value.equals(entry.getValue())){
                iKey = (Integer)entry.getKey();
                break//breaking because its one to one map
            }
        }
        System.out.println("Found Key : "iKey +" value: " + value);
        //ازالة الكل
        days.clear();
        //طباعة حجم الهاش تيبل 
        System.out.println("After remove: "days.size());
    }
}


linkedlistفي  الجافا 

القوائم المرتبطة هي من أبسط هياكل البيانات وأكثرها شيوعًا. المصفوفات والقوائم المرتبطة متشابهة لأن كلاهما يخزن مجموعات من البيانات. تقوم المصفوفة بتخصيص ذاكرة لجميع عناصرها مجمعة معًا في كتلة واحدة من الذاكرة. في المقابل ، تخصص القائمة المرتبطة مساحة لكل عنصر على حدة في كتلة الذاكرة الخاصة به والتي تسمى Node. يتمثل العيب الرئيسي لاستخدام المصفوفات لتخزين البيانات في أن المصفوفات عبارة عن هياكل ثابتة وبالتالي لا يمكن توسيعها أو تقليلها بسهولة لتلائم مجموعة البيانات. من عيوب القائمة المرتبطة على المصفوفة أنها لا تسمح بالوصول المباشر إلى العناصر الفردية. إذا كنت ترغب في الوصول إلى عنصر معين ، فعليك أن تبدأ من الرأس وتتبع الرابط حتى تصل إلى هذا العنصر.


القائمة المرتبطة هي بنية بيانات تتكون من مجموعة من Nodesالتي تمثل معًا .وهو ديناميكي بطبيعته يخصص الذاكرة عند الحاجة. وهذا يعني أن عدد Nodeفي القائمة ليس ثابتًا ويمكن أن يزسداوينقص حسب الطلب. أي تطبيق يجب أن يتعامل مع عدد غير معروف من الكائنات يستخدم قائمة مرتبطة. تحتوي كل Node في قائمة مرتبطة على حقلين: حقل "بيانات" لتخزين أي نوع من العناصر تحتويه القائمة لعميلها 

import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
        //انشاء لينكليست
        LinkedList days = new LinkedList();
        //اضافة قيمة ومفتاح
        days.add("الثلاثاء");
        days.add("الاربعاء");
        days.add("الخميس");
        days.add("الجمعة");
        days.add("السبت");
        //استخراج عناصر من الهاش تيبل 
        Iterator<Stringitr=days.iterator();
        while(itr.hasNext()){
        System.out.println(itr.next());
    }
    /* اضافة العنصر الاول والاخير من اللنك ليست */ 
    days.addFirst("الاثنين");
    days.addLast("الاحد");
    System.out.println("After Addition: " + days);
        /*ادخال قيم على اللينك ليست*/
        days.add(0"اول ايام الاسبوع"); 
        days.add(4,"وسط ايام  الاسبوع"); 
        days.add(9"اخر ايام الاسبوع"); 
        System.out.println("After Insertion: " + days);
//ازالة في اللينك ليست
days.removeFirst();
days.remove(3); 
days.removeLast();
days.remove("الخميس");
System.out.println("After Addition: " + days);
      //حجم اللنكد ليست
      int elements = days.size();
      System.out.println("حجم اللنك ليست: " + elements);
        //اجاد عنصر  في  اللنكد ليست
        boolean check = days.contains("الاحد");
        if(check)
            System.out.println("العنصر موجود");
        else
            System.out.println("العنصر غير موجود ");
            //تحديث اللنك ليست  او جلب ووضع قيمة في العنصر
            Object item = days.get(0);
    days.set(0, (Stringitem + "-البوم الاول");
    System.out.println("بعد التعديل : " + days);
    }
}


vector

يتم استخدام المتجهات في الجافا بشكل شائع بدلاً من المصفوفات ، لأنها تتوسع تلقائيًا عند إضافة بيانات جديدة إليها. هذا يعني أن مثيلات Vector ، مثل القوائم المرتبطة ، يمكن أن تنمو ديناميكيًا. ومع ذلك ، يمكن أن ينمو حجم المتجه أو يتقلص حسب الحاجة لاستيعاب إضافة العناصر وإزالتها بعد إنشاء المتجه.


import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
      //انشاء كائن المتجه فيكتور وحساب حجمه
    Vector vcTr = new Vector();
    System.out.println("Vector Size: " + vcTr.size());
      //مضاعفة حجم الفيكتور
    vcTr = new Vector(2,2);
    System.out.println("Vector Size: " + vcTr.size());
//لكي تعمل على المترجم بشكل جيد ازلت الاحرف  العربية بالانجليزية
    vcTr.addElement("Sunday");
    vcTr.addElement("Monday");
    vcTr.addElement("Wednesday");
    System.out.println("Vector Size: " + vcTr.size());
    System.out.println("Vector Capacity: " + vcTr.capacity());
 
    //استخدام التكرارية  على الفيكتور
    Iterator<Stringitr = vcTr.iterator();
    while(itr.hasNext()){
      System.out.println(itr.next());
    }
    //اضافة عنصر محدد 
    vcTr.add(2,"Tuesday");
    //استخدام التعدادية لعناصر الفيكتور
    Enumeration<Stringenm = vcTr.elements();
    while(enm.hasMoreElements()){
      System.out.println(enm.nextElement());
    }
    
    System.out.println(vcTr.firstElement());
    System.out.println(vcTr.lastElement());
    System.out.println(vcTr.get(2));
    if(vcTr.contains("Monday"))
    System.out.println("Item Found");
    vcTr.remove(1);
    System.out.println(vcTr);
    vcTr.clear();
    if(vcTr.isEmpty())
      System.out.println("Vector Empty !!");
    else
      System.out.println("Vector Contains: " + vcTr.size() + " elements  !!");
  }
}


hashsert

  • تقوم فئة HashSet بتمديد AbstractSet وتنفذ واجهة المجموعة. المجموعة هي مجموعة لا تحتوي على عناصر مكررة ، وعناصرها ليست بترتيب معين
  • في HashSet ، يتم استخدام جدول التجزئة للتخزين
  • يخزن جدول التجزئة المعلومات باستخدام آلية تسمى التجزئة.
  • تُرجع وظيفة التجزئة نفس رمز التجزئة في كل مرة

 
import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
    //انشاء كائن الهاش سث
    HashSet days=new HashSet();
    // اضافة عناصر اليه بالانجليزية
    days.add("Sunday");
    days.add("Monday");
    days.add("Tuesday");
    days.add("Wednesday");
    days.add("Thursday");
    days.add("Friday");
    days.add("Saturday");
    //عملية التكرير 
    Iterator itr=days.iterator();
    while(itr.hasNext()){
      System.out.println(itr.next());
    }
    //ازالة عنصر 
    days.remove("Monday");
    System.out.println(days);
    //البحث في الهاش سث
    if(days.contains("Saturday"))
      System.out.println("Item Found");
    else
    System.out.println("Item Not Found");
    //ازالة كل العناصر
    days.clear();
    //قياس الحجم 
    System.out.println("Size of the HashSet: "+days.size());
  }
}


treeset  

  • يقوم بإنشاء مجموعة تستخدم شجرة للتخزين
  • يتم تخزين الكائنات بترتيب تصاعدي وفرز وفقًا للترتيب الطبيعي
  • يقوم تطبيق TreeSet بالفرز حسب الترتيب المعجمي لقيم السلسلة التي تقوم بإدراجها
  • يمكننا تغيير الترتيب الطبيعي لمجموعة TreeSet باستخدام واجهات المقارنة أو المقارنة
  • جيد  لترتيب  المجموعات  


import java.util.*;
class TestClass
{
  public static void main (String[] argsthrows java.lang.Exception
  {
    //انشاء الكائن التشعبي
    TreeSet days=new TreeSet();
    // اضافة عناصر
    days.add("Sunday");
    days.add("Monday");
    days.add("Tuesday");
    days.add("Wednesday");
    days.add("Thursday");
    days.add("Friday");
    days.add("Saturday");
    //طريقة التكرير 
    Iterator itr=days.iterator();
    while(itr.hasNext()){
      System.out.println(itr.next());
    }
    //طريقة ازالة عنصر واحد 
    days.remove("Monday");
    System.out.println(days);
    //البحث في الكائن التشعبي
    if(days.contains("Saturday"))
      System.out.println("Item Found");
    else
      System.out.println("Item Not Found");
    //ازالة الكل
    days.clear();
    //قياس الحجم
    System.out.println("Size of the HashSet: "+days.size());
  }
}




في الختام ادعوكم للانضمام الى  قناتنا على اليوتوب The Developer

Post a Comment

0 Comments