قبل متابعة الدرس انصحك اخي الكريم بالاطلاع على الدروس السابقة حتى يسهل عليك فهم الدروس التالية:
يوفر إطار عمل المجموعة أيضًا ميزات لتطبيق خوارزميات مختلفة على جميع عناصر المجموعة أو بعضها ، مثل البحث في مجموعة أو فرز عناصر مجموعة أو خلطها ، وجلب عرض للقراءة فقط لمجموعة ، وما إلى ذلك. تعمل الغالبية العظمى من الخوارزميات التي يوفرها نظام Java الأساسي على نسخ القائمة ، لكن القليل منها يعمل على مثيلات تجميع عشوائية. يُقال أن الخوارزميات متعددة الأشكال: أي أنه يمكن استخدام نفس الطريقة في العديد من التطبيقات المختلفة لواجهة المجموعة المناسبة. في جوهرها ، الخوارزميات هي وظائف قابلة لإعادة الاستخدام.
المصفوفات القائمية ArrayList
المصفوفات هي عبارة عن كائن احتوائي على قيم محددة من نفس النوع.، لنفترض انه لديك عدد من القيم الاعداد الصحيحة وقيم عبارة عن string سلاسل (ارقام وحروف .. ألخ) في الغالب ستحتاج الى انشاء مصفوفة للاعداد الصحيحة ومصفوفة للسلاسل وهذا سيقوض عملية الترتيب ، لكن كيف سندمج بين هذه القيم المختلفة وكيف سنضيف حجم المصفوفة بعد الانتهاء هنا يقع الحل الامثل لاستخدام ArrayList
ArrayList او المصفوفات القائمية هي عبارة عن فئة تهتم بواجهة القائمة واكثر مرونة في المجموعة framwork للجافا ، فهي تضيف بشكل ديناميكي حجم المصفوفة وتحتوي على اكبر عدد من القيم المختلفة والغير المتجانسة ويمكنها ان تحتوي على عناصر مكررة ايضا ويمكن الوصول الى هذه المصفوفة القائمية من خلال فهرس مكون من الاعداد الصحيحة الطبيعية جدول يظهر دريقة الفهرسة بالادراج اعتبارا من العدد 0 هو القيمة التي انطلف منها الفهرسة
كيف تضيف عنصر داخل مصفوفة قائمية ArrayList import java.util.*;
class TestClass
{
public static void main (String[] args) throws 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[] args) throws 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 < String> arrList= new 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[] args) throws java.lang.Exception
{
//انشاء كائن جديد
ArrayList aList = new ArrayList();
aList.add("الإثنين");
aList.add("الثلاثاء");
aList.add("الاربعاء");
//استخدام عملية التكرار لمعرفة عناصر المصفوفة القائمية
Iterator < String> itr = 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[] args) throws java.lang.Exception
{
//انشاء هاش ماب
HashMap<Integer,String> days = 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[] args) throws java.lang.Exception
{
//انشاء هاش ماب
HashMap<Integer,String> days = new HashMap<Integer,String>();
//هنا اضافة المفتاح مع القيمة
days.put(1,"الاحد");
days.put(2,"الاثنين");
days.put(3,"الثلاثاء");
days.put(4,"الاربعاء");
//لطباعة حجم الهاش ماب
System.out.println("حجم الهاش ماب: "+ days.size());
}
}
هناك عدة طرق لاظهار العناصر من الهاش ماب
//انشاء هاش ماب
HashMap<Integer,String> days = 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,String> sg : 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,String> days = 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,String> days = 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[] args) throws java.lang.Exception
{
//انشاء هاش ماب
HashMap<Integer,String> days = new HashMap<Integer,String>();
//هنا اضافة المفتاح مع القيمة
days.put(1,"الاحد");
days.put(2,"الاثنين");
days.put(3,"الثلاثاء");
days.put(4,"الاربعاء");
Integer key= null;
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[] args) throws java.lang.Exception
{
//انشاء هاش ماب
HashMap <Integer,String> days = 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,String> sg : 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 iKey= null;
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[] args) throws java.lang.Exception
{
//انشاء هاش تيبل?
Hashtable <Integer,String> days = 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,String> sg : 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 iKey= null;
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[] args) throws java.lang.Exception
{
//انشاء هاش تيبل?
TreeMap <Integer,String> days = 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,String> sg : 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 iKey= null;
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[] args) throws java.lang.Exception
{
//انشاء لينكليست
LinkedList days = new LinkedList();
//اضافة قيمة ومفتاح
days.add("الثلاثاء");
days.add("الاربعاء");
days.add("الخميس");
days.add("الجمعة");
days.add("السبت");
//استخراج عناصر من الهاش تيبل
Iterator<String> itr=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, (String) item + "-البوم الاول");
System.out.println("بعد التعديل : " + days);
}
}
vector
يتم استخدام المتجهات في الجافا بشكل شائع بدلاً من المصفوفات ، لأنها تتوسع تلقائيًا عند إضافة بيانات جديدة إليها. هذا يعني أن مثيلات Vector ، مثل القوائم المرتبطة ، يمكن أن تنمو ديناميكيًا. ومع ذلك ، يمكن أن ينمو حجم المتجه أو يتقلص حسب الحاجة لاستيعاب إضافة العناصر وإزالتها بعد إنشاء المتجه.
import java.util.*;
class TestClass
{
public static void main (String[] args) throws 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<String> itr = vcTr.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
//اضافة عنصر محدد
vcTr.add(2,"Tuesday");
//استخدام التعدادية لعناصر الفيكتور
Enumeration<String> enm = 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[] args) throws 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[] args) throws 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
0 تعليقات