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

لماذا نحتاج إلى المصفوفات؟

عند العمل مع المتغيرات في Java، يمكنك الإعلان عن كل متغير وتهيئته على حدة، مثل:

java
int a = 19;
String name = "John Doe";

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

ما هي المصفوفات؟

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

int[] rollNumbers = new int[5];
String[] names = {"Alice", "Bob", "Charlie"};

بناء جملة المصفوفات

إن بناء جملة الإعلان عن مصفوفة في Java واضح ومباشر:

dataType[] arrayName = new dataType[size];

على سبيل المثال، لإنشاء مصفوفة مكونة من خمسة أعداد صحيحة:

int[] rollNumbers = new int[5];

بدلاً من ذلك، يمكنك الإعلان عن مصفوفة وتهيئتها في سطر واحد:

int[] rollNumbers = {23, 55, 9, 18, 45};

خصائص المصفوفات

عناصر متجانسة

في المصفوفة، يجب أن تكون جميع العناصر من نفس النوع. لا يمكنك مزج الأنواع ضمن مصفوفة واحدة؛ على سبيل المثال:

int[] nums = {1, 2, "three"}; // Will cause a compile-time error

حجم ثابت

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

إدارة الذاكرة الداخلية

تتكون المصفوفات في جافا من:

• ذاكرة المكدس: تخزن المتغير المرجعي للمصفوفة.
• ذاكرة الكومة: تخزن كائن المصفوفة الفعلي وعناصره.

عندما تعلن عن مصفوفة، يتم إنشاء المرجع في ذاكرة المكدس، ويتم تخزين كائن المصفوفة في ذاكرة الكومة.

تخصيص الذاكرة

هناك مرحلتان حاسمتان في تخصيص ذاكرة المصفوفة:

1. الإعلان: تم إنشاء المتغير المرجعي، لكنه لا يشير إلى أي مكان.
2. التهيئة: يشير المتغير المرجعي إلى كائن المصفوفة الفعلي في الكومة، والذي يحتوي على العناصر.

على سبيل المثال:

int[] rollNumbers; // Declaration
rollNumbers = new int[5]; // Initialization

تخصيص الذاكرة الديناميكية

تقوم Java بتخصيص الذاكرة الديناميكية، مما يعني أنه في وقت التشغيل، تقوم بتخصيص الذاكرة حسب الحاجة، مما يجعلها فعالة في إدارة الذاكرة.

الإدخال والإخراج في المصفوفات

أخذ المدخلات

لملء مصفوفة بإدخال المستخدم، يمكنك استخدام حلقة مع ماسح ضوئي لقراءة المدخلات من وحدة التحكم.

Scanner scanner = new Scanner(System.in);
int[] arr = new int[5];
for (int i = 0; i 




  
  
  مصفوفات الطباعة


يمكنك طباعة المصفوفات باستخدام الحلقات أو طريقة الأداة المساعدة Arrays.toString() للحصول على مخرجات أكثر قابلية للقراءة.


for (int i = 0; i 



أو


System.out.println(Arrays.toString(arr));





  
  
  المصفوفات متعددة الأبعاد


المصفوفات أو المصفوفات ثنائية الأبعاد هي مصفوفات من المصفوفات. يبدو بناء جملة المصفوفة ثنائية الأبعاد كما يلي:


int[][] matrix = new int[3][3];





  
  
  مثال




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




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


  
  
  ArrayList: بديل ديناميكي


المصفوفات في Java ذات حجم ثابت، مما يؤدي إلى عدم الكفاءة عندما يكون عدد العناصر غير معروف في وقت الترجمة. يمكن التغلب على هذا القيد باستخدام فئة ArrayList، وهي جزء من Java Collections Framework.


  
  
  باستخدام قائمة المصفوفة


 توفر فئة ArrayList تغيير الحجم الديناميكي. إليك بناء الجملة لإنشاء ArrayList:


ArrayList numbers = new ArrayList();




يمكنك إضافة العناصر ومعالجتها ديناميكيًا:


numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println(numbers); // Output: [1, 2, 3]

numbers.set(1, 10); // Change element at index 1
System.out.println(numbers); // Output: [1, 10, 3]

numbers.remove(0); // Remove element at index 0
System.out.println(numbers); // Output: [10, 3]

boolean contains = numbers.contains(10); // Check if the list contains 10
System.out.println(contains); // Output: true





  
  
  العمل الداخلي لقائمة ArrayList


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


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



  
  
  العثور على العناصر القصوى


للعثور على الحد الأقصى للعنصر في المصفوفة، قم بالتكرار عبر المصفوفة وتتبع أعلى قيمة:


int max = arr[0];
for (int i = 1; i  max) {
        max = arr[i];
    }
}
System.out.println("Maximum value: "   max);





  
  
  عكس مصفوفة


لعكس مصفوفة، استخدم تقنية المؤشرين:


public static void reverse(int[] arr) {
    int start = 0;
    int end = arr.length - 1;
    while (start 



استدعاء الدالة العكسية:


int[] arr = {1, 2, 3, 4, 5};
reverse(arr);
System.out.println(Arrays.toString(arr)); // Output: [5, 4, 3, 2, 1]





  
  
  خاتمة


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