freeCodeCamp/guide/arabic/java/arrays/index.md

---
title: Arrays
localeTitle: المصفوفات
---
# مجموعة مصفوفة

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

**بناء الجملة:**

```java
dataType[] arrayName;   // preferred way
``` 

هنا ، يصف `java datatype[]` أن جميع المتغيرات التي تم ذكرها بعد ذلك سيتم إنشاء مثيل لها كمصفوفات من نوع البيانات المحدد. لذا ، إذا أردنا إنشاء مزيد من المصفوفات من نوع البيانات المماثل ، فكل ما علينا `java arrayName` هو إضافتها بعد `java arrayName` المحدد (لا تنسى فصلها عبر الفواصل فقط). ويرد مثال أدناه في القسم التالي للرجوع إليه.

```java
dataType arrayName[];  //  works but not preferred way
``` 

هنا ، يصف `java datatype` فقط أن المتغيرات المذكورة بعد أن تنتمي إلى هذا النوع من البيانات. إلى جانب ذلك ، يصف `java []` بعد اسم المتغير أن المتغير هو صفيف من نوع البيانات المحدد (وليس مجرد قيمة أو كائن من هذا النوع من البيانات). لذا ، إذا أردنا إنشاء مزيد من المصفوفات من نوع البيانات المماثل ، فسوف نضيف أسماء المتغيرات بعد الاسم المحدد بالفعل ، مفصولة بفواصل وكل مرة سيتعين علينا إضافة `java []` بعد اسم المتغير وإلا فسيكون المتغير إنشاء مثيل كمتغير تخزين قيمة عادية (وليس صفيف). لفهم أفضل يتم إعطاء مثال في المقطع التالي.

## مقتطفات الشفرة للبناء أعلاه:

```java
double[] list1, list2; // preferred way
``` 

فوق المقتطف التعليمات البرمجية instantiates 2 صفائف من أسماء مزدوجة النوع list1 و list2.

```java
double list1[], list2; // works but not preferred way
``` 

فوق المقتطف الشفوي مصفوفة من نوع البيانات مزدوج المسمى list1 ومتغير بسيط من نوع البيانات مزدوج المسمى list2 (لا تخلط مع قائمة **name2** . أسماء المتغيرات لا علاقة لها بنوع المتغير).

ملاحظة: لا يتم تفضيل `double list[]` للنمط `double list[]` لأنها تأتي من لغة C / C ++ وتم اعتمادها في Java لاستيعاب المبرمجين C / C ++. بالإضافة إلى أنه أكثر قابلية للقراءة: يمكنك أن تقرأ أنه "مجموعة مزدوجة تسمى قائمة" بخلاف "قائمة مزدوجة تسمى صفيف"

## إنشاء المصفوفات:

```java
dataType[] arrayName = new dataType[arraySize];
``` 

## مقتطفات الشفرة للبناء أعلاه:

```java
double[] List = new double[10];
``` 

## طريقة أخرى لإنشاء صفيف:

```java
dataType[] arrayName = {value_0, value_1, ..., value_k};
``` 

## مقتطفات الشفرة للبناء أعلاه:

```java
double[] list = {1, 2, 3, 4};

The code above is equivalent to:
double[] list = new double[4];
*IMPORTANT NOTE: Please note the difference between the types of brackets
that are used to represent arrays in two different ways.
``` 

## الوصول إلى المصفوفات:

```java
arrayName[index]; // gives you the value at the specified index
``` 

## مقتطفات الشفرة للبناء أعلاه:

```java
System.out.println(list[1]);
``` 

انتاج:

```
2.0
``` 

## تعديل المصفوفات:

```java
arrayName[index] = value;
``` 

ملاحظة: لا يمكنك تغيير حجم أو نوع الصفيف بعد تهيئته. ملاحظة: يمكنك مع ذلك إعادة ضبط المصفوفة مثل ذلك

```java
arrayName = new dataType[] {value1, value2, value3};
``` 

## حجم المصفوفات:

من الممكن العثور على عدد العناصر في صفيف باستخدام "سمة الطول". تجدر الإشارة هنا إلى أن `java length` هو **سمة** لكل صفيف أي اسم متغير يخزن طول المتغير. يجب عدم الخلط بينه وبين **طريقة** الصفيف لأن الاسم هو نفس طريقة `java length()` المطابقة لفئات String.

```java
int[] a = {4, 5, 6, 7, 8}; // declare array
System.out.println(a.length); //prints 5
``` 

## مقتطفات الشفرة للبناء أعلاه:

```java
list[1] = 3; // now, if you access the array like above, it will output 3 rather than 2
``` 

_مثال على الكود:_

```java
int[] a = {4, 5, 6, 7, 8}; // declare array
for (int i = 0; i < a.length; i++){ // loop goes through each index
    System.out.println(a[i]); // prints the array
}
``` 

انتاج:

 `    4 
    5 
    6 
    7 
    8 
` 

### صفائف متعددة الأبعاد

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

```java
int M = 5;
int N = 5;
double[][] a = new double [M][N]; //M = rows N = columns
for(int i = 0; i < M; i++) {
    for (int j = 0; j < N; j++) {
        //Do something here at index
    }
}
``` 

ستنفذ هذه الحلقة M ^ N مرة وستبني هذا:

\[0 | 1 | 2 | 3 | 4\]  
\[0 | 1 | 2 | 3 | 4\]  
\[0 | 1 | 2 | 3 | 4\]  
\[0 | 1 | 2 | 3 | 4\]  
\[0 | 1 | 2 | 3 | 4\]

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

```java
int a=2, b=3, c=4;
int[][][] a=new int[a][b][c];
``` 

بطريقة مماثلة ، يمكن للمرء أن مجموعة من أبعاد مثل ما هو / هي ترغب في ولكن تصور مجموعة من أكثر من 3 أبعاد يصعب تصور بطريقة معينة.

### Jagged Arrays

الصفائف الخشنة هي صفائف متعددة الأبعاد لها عدد محدد من الصفوف ولكن عدد الأعمدة متفاوت. يتم استخدام الصفائف الخشنة للحفاظ على استخدام الذاكرة للمصفوفة. فيما يلي مثال الكود:

```java
int[][] array = new int[5][]; //initialize a 2D array with 5 rows
array[0] = new int[1]; //creates 1 column for first row
array[1] = new int[2]; //creates 2 columns for second row
array[2] = new int[5]; //creates 5 columns for third row
array[3] = new int[5]; //creates 5 columns for fourth row
array[4] = new int[5]; //creates 5 columns for fifth row
``` 

انتاج:

\[0\]  
\[0 | 1\]  
\[0 | 1 | 2 | 3 | 4\]  
\[0 | 1 | 2 | 3 | 4\]  
\[0 | 1 | 2 | 3 | 4\]

#### معلومات اكثر:

*   المصدر: [Java Arrays](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html)