المصفوفات ثنائية البعد في جافا (Two-dimensional Arrays in Java)

تُعد المصفوفات ثنائية البعد (Two-dimensional Arrays) من أهم هياكل البيانات التي تُستخدم في البرمجة بلغة جافا Java، حيث تتيح تخزين البيانات بطريقة منظمة على شكل جداول أو مصفوفات، مما يسهل التعامل مع البيانات المعقدة التي تتطلب هيكلة على شكل صفوف وأعمدة. في هذا المقال سيتم التعمق في شرح المصفوفات ثنائية البعد في جافا من حيث مفهومها، كيفية إنشائها، التعامل معها، العمليات التي يمكن إجراؤها عليها، بالإضافة إلى تطبيقات عملية وأمثلة توضيحية شاملة.

مفهوم المصفوفات ثنائية البعد في جافا

المصفوفة ثنائية البعد هي عبارة عن مصفوفة تحتوي على مصفوفات أخرى بداخلها، حيث يمكن تصورها على شكل جدول من الصفوف والأعمدة. كل عنصر في هذه المصفوفة يُعرف بموقعه من خلال رقم الصف ورقم العمود.

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

في جافا، المصفوفة ثنائية البعد هي في الأساس مصفوفة من المصفوفات، حيث أن كل صف هو عبارة عن مصفوفة منفصلة.

كيفية إنشاء مصفوفة ثنائية البعد في جافا

يمكن إنشاء مصفوفة ثنائية الأبعاد في جافا باستخدام أكثر من طريقة، كما يلي:

1. تعريف مصفوفة ثنائية البعد مع تحديد الحجم فقط

java
CopyEdit
int[][] matrix = new int[3][4];

في المثال أعلاه، يتم إنشاء مصفوفة من النوع int تحتوي على 3 صفوف و4 أعمدة. جميع القيم تبدأ بالافتراضي وهو 0 في حالة الأعداد الصحيحة.

2. تعريف مصفوفة ثنائية البعد مع التهيئة المباشرة

java
CopyEdit
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

هذا المثال يُظهر إنشاء مصفوفة 3×3 مع قيم محددة لكل عنصر.

3. تعريف مصفوفة ثنائية البعد بدون تحديد عدد الأعمدة مسبقًا

java
CopyEdit
int[][] matrix = new int[3][];
matrix[0] = new int[2];
matrix[1] = new int[4];
matrix[2] = new int[3];

هذا الشكل يُستخدم في المصفوفات “غير المنتظمة” حيث قد يختلف عدد الأعمدة في كل صف.

الوصول إلى عناصر المصفوفة

يمكن الوصول إلى أي عنصر في المصفوفة باستخدام مؤشر الصف ومؤشر العمود كما يلي:

java
CopyEdit
int value = matrix[1][2];

في هذا المثال، يتم الوصول إلى العنصر الموجود في الصف الثاني (مؤشر 1) والعمود الثالث (مؤشر 2).

التكرار على المصفوفة ثنائية البعد

يتم التكرار عادةً على المصفوفة باستخدام حلقات متداخلة (nested loops) للتنقل بين الصفوف والأعمدة:

java
CopyEdit
for (int i = 0; i < matrix.length; i++) {          // i يمثل الصفوف
    for (int j = 0; j < matrix[i].length; j++) {   // j يمثل الأعمدة
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

• matrix.length يعطي عدد الصفوف.

• matrix[i].length يعطي عدد الأعمدة في الصف i.

العمليات الشائعة على المصفوفات ثنائية البعد

1. ملء المصفوفة بالقيم

يمكن ملء المصفوفة بالقيم باستخدام حلقات متداخلة:

java
CopyEdit
int counter = 1;
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        matrix[i][j] = counter++;
    }
}

2. نسخ المصفوفة

يمكن نسخ المصفوفة عن طريق تكرار العناصر:

java
CopyEdit
int[][] copy = new int[matrix.length][matrix[0].length];
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        copy[i][j] = matrix[i][j];
    }
}

3. جمع مصفوفتين

لجمع مصفوفتين بنفس الأبعاد:

java
CopyEdit
int[][] sum = new int[matrix.length][matrix[0].length];
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        sum[i][j] = matrix1[i][j] + matrix2[i][j];
    }
}

