مفهوم هيكلة البيانات في جافا
Data Structure تسمى هيكلة البيانات أو بنية البيانات في اللغة العربية, و هي تعني طريقة تخزين أو ترتيب البيانات في الذاكرة بشكل يسهل عملية حفظها أو إسترجاعها.
في جافا يوجد مجموعة كبيرة من الكلاسات (Classes) و الإنترفيسات (Interfaces) تستخدم لترتيب الكائنات التي تم إنشاءها أثناء تشغيل البرنامج.
سنشرح في هذا الدرس الكلاسات و الإنترفيسات التالية:
VectorEnumerationStackHashtableProperties
في الدرس التالي ستتعرف أيضاً على مجموعة كبيرة من الكلاسات و الإنترفيسات التي تستخدم في هيكلة البيانات و التي تم وضعها في حزمة تسمى Collection.
Java الكلاس Vector في جافا
مقدمة
الكلاس Vector يستخدم لإنشاء مصفوفات متطورة مقارنةً مع المصفوفات العادية Arrays, حيث يوفر لك مجموعة من الدوال التي تمكنك من البحث فيها, التشييك على عناصرها, إضافة عناصر جديدة, حذف عناصر منها, و معالجة أكثر من عنصر فيها في نفس الوقت إلخ..
أهم ميزة في المصفوفات التي نوعها Vector هي أن عدد العناصر فيها غير ثابت, حيث أنه يزيد عند إضافة عنصر جديد فيها و ينقص عند حذف عنصر منها بشكل تلقائي, و هذه الميزة غير موجودة في المصفوفات العادية.
كما أنك تستطيع الوصول للعناصر الموجودة فيها عن طريق أرقام الـ Index التي تعطى بالترتيب لكل عنصر يضاف فيها.
كلاسات جافا جاهزة
Class Vector in Java The class Vector is used to create advanced arrays compared to regular arrays, as it provides you with a set of functions that enable you to search in them, check their elements, add new elements, delete elements from them, and process more than one element in it at the same time, etc. The most important feature of vector arrays is that the number of elements in them is not fixed, as it increases when a new element is added in them and decreases when an element is deleted from them automatically, and this feature is not present in regular arrays. You can also access the elements in it through the index numbers, which are given in order for each element added to it.
كونستركتورات الكلاس Vector
الجدول التالي يحتوي على جميع الكونستركتورات الموجودين في الكلاس Vector.
| الكونستركتور مع تعريفه | |
|---|---|
public Vector()
هذا الكونستركتور الإفتراضي في الكلاس Vector, يستخدم لإنشاء كائن نوعه Vector حجمه 10, أي يمكن أن يحتوي على 10 عناصر.هنا كلما امتلأ الـ Vector سيحجز مكان لـ 10 عناصر جديدة في الذاكرة. |
|
public Vector(int size)
يستخدم هذا الكونستركتور لتحديد حجم كائن الـ Vector الأولي.الرقم الذي نضعه كـ Argument في هذا الكونستركتور يحدد عدد العناصر الذي يمكن أن يحتويه كائن الـ Vector, و يحدد أيضاً عدد العناصر الذي سيحجز له في الذاكرة كلما امتلأ. |
|
public Vector(int size, int increment)
يستخدم هذا الكونستركتور لتحديد حجم كائن الـ Vector الأولي و تحديد كم عنصر جديد سيضاف فيه كلما امتلأ.الرقم الذي نضعه مكان الباراميتر size يحدد عدد العناصر الذي يمكن أن يحتويه كائن الـ Vector.الرقم الذي نضعه مكان الباراميتر increment | |
public Vector(Collection c)
يستخدم هذا الكونستركتور لإنشاء كائن نوعه Vector يحتوي على عناصر كائن الـ Collection الذي نمرره له كـ Argument.
دوال الكلاس Vector
الجدول التالي يحتوي على جميع دوال الكلاس Vector.
| الدالة مع تعريفها | |
|---|---|
public void add(int index, Object element)
تستخدم لإضافة عنصر جديد في مكان محدد في كائن الـ Vector. |
|
public boolean add(Object o)
تستخدم لإضافة عنصر جديد في آخر كائن الـ Vector.ترجع true إذا تمت الإضافة بنجاح. |
|
public boolean addAll(Collection c)
تستخدم لإضافة جميع العناصر الموجودين في كائن الـ Collection بالترتيب في آخر كائن الـ Vector.ترجع true إذا تمت الإضافة بنجاح. |
|
public boolean addAll(int index, Collection c)
تستخدم لإضافة جميع العناصر الموجودين في كائن الـ Collection بالترتيب في مكان محدد في كائن الـ Vector.ترجع true إذا تمت الإضافة بنجاح. |
|
public void addElement(Object o)
تستخدم لإضافة عنصر جديد في آخر كائن الـ Vector مع زيادة عدد العناصر واحداً. |
|
public int capacity()
ترجع حجم كائن الـ Vector المحجوز في الذاكرة. |
|
public void clear()
تمسح جميع العناصر الموجودة في كائن الـ Vector. |
|
public Object clone()
تنشئ نسخة من كائن الـ Vector. |
|
public boolean contains(Object elem)
ترجع true إذا كان كائن الـ Vector يحتوي على الكائن الذي نضعه لها كـ Argument. |
|
public boolean containsAll(Collection c)
ترجع true إذا كان كائن الـ Vector يحتوي على جميع العناصر الموجودة في كائن الـ Collection الذي نضعه لها كـ Argument. |
|
public void copyInto(Object[] anArray)
تنسخ محتوى كائن الـ Vector في مصفوفة من نفس النوع.ملاحظة: حجم المصفوفة التي سيتم نسخ القيم فيها يجب أن لا يكون أصغر من حجم كائن الـ Vector. كما أن نوع المصفوفة التي سيتم النسخ فيها يجب أن يتناسب مع نوع القيم المراد تخزينها فيها. |
|
public Object elementAt(int index)
ترجع العنصر الموجود على الـ index الذي نمرره لها كـ Argument. |
|
public Enumeration elements()
ترجع كائن نوع Enumeration يحتوي على جميع عناصر كائن الـ Vector. |
|
public void ensureCapacity(int minCapacity)
تحدد عدد العناصر الأقل الذي يجب أن يحجز للكائن Vector في الذاكرة.إذا كان العدد الموضوع فيها أكبر من عدد العناصر المحجوز للكائن Vector, عندها يتم تكبير حجمه.إذا كان العدد الموضوع فيها أصغر من عدد العناصر الموجودة في كائن الـ Vector, لن تفعل أي شيء. |
|
public boolean equals(Object o)
تقارن كائن الـ Vector مع أي مصفوفة نمررها لها كـ Argument.ترجع true في حال كان كائن الـ Vector يتطابق مع المصفوفة في عدد و قيم العناصر الموضوعة فيهما و بنفس الترتيب. |
|
public Object firstElement()
ترجع أول عنصر موجود في كائن الـ Vector, أي العنصر الموجود على الـ index رقم 0. |
|
public Object get(int index)
ترجع العنصر الموجود على الـ index الذي نمرره لها كـ Argument. |
|
public int hashCode()
ترجع الـ Hash Code للعنصر الذي قام باستدعائها. |
|
public int indexOf(Object elem)
تبحث في كائن الـ Vector عن أي قيمة نمررها لها كـ Argument.ترجع رقم أول Index يحتوي على القيمة المطلوبة في حال وجود نفس القيمة في أكثر من عنصر. ترجع 1- في حال عدم إيجاد القيمة المطلوبة. |
|
public int indexOf(Object elem, int index)
تبحث في كائن الـ Vector عن أي قيمة نمررها لها كـ Argument.تبدأ عملية البحث من رقم الـ index الذي نضعه مكان الباراميتر الثاني. ترجع رقم أول Index يحتوي على القيمة المطلوبة في حال وجود نفس القيمة في أكثر من عنصر. ترجع 1- في حال عدم إيجاد القيمة المطلوبة. |
|
public void insertElementAt(Object obj, int index)
تستخدم لإضافة عنصر جديد في مكان محدد في كائن الـ Vector. |
|
public boolean isEmpty()
ترجع true في حال كان كائن الـ Vector فارغاً. |
|
public Object lastElement()
ترجع آخر عنصر موجود في كائن الـ Vector. |
|
public int lastIndexOf(Object elem)
تبحث في كائن الـ Vector عن أي قيمة نمررها لها كـ Argument.ترجع رقم آخر Index يحتوي على القيمة المطلوبة في حال وجود نفس القيمة في أكثر من عنصر. ترجع 1- في حال عدم إيجاد القيمة المطلوبة. |
|
public int lastIndexOf(Object elem, int index)
تبحث في كائن الـ Vector عن أي قيمة نمررها لها كـ Argument.تبدأ عملية البحث من رقم الـ index الذي نضعه مكان الباراميتر الثاني. ترجع رقم آخر Index يحتوي على القيمة المطلوبة في حال وجود نفس القيمة في أكثر من عنصر. ترجع 1- في حال عدم إيجاد القيمة المطلوبة. |
|
public Object remove(int index)
تحذف عنصر محدد من كائن الـ Vector. |
|
public boolean remove(Object o)
تحذف أول عنصر يتم إيجاده في كائن الـ Vector في حال كان يتطابق مع الكائن الذي نمرره لها كـ Argument.ترجع true إذا تم حذف العنصر بنجاح. |
|
public boolean removeAll(Collection c)
تحذف مجموعة متتالية من العناصر الموجود في كائن الـ Vector في حال كانت تتطابق مع كائن الـ Collection الذي نمرره لها كـ Argument.ترجع true إذا تم حذف جميع العناصر بنجاح. |
|
public boolean removeAllElements()
تحذف جميع العناصر من كائن الـ Vector, و تجعل حجمه يساوي 0.ترجع true إذا تم حذف جميع العناصر بنجاح. |
|
public boolean removeElement(Object obj)
تحذف أول عنصر يتم إيجاده في كائن الـ Vector في حال كان يتطابق مع الكائن الذي نمرره لها كـ Argument.ترجع true إذا تم حذف العنصر بنجاح. |
|
public void removeElementAt(int index)
تحذف عنصر محدد من عناصر كائن الـ Vector. |
|
public boolean retainAll(Collection c)
تبقي عناصر كائن الـ Vector الموجودة في كائن الـ Collection الذي نمرره لها كـ Argument, و تحذف جميع العناصر الأخرى. |
|
public Object set(int index, Object element)
تبدل عنصر محدد في كائن الـ Vector بعنصر جديد, و ترجعه أيضاً. |
|
public void setElementAt(Object obj, int index)
تبدل عنصر محدد في كائن الـ Vector بعنصر جديد. |
|
public void setSize(int newSize)
تحدد عدد عناصر كائن الـ Vector.إذا كان العدد الموضوع فيها أكبر من عدد عناصر كائن الـ Vector, عندها توضع القيمة null مكان كل عنصر فارغ ( أي غير مستخدم ).إذا كان العدد الموضوع فيها أصغر من عدد العناصر كائن الـ Vector, عندها يتم حذف العناصر التي لم يعد كائن الـ Vector قادراً على تخزينها. |
|
public int size()
ترجع عدد العناصر الموجودة في كائن الـ Vector. |
|
public List subList(int fromIndex, int toIndex)
ترجع كائن نوعه List يمثل العناصر الموجودة في كائن الـ Vector إبتداءاً من fromIndex وصولاً إلى ما قبل toIndex. |
|
public Object[] toArray()
ترجع مصفوفة نوعها Object تحتوي على جميع العناصر الموجودة في كائن الـ Vector. |
|
public String toString()
ترجع كائن نوعه String يمثل العناصر الموجودة في كائن الـ Vector. |
|
public void trimToSize()
تصغر حجم كائن الـ Vector في الذاكرة, حيث أنها تحذف جميع الأماكن المحجوزة له في الذاكرة و التي لم يضطر إلى استخدامها لأنها ما زالت فارغة ( أي لا تحتوي على عنصر ). |
|
أمثلة شاملة
في كل مثال موضوع استخدامنا كونستركتور مختلف و دوال جديدة.
المثال الأول
في المثال التالي وضحنا الفرق بين حجم كائن الـ Vector في الذاكرة و بين عدد عناصره المستخدمة.
استخدامنا فيه الدوال التالية: add() - capacity() - size() - trimToSize().
import java.util.Vector; // Vector هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
Vector v = new Vector(); // باستخدام الكونستركتور الإفتراضي v إسمه Vector هنا قمنا بإنشاء كائن من الكلاس
System.out.println("capacity = " + v.capacity()); // في الذاكرة و الذي سيكون 10 لأن هذا الكائن أنشئ بواسطة الكونستركتور الإفتراضي v هنا عرضنا عدد العناصر المحجوز للكائن
System.out.println("size = " + v.size() + "\n"); // و الذي سيكون 0 لأننا لم ندخل فيه أي كائن بعد v هنا عرضنا عدد عناصر الكائن
v.add("A"); // v هنا قمنا بإضافة 11 عنصر في الكائن
v.add("B");
v.add("C");
v.add("D");
v.add("E");
v.add("F");
v.add("G");
v.add("H");
v.add("I");
v.add("J");
v.add("K");
System.out.println("capacity = " + v.capacity()); // و الذي أصبح 20 لأن الكونستركتور الإفتراضي يحجز 10 أماكن جديدة كلما إمتلأ v هنا عرضنا عدد العناصر المحجوز للكائن
System.out.println("size = " + v.size() + "\n"); // و الذي أصبح 11 لأننا أضفنا فيه 11 عنصراً v هنا عرضنا عدد عناصر الكائن
v.trimToSize(); // و التي لم يحتاجها v هنا قمنا بحذف الأماكن المحجوزة في الذاكرة من أجل الكائن
System.out.println("capacity = " + v.capacity()); // هنا عرضنا حجم المصفوفة في الذاكرة و عدد عناصرها, لاحظ أنهما أصبحا متساويان
System.out.println("size = " + v.size());
}
}
•سنحصل على النتيجة التالية عند التشغيل.
capacity = 10
size = 0
capacity = 20
size = 11
capacity = 11
size = 11
المثال الثاني
في المثال التالي قمنا بتحديد حجم كائن الـ Vector في الذاكرة من خلال الكونستركتور.
ثم قمنا بإضافة بعض العناصر فيه.
بعدها قمنا بتحديد عدد عناصره و حجمه في الذاكرة بواسطة الدالة setSize().
في الأخير قمنا بعرض جميع عناصره بواسطة الحلقة for.
import java.util.Vector; // Vector هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
Vector v = new Vector(5); // يمكنه إحتواء 5 عناصر v إسمه Vector هنا قمنا بإنشاء كائن من الكلاس
System.out.println("capacity = " + v.capacity()); // في الذاكرة و الذي سيكون 5 v هنا عرضنا عدد العناصر المحجوز للكائن
System.out.println("size = " + v.size() + "\n"); // و الذي سيكون 0 لأننا لم ندخل فيه أي كائن بعد v هنا عرضنا عدد عناصر الكائن
v.add("A"); // v هنا قمنا بإضافة 5 عناصر في الكائن
v.add("B");
v.add("C");
v.add("D");
v.add("E");
System.out.println("capacity = " + v.capacity()); // هنا عرضنا حجم المصفوفة في الذاكرة و عدد عناصرها, لاحظ أنهما أصبحا متساويان
System.out.println("size = " + v.size() + "\n");
v.setSize(12); // مكان كل عنصر غير مستخدم null في الذاكرة بـ 12 عنصر و تم وضع القيمة v هنا قمنا بتحديد حجم الكائن
System.out.println("capacity = " + v.capacity()); // هنا عرضنا حجم المصفوفة في الذاكرة و عدد عناصرها يساويان 12
System.out.println("size = " + v.size() + "\n");
for(int i=0; i<v.size(); i++) { // هنا أنشأنا حلقة تعرض جميع العناصر الموجودة فيها
System.out.println("v[" +i+ "] = " +v.get(i));
}
}
}
•سنحصل على النتيجة التالية عند التشغيل.
capacity = 5
size = 0
capacity = 5
size = 5
capacity = 12
size = 12
v[0] = A
v[1] = B
v[2] = C
v[3] = D
v[4] = E
v[5] = null
v[6] = null
v[7] = null
v[8] = null
v[9] = null
v[10] = null
v[11] = null
المثال الثالث
في المثال التالي قمنا بإضافة كائن نوعه Vectorفي كائن آخر نوعه Vector.
لاحظ هنا أنه عند إضافة كائن بواسطة الدالة add(Collection c) فإن جميع عناصره توضع في عنصر واحد.
import java.util.Vector; // Vector هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
Vector v1 = new Vector(); // v1 إسمه Vector هنا قمنا بإنشاء كائن من الكلاس
Vector v2 = new Vector(); // v2 إسمه Vector هنا قمنا بإنشاء كائن من الكلاس
v1.add("A"); // v1 هنا قمنا بإضافة 5 عناصر في الكائن
v1.add("B");
v1.add("C");
v1.add("D");
v1.add("E");
v2.add(v1); // v2 في أول عنصر في الكائن v1 هنا قمنا بإضافة جميع عناصر الكائن
System.out.println("v1 size = " + v1.size()); // يحتوي على 5 عناصر v1 لاحظ أن الكائن
System.out.println("v2 size = " + v2.size() + "\n"); // يحتوي على عنصر واحد فقط v2 لكن الكائن
System.out.println("v2[0] = " +v2.get(0)); // عبارة عن مصفوفة فيها 5 كائنات v2 لاحظ أن العنصر الذي يحتويه الكائن
}
}
•سنحصل على النتيجة التالية عند التشغيل.
v1 size = 5
v2 size = 1
v2[0] = [A, B, C, D, E]
المثال الرابع
في المثال التالي قمنا باستخدام الدوال التالية التي تستخدم في البحث و التشييك:
firstElement() - lastElement() - indexOf() - lastIndexOf() - elementAt() - contains().
import java.util.Vector; // Vector هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
// v إسمه Vector هنا قمنا بإنشاء كائن من الكلاس
Vector v = new Vector();
// v هنا قمنا بإضافة 9 عناصر في الكائن
v.add("A");
v.add("B");
v.add("C");
v.add("D");
v.add("E");
v.add("A");
v.add("B");
v.add("C");
v.add("Z");
// v هنا عرضنا العنصر الأول و الأخير الموجودين في الكائن
System.out.println("First element: " + v.firstElement());
System.out.println("Last element: " + v.lastElement() + "\n");
// v هنا عرضنا خامس عنصر موجود في الكائن
System.out.println("Element at v[4]: " + v.elementAt(4) + "\n");
// v موجودين في الكائن 'C' أول و آخر كائن index هنا عرضنا
System.out.println("First index of the object 'C': " + v.indexOf("C"));
System.out.println("Last index of the object 'C': " + v.lastIndexOf("C") + "\n");
// F و D عن الكائنين v هنا بحثنا في عناصر الكائن
System.out.println("Does it contain a 'D' object? " + v.contains("D"));
System.out.println("Does it contain a 'F' object? " + v.contains("F"));
}
}
•سنحصل على النتيجة التالية عند التشغيل.
First element: A
Last element: Z
Element at v[4]: E
First index of the object 'C': 2
Last index of the object 'C': 7
Does it contain a 'D' object? true
Does it contain a 'F' object? false
المثال الخامس
في المثال التالي قمنا بنسخ عناصر كائن الـ Vector بداخل مصفوفة جديدة نوعها Object بواسطة الدالة copyInto().
import java.util.Vector; // Vector هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
// v إسمه Vector هنا قمنا بإنشاء كائن من الكلاس
Vector v = new Vector();
// v هنا قمنا بإضافة 3 عناصر في الكائن
v.add("A");
v.add("B");
v.add("C");
// v عدد عناصرها يساوي عدد عناصر الكائن ,Object هنا قمنا بإنشاء مصفوفة نوعها
Object[] arr = new Object[v.size()];
// arr بنفس الترتيب في المصفوفة v هنا قمنا بنسخ عناصر الكائن
v.copyInto(arr);
// arr هنا أنشأنا حلقة تعرض جميع العناصر الموجودة في الحلقة
for(int i=0; i<arr.length; i++) {
System.out.println("arr[" +i+ "] = " +arr[i]);
}
}
}
•سنحصل على النتيجة التالية عند التشغيل.
arr[0] = A
arr[1] = B
arr[2] = C
المثال السادس
في المثال التالي قمنا بإنشاء نسخة ثانية من كائن الـ Vector في كائن جديد نوعه Object بواسطة الدالة clone().
بعدها قمنا بمسح جميع عناصر كائن الـ Vector الأساسي بواسطة الدالة clone().
import java.util.Vector; // Vector هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
// v إسمه Vector هنا قمنا بإنشاء كائن من الكلاس
Vector v = new Vector();
// v هنا قمنا بإضافة 3 عناصر في الكائن
v.add("A");
v.add("B");
v.add("C");
// o في الكائن v هنا قمنا بنسخ عناصر الكائن
Object o = v.clone();
// v هنا قمنا بمسح جميع عناصر الكائن
v.clear();
// o و v هنا قمنا بعرض عناصر كل من الكائنات
System.out.println("v = " +v);
System.out.println("o = " +o);
}
}
•سنحصل على النتيجة التالية عند التشغيل.
v = []
o = [A, B, C]
Java الإنترفيس Enumeration في جافا
مقدمة
الـ Enumeration هو إنترفيس يستخدم لتخزين عناصر متتالية موجودة في Data Structure معينة دفعة واحدة.
بعدها يمكنه إرجاع هذه العناصر واحداً تلو الآخر بواسطة الدالة nextElement().
فعلياً لا يعتبر Data Structure معينة بحد ذاته, لكن بعض الكلاسات و الإنترفيسات الأخرى التي تنتمي لفئة الـ Data Structure تعتمد عليه, مثل الكلاسات Vector و Properties.
في الدرس التالي سنتعرف على إنترفيس يشبهه إسمه Iterator.
Enumeration in Java Enumeration is an interface used to store consecutive elements in a particular Data Structure at once. Then he can return these elements one by one with the nextElement () function. Actually, it is not considered a specific data structure, but some classes and other interfaces that belong to the Data Structure category depend on it, such as Vector and Properties classes. In the next lesson, we will learn about an Interface similar to its name, Iterator.
دوال الإنترفيس Enumeration
الجدول التالي يحتوي على دوال الإنترفيس Enumeration.
| الدالة مع تعريفها | |
|---|---|
public boolean hasMoreElements()
ترجع true في حال كان كائن الـ Enumeration لا يزال يحتوي على عناصر. |
|
public Object nextElement()
ترجع العنصر التالي الموجود في كائن الـ Enumeration, ترجعه كـ Object. |
|
مثال شامل
import java.util.Vector; // Vector هنا قمنا باستدعاء الكلاس
import java.util.Enumeration; // Enumeration هنا قمنا باستدعاء الإنترفيس
public class Main {
public static void main(String[] args) {
Vector v = new Vector(); // وضعنا فيه أيام الأسبوع v إسمه Vector هنا قمنا بإنشاء كائن من الكلاس
v.add("Monday"); // أي قمنا بإضافة 7 أيام .v هنا قمنا بإضافة 7 عنصر في الكائن
v.add("Tuesday");
v.add("Wednesday");
v.add("Thursday");
v.add("Friday");
v.add("Satruday");
v.add("Sunday");
Enumeration days = v.elements(); // v وضعنا فيه جميع عناصر الكائن days إسمه Enumeration هنا قمنا بإنشاء كائن نوعه
while(days.hasMoreElements()) { // و تعرض كل عنصر تمر عليه days هنا أنشأنا حلقة تمر على جميع عناصر الكائن
System.out.println(days.nextElement());
}
}
}
•سنحصل على النتيجة التالية عند التشغيل.
Monday
Tuesday
Wednesday
Thursday
Friday
Satruday
Sunday
Java الكلاس Stack في جافا
مقدمة
الكلاس Stack يرث من الكلاس Vector و هو يطبق مبدأ LIFO ( Last In First Out ), أي العنصر الذي يدخل في الأخير يخرج في الأول.
بما أنه يرث من الكلاس Vector فهذا يعني أنه يملك جميع الدوال الموجودة فيه.
هنا يتم تخزين العناصر بشكل عامودي, حيث أن العناصر تترتب فيه من الأسفل إلى الأعلى.
إذاً عند إضافة عنصر ( كائن ), سيتم تخزينه في أعلى الـ Stack. و عند حذف عنصر, سيتم حذف العنصر الموجود في الأعلى أيضاً.
بما أنه لا يمكن التعامل معه إلا من الأعلى فهذا يعني أنه يمكن الوصول فقط للعنصر الموجود في أعلى الـ Stack.
ننصحك بمشاهدة هذا الفيديو حتى تفهم طريقة تخزين الكائنات و استرجاعها في الـ Stack.
دوال الكلاس Stack
الجدول التالي يحتوي على دوال الكلاس Stack.
| الدالة مع تعريفها | |
|---|---|
public boolean empty()
تفحص كائن الـ Stack لمعرفة إذا كان يحتوي على عناصر أم لا.ترجع false في حال كان كائن الـ Stack لا يزال يحتوي على عناصر. |
|
public Object peek()
ترجع العنصر الموجود في أعلى كائن الـ Stack, بدون أن تحذفه. |
|
public Object pop()
ترجع العنصر الموجود في أعلى كائن الـ Stack, و تحذفه منه. |
|
public Object push(Object element)
تضع الكائن الذي نمرره لها كـ Argument في أعلى كائن الـ Stack, و ترجعه أيضاً. |
|
public int search(Object element)
تبحث عن الكائن الذي نمرره لها كـ Argument في جميع عناصر كائن الـ Stack.في حال تم إيجاد تطابق, ترجع رقمه التراتبي بالنسبة للعناصر الموجودة في كائن الـ Stack.في حال عدم إيجاد تطابق, ترجع 1- |
|
مثال شامل
في المثال التالي قمنا بتعريف كائن نوعه Stack ثم أدخلنا فيه أربعة عناصر A - B - C - D.
بعدها قمنا بالبحث عنهم بداخل كائن الـ Stack حتى نعرف مكان وجودهم بداخله, أي كيف تم ترتيبهم.
قمنا أيضاً بالبحث عن كائنات غير موجودة في الـ Stack حتى نرى النتيجة التي ترجع لنا عند البحث عن قية غير موجودة فيه.
في الأخير قمنا بعرض و حذف جميع العناصر الموجودة فيه.
import java.util.Stack; // Stack هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
// s إسمه Stack هنا قمنا بتعريف كائن نوعه
Stack s = new Stack();
// s هنا قمنا بإضافة 4 عناصر في الكائن
s.push("A");
s.push("B");
s.push("C");
s.push("D");
// s هنا قمنا بالبحث عن أماكن الكائنات التي أدخلناها في الكائن
System.out.println("Search result for the object 'A': " + s.search("A"));
System.out.println("Search result for the object 'B': " + s.search("B"));
System.out.println("Search result for the object 'C': " + s.search("C"));
System.out.println("Search result for the object 'D': " + s.search("D") + "\n");
// -و بالتالي ستكون نتيجة البحث 1 v هنا قمنا بالبحث عن كائنات غير موجوة في الكائن
System.out.println("Search result for the object 'X': " + s.search("X"));
System.out.println("Search result for the object 'Y': " + s.search("Y") + "\n");
System.out.println("All elements in the stack:");
// ليس فارغاً. سيتم عرض و حذف كل عنصر تمر عليه s هنا أنشأنا حلقة تستمر في تكرار نفسها طالما أن الكائن
while( !s.empty() ) {
System.out.println(s.pop());
}
}
}
•سنحصل على النتيجة التالية عند التشغيل.
Search result for the object 'A': 4
Search result for the object 'B': 3
Search result for the object 'C': 2
Search result for the object 'D': 1
Search result for the object 'X': -1
Search result for the object 'Y': -1
All elements in the stack:
D
C
B
A
Java الكلاس Hashtable في جافا
مقدمة
الكلاس Hashtable يستخدم لتخزين العناصر بشكل Key / Value حيث يتم إعطاء مفتاح لكل قيمة يتم تخزينها بداخل الـ Hashtable.
هنا كل قيمة يتم تخزينها في كائن الـ Hashtable يجب إعطاءها Key غير مستخدم, لأن كل Key موضوع يسمح لك بالوصول لقيمة واحدة من القيم الموجودة في كائن الـ Hashtable.
إذاً الـ Hashtable كأنه جدول يتألف من عامودين, الأول يحتوي المفاتيح ( Keys ) و الثاني يحتوي على القيم ( Values ).
إذاً هنا كل عنصر يضاف في الـ Hashtable يجب أن يحتوي على كائنين, الأول يمثل المفتاح و الثاني يمثل قيمته.
كونستركتورات الكلاس Hashtable
الجدول التالي يحتوي على جميع الكونستركتورات الموجودين في الكلاس Hashtable.
| الكونستركتور مع تعريفه | |
|---|---|
public Hashtable()
هذا الكونستركتور الإفتراضي في الكلاس Hashtable, يستخدم لإنشاء كائن نوعه Hashtable ليس له حجم محدد.إذاً في البداية يكون حجمه يساوي 0 لكنه يزيد كلما أضفنا فيه عنصر جديد. |
|
public Hashtable(int size)
يستخدم هذا الكونستركتور لتحديد حجم كائن الـ Hashtable الأولي الذي نريده أن يحجز له في الذاكرة.الرقم الذي نضعه كـ Argument في هذا الكونستركتور يحدد عدد العناصر التي يمكن أن يحتويها كائن الـ Hashtable, و تذكر أن حجمه يزيد عند الحاجة. |
|
public Hashtable(int size, float fillRatio)
يستخدم هذا الكونستركتور لتحديد حجم كائن الـ Hashtable الأولي الذي نريده أن يحجز له في الذاكرة.الرقم الذي نضعه مكان الباراميتر size يحدد عدد العناصر التي يمكن أن يحتويها كائن الـ Hashtable, و تذكر أن حجمه يزيد عند الحاجة.الرقم الذي نضعه مكان الباراميتر fillRatio يمكن أن يكون بين 0.0f و 1.0f.هنا يتم ضرب المتغيرين size و fillRatio ببعضهم, ناتج عملية الضرب يحدد متى سيتم زيادة حجم كائن الـ Hashtable في الذاكرة. |
|
public Hashtable(Map m)
يستخدم هذا الكونستركتور لإنشاء كائن نوعه Hashtable يحتوي على عناصر كائن الـ Map الذي نمرره له كـ Argument. |
|
دوال الكلاس Hashtable
الجدول التالي يحتوي على جميع دوال الكلاس Hashtable.
| الدالة مع تعريفها | |
|---|---|
public void clear()
تمسح جميع العناصر الموجودة في كائن الـ Hashtable. |
|
public Object clone()
تنشئ نسخة من كائن الـ Hashtable. |
|
public boolean contains(Object value)
ترجع true إذا كان كائن الـ Hashtable يحتوي على القيمة التي نضعها لها كـ Argument. |
|
public boolean containsValue(Object value)
ترجع true إذا كان كائن الـ Hashtable يحتوي على القيمة التي نضعها لها كـ Argument تماماً مثل الدالة contains().معلومة تقنية: هذه الدالة ورثها الكلاس Hashtable من الإنترفيس Map, و فعل لها Override لتستدعي الدالة contains() فقط, لذلك لا يوجد أي فرق بينهما. |
|
public boolean containsKey(Object key)
ترجع true إذا كان كائن الـ Hashtable يحتوي على المفتاح الذي نضعه لها كـ Argument. |
|
public Enumeration elements()
ترجع كائن نوع Enumeration يحتوي على جميع قيم الـ Hashtable. |
|
public Enumeration keys()
ترجع كائن نوع Enumeration يحتوي على جميع مفاتيح الـ Hashtable. |
|
public Object get(Object key)
ترجع قيمة المفتاح الذي نمرره لها كـ Argument.في حال كان كائن الـ Hashtable لا يحتوي على المفتاح الذي مررناه لها, ترجع القيمة null. |
|
public boolean isEmpty()
ترجع true في حال كان كائن الـ Hashtable فارغاً. |
|
public void put(Object key, Object value)
تستخدم لإضافة عنصر جديد في كائن الـ Hashtable. |
|
public Object remove(Object key)
تحذف العنصر الذي يملك المفتاح الذي نمرره لها كـ Argument. |
|
public int size()
ترجع عدد العناصر الموجودة في كائن الـ Hashtable. |
|
public String toString()
ترجع كائن نوعه String يمثل العناصر الموجودة في كائن الـ Hashtable. |
|
مثال شامل
في المثال التالي قمنا بتعريف كائن نوعه Hashtable, إسمه h, ثم أدخلنا فيه 12 عنصر.
بعدها قمنا بتخزين جميع المفاتيح في كائن نوعه Enumeration, إسمه keys.
و قمنا أيضاً بتخزين جميع القيم في كائن نوعه Enumeration, إسمه values.
بعدها عرضناهم كجدول يتألف من عامودين من خلال الحلقة while.
في الأخير قمنا بالبحث عن قيمة مفتاح أدخالناه سابقاً.
import java.util.Hashtable; // Hashtable هنا قمنا باستدعاء الكلاس
import java.util.Enumeration; // Enumeration هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
// و الذي سنضع فيه كود البلد و إسمه h إسمه Hashtable هنا قمنا بتعريف كائن نوعه
Hashtable h = new Hashtable();
// كل عنصر يحتوي على كود البلد كمفتاح و إسمه كقيمة .h هنا قمنا بإضافة 12 عنصر في الكائن
h.put("+961", "Lebanon");
h.put("+962", "Jordan");
h.put("+963", "Syria");
h.put("+964", "Iraq");
h.put("+965", "Kuwait");
h.put("+966", "KSA");
h.put("+967", "Yaman");
h.put("+968", "Oman");
h.put("+970", "Palestine");
h.put("+212", "Morocco");
h.put("+281", "Libya");
h.put("+20", "Egypt");
// أي وضعنا اكواد البلاد فيه .keys بداخل الكائن h هنا قمنا بتخزين جميع مفاتيح الكائن
Enumeration keys = h.keys();
// أي وضعنا أسماء البلاد فيه .values بداخل الكائن h هنا قمنا بتخزين جميع قيم الكائن
Enumeration values = h.elements();
System.out.println("The table below contains all Codes & Countries \n");
System.out.println("---------------------");
System.out.println("Code \t | Country");
System.out.println("---------------------");
// لا يزال يحتوي على مفاتيح keys هنا أنشأنا حلقة تستمر في تكرار نفسها طالما أن الكائن
// الفكرة هنا المرور على جميع المفاتيح الموجودة و عرض كل مفتاح موجود و قيمته
while( keys.hasMoreElements() ) {
System.out.println(keys.nextElement() + "\t | " + values.nextElement());
}
System.out.println("---------------------\n");
// KSA هنا قمنا بالبحث عن إسم البلد الذي يملك الكود 996+ فكان الجواب
System.out.println("Which Country use the code +966 ?");
System.out.println(h.get("+966"));
}
}
•سنحصل على النتيجة التالية عند التشغيل.
The table below contains all Codes & Countries
---------------------
Code | Country
---------------------
+281 | Libya
+966 | KSA
+965 | Kuwait
+964 | Iraq
+963 | Syria
+962 | Jordan
+961 | Lebanon
+212 | Morocco
+20 | Egypt
+970 | Palestine
+968 | Oman
+967 | Yaman
---------------------
Which Country use the code +966 ?
KSA
Java الكلاس Properties في جافا
مقدمة
الكلاس Properties يرث من الكلاس Hashtable و هو يستخدم أيضاً لتخزين العناصر بشكل Key / Value.
بما أنه يرث من الكلاس Hashtable, فهذا يعني أنه يملك جميع الدوال الموجودة فيه.
الفرق الأساسي بين الكلاس Properties و الكلاس Hashtable هو أن الكلاس Properties يمكنه تخزين Keys و Values فقط من النوع String.
بالإضافةً إلى أن الكلاس Properties يحتوي على دوال جاهزة للتعامل مع الملفات.
كونستركتورات الكلاس Properties
الجدول التالي يحتوي على جميع الكونستركتورات الموجودين في الكلاس Properties.
| الكونستركتور مع تعريفه | |
|---|---|
public Properties()
هذا الكونستركتور الإفتراضي في الكلاس Properties, يستخدم لإنشاء كائن نوعه Properties. |
|
public Properties(Properties defaultProperty)
يستخدم هذا الكونستركتور لإنشاء كائن نوعه Properties يملك عناصر مسبقة من كائن الـ Properties الذي نمرره كـ Argument.سيتم اللجوء إلى الكائن defaultProperty عند البحث عن قيمة مفتاح غير موجود في كائن الـ Properties. |
|
دوال الكلاس Properties
الجدول التالي يحتوي على جميع دوال الكلاس Properties.
| الدالة مع تعريفها | |
|---|---|
public String getProperty(String key)
ترجع قيمة المفتاح الذي نمرره لها كـ Argument.في حال كان كائن الـ Properties لا يحتوي على المفتاح الذي مررناه لها, ترجع القيمة null.ملاحظة: في حال كان كائن الـ Properties يملك كائن Properties إفتراضي يحتوي على المفتاح المطلوب و الذي لم يتم العثور عليه في كائن الـ Properties الذي قام باستدعائها, عندها سيتم إرجاع قيمته التي تم إيجادها في كائن الـ Properties الإفتراضي. |
|
public String getProperty(String key, String defaultProperty)
ترجع قيمة المفتاح الذي نمرره لها مكان الباراميتر key.في حال كان كائن الـ Properties لا يحتوي على المفتاح الذي مررناه لها, ترجع قيمة الـ defaultProperty. | |
public void list(PrintStream streamOut)
تنسخ محتوى كائن الـ Properties بالكامل في الملف الذي يشير له كائن الـ PrintStream.تنسخ محتوى كائن الـ
Properties الإفتراضي أيضاً.
public void list(PrintWriter streamOut)
تنسخ محتوى كائن الـ Properties بالكامل في الملف الذي يشير له كائن الـ PrintWriter.تنسخ محتوى كائن الـ
Properties الإفتراضي أيضاً.
public void load(InputStream streamIn) throws IOException
تنسخ محتوى الملف الذي يشير له كائن الـ InputStream في كائن الـ Properties.
public Enumeration propertyNames()
ترجع كائن نوع Enumeration يحتوي على جميع مفاتيح كائن الـ Properties.
public Object setProperty(String key, String value)
تستخدم لتبديل قيمة عنصر معين من عناصر كائن الـ Properties من خلال مفتاحه.و هي ترجع قيمة المفتاح القديمة, أو ترجع
null في حال كان الـ key الموضوع غير موجود و عندها سيتم إضافة الـ key و الـ value كعنصر جديد في كائن الـ Properties.الباراميتر
key هو المفتاح الذي سيتم تبديل قيمته.الباراميتر
value هو القيمة الجديدة التي ستعطى للمفتاح.
public void store(OutputStream streamOut, String comments)
تنسخ محتوى الـ Properties بالكامل في الملف الذي يشير له كائن الـ OutputStream. مع إضافة تعليقات فوق المحتوى.تنسخ محتوى الـ
Properties الإفتراضي أيضاً.الباراميتر
comments عبارة عن التعليقات التي سيتم إضافتها فوق محتوى كائن الـ Properties.
public void store(Writer streamOut, String comments)
تنسخ محتوى الـ Properties بالكامل في الملف الذي يشير له كائن الـ Writer, مع إضافة تعليقات فوق المحتوى.تنسخ محتوى الـ
Properties الإفتراضي أيضاً.الباراميتر
comments عبارة عن التعليقات التي سيتم إضافتها فوق محتوى كائن الـ Properties.
أمثلة شاملة
في كل مثال موضوع استخدامنا كونستركتور مختلف و دوال جديدة.
المثال الأول
في المثال التالي قمنا بتعريف كائن نوعه Properties, إسمه h, ثم أدخلنا فيه 12 عنصر.
بعدها قمنا بتخزين جميع المفاتيح في كائن نوعه Enumeration, إسمه keys.
و قمنا أيضاً بتخزين جميع القيم في كائن نوعه Enumeration, إسمه values.
بعدها عرضناهم كجدول يتألف من عامودين من خلال الحلقة while.
في الأخير قمنا بالبحث عن قيمة مفتاحين, واحد موجود و آخر غير موجود في الكائن الـ h.
import java.util.Properties; // Properties هنا قمنا باستدعاء الكلاس
import java.util.Enumeration; // Enumeration هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
// و الذي سنضع فيه كود البلد و إسمه p إسمه Properties هنا قمنا بتعريف كائن نوعه
Properties p = new Properties();
// كل عنصر يحتوي على كود البلد كمفتاح و إسمه كقيمة .h هنا قمنا بإضافة 12 عنصر في الكائن
p.put("+961", "Lebanon");
p.put("+962", "Jordan");
p.put("+963", "Syria");
p.put("+964", "Iraq");
p.put("+965", "Kuwait");
p.put("+966", "KSA");
p.put("+967", "Yaman");
p.put("+968", "Oman");
p.put("+970", "Palestine");
p.put("+212", "Morocco");
p.put("+281", "Libya");
p.put("+20", "Egypt");
// أي وضعنا اكواد البلاد فيه .keys بداخل الكائن p هنا قمنا بتخزين جميع مفاتيح الكائن
Enumeration keys = p.keys();
// أي وضعنا أسماء البلاد فيه .values بداخل الكائن p هنا قمنا بتخزين جميع قيم الكائن
Enumeration values = p.elements();
System.out.println("The table below contains all Codes & Countries \n");
System.out.println("---------------------");
System.out.println("Code \t | Country");
System.out.println("---------------------");
// ليس فارغاً. الفكرة هنا المرور على جميع المفاتيح الموجودة و عرض كل مفتاح موجود و قيمته keys هنا أنشأنا حلقة تستمر في تكرار نفسها طالما أن الكائن
while( keys.hasMoreElements() ) {
System.out.println(keys.nextElement() + "\t | " + values.nextElement());
}
System.out.println("---------------------\n");
// KSA هنا قمنا بالبحث عن إسم البلد الذي يملك الكود 996+ فكان الجواب
System.out.println("Which Country use the code +966 ?");
System.out.println(p.getProperty("+966", "Code not found!"));
// +لأنها القيمة التي وضعناها في حال عدم إيجاد الكود 123 Code not found! هنا قمنا بالبحث 123 إسم البلد الذي يملك الكود 123+ فكان الجواب
System.out.println();
System.out.println("Which Country use the code +123 ?");
System.out.println(p.getProperty("+123", "Code not found!"));
}
}
•سنحصل على النتيجة التالية عند التشغيل.
The table below contains all Codes & Countries
---------------------
Code | Country
---------------------
+281 | Libya
+966 | KSA
+965 | Kuwait
+964 | Iraq
+963 | Syria
+962 | Jordan
+961 | Lebanon
+212 | Morocco
+20 | Egypt
+970 | Palestine
+968 | Oman
+967 | Yaman
---------------------
Which Country use the code +966 ?
KSA
Which Country use the code +123 ?
Code not found!
المثال الثاني
في المثال التالي قمنا بتعريف كائن نوعه Properties, إسمه defaultNumbers, ثم أدخلنا فيه 10 عناصر.
بعدها قمنا بتعريف كائن آخر نوعه Properties, إسمه, ثم أدخلنا فيه أيضاً 10 عناصر.
الكائن arabicNumbers يستخدم الكائن defaultNumbers كـ Properties إفتراضي.
في الأخير قمنا بالبحث في الكائن arabicNumbers عن مفتاحين, واحد يملكه و الآخر يملكه إفتراضياً.
import java.util.Properties; // Properties هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
// و الذي سنضع فيه الأرقام باللغة الإنكليزية defaultNumbers إسمه Properties هنا قمنا بتعريف كائن نوعه
Properties defaultNumbers = new Properties();
// defaultNumbers هنا قمنا بإضافة 10 عناصر في الكائن
defaultNumbers.put("0", "Zero");
defaultNumbers.put("1", "One");
defaultNumbers.put("2", "Two");
defaultNumbers.put("3", "Three");
defaultNumbers.put("4", "Four");
defaultNumbers.put("5", "Five");
defaultNumbers.put("6", "Six");
defaultNumbers.put("7", "Seven");
defaultNumbers.put("8", "Eight");
defaultNumbers.put("9", "Nine");
// و الذي سنضع فيه الأرقام باللغة العربية arabicNumbers إسمه Properties هنا قمنا بتعريف كائن نوعه
// عند الحاجة له defaultNumbers هذا الكائن يستخدم الكائن
Properties arabicNumbers = new Properties(defaultNumbers);
// arabicNumbers هنا قمنا بإضافة 10 عناصر في الكائن
arabicNumbers.put("٠", "صفر");
arabicNumbers.put("١", "واحد");
arabicNumbers.put("٢", "إثنان");
arabicNumbers.put("٣", "ثلاثة");
arabicNumbers.put("٤", "أربعة");
arabicNumbers.put("٥", "خمسة");
arabicNumbers.put("٦", "ستة");
arabicNumbers.put("٧", "سبعة");
arabicNumbers.put("٨", "ثمانية");
arabicNumbers.put("٩", "تسعة");
// defaultNumbers عن رقم موجود فيه و رقم آخر حصل عليه من الكائن arabicNumbers هنا قمنا بالبحث في الكائن
System.out.println(arabicNumbers.getProperty("1"));
System.out.println(arabicNumbers.getProperty("١"));
}
}
•سنحصل على النتيجة التالية عند التشغيل.
One
واحد
المثال الثالث
في المثال التالي قمنا بتعريف كائن نوعه Properties, إسمه names, الهدف منه تخزين الأسماء بالإنجليزية و العربية, ثم أدخلنا فيه 5 عناصر.
في الأخير قمنا بالبحث في نسخ محتوى الكائن names في ملف جديد إسمه ar-en-names.txt.
import java.io.IOException; // IOException هنا قمنا باستدعاء الكلاس
import java.io.PrintWriter; // PrintWriter هنا قمنا باستدعاء الكلاس
import java.util.Properties; // Properties هنا قمنا باستدعاء الكلاس
public class Main {
public static void main(String[] args) {
// و الذي سنضع فيه الأٍسماء بالإنجليزية و العربية names إسمه Properties هنا قمنا بتعريف كائن نوعه
Properties names = new Properties();
// names هنا قمنا بإضافة 5 عناصر في الكائن
names.put("Ahmad" , "أحمد");
names.put("Ibrahim", "إبراهيم");
names.put("Samer" , "سامر");
names.put("Hala" , "هالة");
names.put("Rana" , "رنا");
try {
// لإنشاء ملف و الكتابة فيه لاحقاً FileWriter هنا قمنا بإنشاء كائن نوعه
PrintWriter fw = new PrintWriter("C:\\Users\\Mhamad\\Desktop\\ar-en names.txt");
// fw في الملف الذي يشير له الكائن names هنا قمنا بنسخ محتوى الكائن
names.list(fw);
// هنا قمنا بإغلاق إتصال البرنامج مع الملف و تنظيف الذاكرة
fw.flush();
fw.close();
}
// لإلتقاط أي خطأ قد يحدث بسبب الملف catch هنا وضعنا الجملة
catch(IOException e){
System.out.println("There is IOException!");
}
}
}
•بعد تشغيل البرنامج, قم بفتح الملف ar-en-names.txt و ستجد النص التالي بداخله التالية.
-- listing properties --
Ibrahim=إبراهيم
Samer=سامر
Rana=رنا
Hala=هالة
Ahmad=أحمد