تطبيق وصل wassll لمتابعة مخصصات المحروقات

المصفوفات Array في جافا

المصفوفة ( Array ) في لغة جافا, هي عبارة عن وسيلة لتخزين البيانات من نوع واحد بشكل مؤقت و تسمى باللغة الإنجليزية Array. وتعرف أيضاً على انها تقنية أو أداة لخزن البيانات من نوع واحد بشكل مؤقت وهي مقسمة لعدة خلايا وكل خلية لها عنوان index لذلك يسهل علينا معالجة البيانات وترتيبها وفرزها والبحث فيها بإستخدام المصفوفات.

أثناء عملنا في البرمجة يكون لدينا في بعض الأحيان بعض من البيانات و نريد أن نخزنها و نريد بأن نقوم بخزنها لكي نقوم بالتحكم بها. في هذه الحالة نقوم بإستخدام المصفوفات في اثناء عملنا في البرنامج حتى نستطيع معالجة البيانات. و هي داخل المصفوفة Array و يتم تخزين البيانات بها من نوع واحد فقط يعني إما int أو str أو char ...الخ. لا نستطيع خزن بيانات من أنواع مختلفة في مصفوفة واحدة يعني مثل str و int إلا إذا كان نوع. المصفوفة String يعني إذا كانت البيانات نوعها string نقوم. بتعريف لها مصفوفة string و إذا كانت int نعرف لها مصفوفة int.

 

فوائد إستخدام المصفوفات في البرمجة

1. خزن البيانات أثناء عملنا في البرنامج حتى نستطيع معالجتها.
2. فرز البيانات و ترتيبها.
3. البحث في البيانات.
4. مقارنة البيانات.
5. البحث عن عنصر معين مثل اكبر عنصر او اصغر عنصر داخل المصفوفة او إيجاد العناصر السالبة.

 

المصفوفات ذات بعد واحد Array 1D في جافا

نستطيع تخيل المصفوفة على أنها مستطيل مقسم إلى عدة خلايا, و أهم شيئ يلزم معرفته بأن لكل خلية عنوان مختلف لمعرفتها و تمييزها. مثل الإندكس بباقي اللغات و اول خلية عنوانها يكون 0.

type[] ArrayName=new Type[size];

إن Type نوع المصفوفة هل هو عددي أو نصي أو char أو أي نوع بيانات آخر.

و ArrayName هو إسم المصفوفة.

والكائن new لتحرير مساحة في الذاكرة للمصفوفة بنفس حجم المصفوفة.

و size يعني حجم المصفوفة أي كم هو عدد الخلاية التي نريدها مثلاً خمس خلايا أو ست خلايا.

int a=new int[5];

مثال 1

package javaapplication22;
public class JavaApplication22 {
    public static void main(String[] args) {
        int [] cs = new int [4];
        cs[0]=23;
        cs[1]=26;
        cs[2]=24;
        cs[3]=80;
        System.out.println(a[1]);
        System.out.println(a[3]);
    }
}

عند تنفيذ البرنامج سوف يطبع لنا 23 و 80 لأن حددنا له الخلاية الذي نريد عرض بياناتها.

مثال 2

اكتب برنامج يقوم بتعريف مصفوفة ذات بعد واحد من نوع نصي حجمها 5 خلايا, ثم قم بإظهار. رسالة للمستخدم تطالبه بإدخال خمسة أسماء, ثم يقوم. بترتيب هذه الأسماء بالأبجدية و طباعتها بشكل مرتب.

package javaapplication22;
import java.utl.Scanner;
public class JavaApplication22 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int i;
        String [] st=new String[5];
        System.out.println("Enter 5 Names");
        for(i=0;i<st.length;i++)
            st[i]=s.nextLine();
        Arrays.sort(st);
        for(i=0;i<st.length;i++)
            System.out.println(st[i]);
    }
}

قمنا بتضمين حزمة الإدخال عبر الأمر java.utl.Scanner ودخلنا للبرنامج الرئيسي.

قمنا بتعريف كائن s من كلاس حزمة الإدخال, و أنشأنا متغير عددي int وهو i من اجل إستخدامه لبداية اللوب.