4. ضرب مصفوفتين

عملية ضرب المصفوفات تتطلب توافق الأبعاد، بحيث يكون عدد أعمدة المصفوفة الأولى مساويًا لعدد صفوف المصفوفة الثانية.

java
CopyEdit
int[][] multiply(int[][] A, int[][] B) {
    int rowsA = A.length;
    int colsA = A[0].length;
    int rowsB = B.length;
    int colsB = B[0].length;

    if (colsA != rowsB) {
        throw new IllegalArgumentException("أبعاد المصفوفات غير متوافقة للضرب");
    }

    int[][] result = new int[rowsA][colsB];

    for (int i = 0; i < rowsA; i++) {
        for (int j = 0; j < colsB; j++) {
            for (int k = 0; k < colsA; k++) {
                result[i][j] += A[i][k] * B[k][j];
            }
        }
    }
    return result;
}

المصفوفات غير المنتظمة (Jagged Arrays)

في جافا، المصفوفات ثنائية البعد ليست ملزمة بأن تكون ذات أبعاد متساوية، حيث يمكن أن يكون طول كل صف مختلفًا عن الآخر، مما يُعرف بالمصفوفة غير المنتظمة أو “jagged array”.

مثال:

java
CopyEdit
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[2];
jaggedArray[1] = new int[4];
jaggedArray[2] = new int[3];

هذا يتيح مرونة أكثر عند الحاجة إلى تخزين بيانات ذات أبعاد مختلفة.

تطبيقات المصفوفات ثنائية البعد في البرمجة

تستخدم المصفوفات ثنائية الأبعاد في العديد من المجالات، منها:

• الجداول الحسابية: تخزين البيانات في شكل صفوف وأعمدة مثل جداول إكسل.

• الرسوميات: تمثيل الصور الرقمية حيث كل عنصر يمثل لون نقطة معينة.

• الألعاب: تمثيل خرائط الألعاب أو لوحات اللعب مثل لعبة الشطرنج أو السودوكو.

• المعادلات الرياضية: تخزين معطيات الأنظمة الخطية ومصفوفات التحويل.

• الذكاء الاصطناعي: تخزين البيانات والمعطيات المستخدمة في الشبكات العصبية.

• نظم قواعد البيانات: تخزين وعرض البيانات بشكل منظم.

الفرق بين المصفوفة أحادية البعد وثنائية البعد

نصائح عند التعامل مع المصفوفات ثنائية البعد في جافا

1. التأكد من صحة الأبعاد: قبل تنفيذ العمليات مثل الجمع أو الضرب، يجب التأكد من توافق أبعاد المصفوفات.

2. معالجة المصفوفات غير المنتظمة بحذر: عند التعامل مع jagged arrays يجب الانتباه لأن طول كل صف قد يختلف.

3. استخدام الحلقات المتداخلة بشكل فعال: تجنب تكرار العمليات غير الضرورية داخل الحلقات.

4. فهم استهلاك الذاكرة: المصفوفات الكبيرة قد تستهلك مساحة كبيرة في الذاكرة مما قد يؤثر على أداء البرنامج.

5. استخدام مكتبات خارجية عند الحاجة: مثل مكتبة Apache Commons Math لتسهيل العمليات الرياضية المعقدة.

مثال عملي كامل لبرنامج باستخدام مصفوفة ثنائية الأبعاد

java
CopyEdit
public class TwoDArrayExample {
    public static void main(String[] args) {
        int[][] matrix = {
            {3, 5, 7},
            {1, 6, 9},
            {4, 8, 2}
        };

        // طباعة المصفوفة
        System.out.println("مصفوفة الإدخال:");
        printMatrix(matrix);

        // إيجاد أكبر عنصر في كل صف
        for (int i = 0; i < matrix.length; i++) {
            int max = matrix[i][0];
            for (int j = 1; j < matrix[i].length; j++) {
                if (matrix[i][j] > max) {
                    max = matrix[i][j];
                }
            }
            System.out.println("أكبر قيمة في الصف " + i + " هي: " + max);
        }
    }

    public static void printMatrix(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

الخلاصة

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

المصادر والمراجع

• Oracle Java Documentation – Arrays

• Herbert Schildt, Java: The Complete Reference, 11th Edition, McGraw-Hill Education, 2018.