وبعد ذلك عرّفنا مصفوفة نصية String كما هو مطلوب في نص المثال وحجمها 5 خلايا.

دخلنا لحلقة for تكرارية من اجل استقبال القيم عن طريقها و nextLine هو الكلاس المسؤول عن ادخال القيمة النصية.

ثم في النهاية رتبنا المصفوفة عبر sort و طبعناها.

مثال 3

اكتب برنامج يقوم بإظهار رسالة تطالب المستخدم بإدخال العنصر الذي يريد البحث عنه في المصفوفة., ثم البحث في المصفوفة بواسطة العنصر الذي ادخله المستخدم. في حال وجود العنصر طباعة رسالة تفيده بأنه تم إيجاد العنصر. مع طباعة موقع العنصر في المصفوفة, وفي حال عدم وجود العنصر طباعة رسالة تفيد بعدم وجود العنصر.

package javaapplication22;
import java.utl.Scanner;
public class JavaApplication22 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int []a={1,5,69,-5,7};
        boolean f=false;
        int se=s.nextInt();
        for(int i=0;i<a.length;i++)
            if(se==a[i])
            {
                f=true;
                System.out.println("is found " + i);
                break;
            }
        if(f==false)
            System.out.println("Not Found");
    }
}

في داخل البرنامج الرئيسي لقد قمنا بتعريف كائن مشتق من كلاس حزمة الإدخال وهو s. و أنشأنا مصفوفة نوعها int و اسندنا لها القيم بشكل مباشر و لا داعي لتحديد حجم المصفوفة. بعد ذلك قمنا بإنشاء متغير se يقوم بإستقبال المدخلات من المستخدم وتكون مدخلات عددية فقط. و ندخل هذا العدد الذي قام المستخدم بإدخاله في حلقة تكرارية for ووضعنا شروط في حال تم ايجاد العنصر يطبع انه تم ايجاده. وبحال لم يجده يطبع أنه لم يجده.

 

المصفوفات ذات بعدين Array 2D في جافا

هي عبارة عن مجموعة من الصفوف و الأعمدة المتقاطعة مشكّلة بتقاطعها بما يسمى بالخلايا. و تكون كما بالشكل الآتي يوضح شكل المصفوفة و الصفوف و الأعمدة.

الصفوف تأتي بشكل اُفقي و الأعمدة تأتي بشكل عمودي حيث يرمز للصفوف بالحرف M و لعدد الأعمدة يرمز لها N. من أهم الأشياء التي يجب أن نعرفها في المصفوفة ذات بعدين بأن لكل مصفوفة عنوان و كل عنوان يتكون من مقطعين. المقطع الأول نسميه "i" و المقطع الثاني نسميه "j" و هذه التسمية ليست ثابتة أو إجبارية و إنما شائعة. حيث الخلية في الجدول السابق 0,0 نلاحظ أنها مكونة من مقطعين الأول "i" و الثاني "j" و هكذا. من خلال الجدول السابق بأن الصف 0,0 و 0,1 و 0,2 و 0,3 نلاحظ من ذلك بأن الجزء "i" ثابت و هو 0 و الجزء "j" هو الذي يزداد.

و إذا نظرنا لها بشكل عمودي نلاحظ بأن "i" هو الذي يزداد و "j" هو ثابت. نلاحظ ايضاً بأن المصفوفة لها قطرين القطر الرئيسي باللون البرتقالي ننظر إليه من اليسار لليمين. و القطر الثانوي باللون الأصفر ننظر إليه من اليمين لليسار و هذا الجدول كان مثال بسيط لكيفية التعامل مع مصفوفة و عناوين خلايا المصفوفة ذات بعدين. و إذا نظرنا في القطر الرئيسي نجد بأن "i" تتساوى مع "j" و إذا جئنا للقطر الثانوي نجد أن العلاقة. بين "i" و "j" أنه عندما نجمعهم مع بعض ستكون النتيجة. تساوي حجم المصفوفة ناقص 1 حيث إذا جمعنا مثلاً 0+3 يساوي 3 و هكذا لجميع العناصر بداخل الخلية.

الشكل العام لتعريف المصفوفة ذات بعدين في جافا

type[][]Array_name=new Type[m][n]

حيث أن type نوع المصفوفة و نفتح مربعين [][] ثم إسم المصفوفة إختياري ثم يساوي new و هي. إستنساخ أو إنشاء مصفوفة بداخل الذاكرة بواسطة كلمة new ثم نكتب نوع المصفوفة و نعطيها الأحجام M و N.

مثال 4

package javaapplication22;
public class JavaApplication22 {
    public static void main(String[] args) {
        int [][]a=new int[4][4];
        a[0][2]=19;
        a[1][3]=25;
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a.length;j++)
                System.out.print(a[i][j]);
            System.out.println();
        }
    }
}

في البداية قلنا له خزّن لنا القيمة 19 في الخلاية 0 و 2 و القيمة 25 في الخلاية 1 و 3 ثم ادخلناه في حلقة لوب نوع for للـ i. و حلقة لوب ثانية للـ j و إستخدمنا بالبداية print من أجل الطباعة على الصف نفسه و لا نريد النزول. لسطر آخر لأنها مصفوفة ذات بعدين و نريد طباعتها على شكل مربع و ليست مصفوفة على بعد واحد.

مثال 5

انشئ مصفوفة ذات بعدين تستقبل قيم من لوحة مفاتيح المستخدم و تخزينها داخل المصفوفة و طباعتها بشكل مرتب بحجم 4*4 .

package javaapplication22;
import java.utl.Scanner;
public class JavaApplication22 {
    public static void main(String[] args) {
        Scanner n=new Scanner(System.in);
        int [][]a=new int[4][4];
        int i,j;
        for(i=0;i<a.length;i++)
        {
            for(j=0;j<a.length;j++)
                a[i][j]=n.nextInt();
        }
        for(i=0;i<a.length;i++)
        {
            for(j=0;j<a.length;j++)
                System.out.print(a[i][j]);
            System.out.println();
        }
    }
}

في البداية ضمننا حزمة الإدخال java.util.Scanner و دخلنا للبرنامج الرئيسي و عرّفنا كائن مشتق. من كلاس حزمة الإدخال و عرفّنا مصفوفة 4 في 4 و دخلنا. في حلقتين لوب في جزء الإدخال و حلقتين لوب في جزء طباعة عناصر المصفوفة.

كيفية طباعة عناصر القطر الرئيسي في المصفوفة Array2D؟

إذا طُلِبَ منّا طباعة عناصر القطر الرئيسي فقط ما هي الآلية التي سنستخدمها للتعامل مع المصفوفة ذات بعدين حتى نستطيع طباعه عناصر القطر الرئيسي؟. ذكرنا قبل قليل ببداية الدرس بأن عناصر القطر الرئيسي الذي كانت مضللة باللون البرتقالي. و قلنا أن العلاقة بالقطر الرئيسي هي "i" تساوي "j" إذا أردنا طباعة عناصره. هنا نكون قد استنتجنا شرط و هو نقوم فقط بكتابة شرط واحد عند طباعة عناصر المصفوفة. و هو عندما تكون "i" تساوي "j" إطبع هذه العناصر حتى نتمكن من طباعة القطر الرئيسي فقط.

مثال 6

إطبع عناصر القطر الرئيسي فقط من مصفوفة ذات بعدين 4*4.

package javaapplication22;
import java.utl.Scanner;
public class JavaApplication22 {
    public static void main(String[] args) {
        Scanner n=new Scanner(System.in);
        int [][]a=new int[4][4];
        int i,j;

        for(i=0;i<a.length;i++)
        {
            for(j=0;j<a.length;j++)
                a[i][j]=n.nextInt();
        }

        for(i=0;i<a.length;i++)
        {
            for(j=0;j<a.length;j++)
                System.out.print(a[i][j]+ " ");
            System.out.println();
        }
       
        for(i=0;i<a.length;i++)
        {
            for(j=0;j<a.length;j++)
                if(i==j)
                System.out.print(a[i][j])+ " ";
            System.out.println();
        }

    }
}

بنفس شرح المثال السابق 2 فقط إضفنا له لوب آخر و هو طباعة عناصر القطر الرئيسي فقط و كان الشرط هو إذا "i" تساوي "j" قم بتنفيذ الأوامر.