Introduction To Java Programming CH6

‫ ا
ا ا‬
Java Programming Introduction to
Chapter 6 Arrays
‫ و ازاي ﻥﻡ! ﻡه و اه ای‬array ‫ ا دة هف ان ء ا
ی ای‬
. %‫ &! اﻡ‬
Basics Array .٦.٢
4‫د * و آ‬06‫ﻡ ا‬78‫ و ﻥ‬double ‫ع‬0‫م ﻡ ا‬2‫ ار‬١٠ !%‫ض اﻥ *وزی ﻥ‬,
&‫! آ! ﻡ‬%‫ و ﻥ‬double ‫ع‬0‫ ﻡ&ات ﻡ ا‬١٠ ‫ اﻥ ﻥف‬6,‫ة آ ه‬7‫! آ‬2 9 2:*
:A‫ا ﻡ‬0‫ ﻡ&ات آﻥ‬١٠ ‫ش‬0‫ﻥ‬6‫ض اﻥ ﻡ‬, => =? ‫ و > دة‬4%‫ *وزی ﻥ‬4‫ا@ ا‬
‫ع دة‬0B0 ‫ ا‬4* ‫ وت‬arrays ‫ ال‬.6 =?‫ع ه@ ا‬0B0 ‫ ا‬7‫ ﻡ& اآ‬١٠٠٠ ‫ او‬١٠٠
.‫ع‬0‫ ا‬D,‫* ﻡ&ات ﻡ ﻥ‬0 %‫ اﻥ ﻡ‬array ‫ل * ال‬0@‫ر ﻥ‬7@‫ی@ ﻥ‬
Variables Declaring Array .٦.٢.١

array reference ‫ء دة هف ازاي ﻥف ال‬E%‫ ا‬
array ! reference ‫ن‬06 &‫ول ﻥف ﻡ‬F‫زم ا‬F ‫د‬0‫ اي آ‬array ‫م ال‬78‫ن ﻥ‬4*
.4* ‫ دة ور‬G ‫ ا‬4‫اﺕ ا‬7‫ع ا‬0‫ﻡ و ﻥف ﻥ‬78‫ ه‬4‫ا‬
‫! دة‬6 array ‫ ال‬I‫و >ی@ ﺕی‬
dataType[] arrayRefVar;
‫او‬
dataType arrayRefVar[]; // This style is allowed, but not preferred
@‫ی‬J‫ی@ آ ا‬J ‫ل‬A‫ﻡ اآ ﻡ اﻥ و دة ﻡ‬78 !6‫و ا‬F‫ی@ ا‬J‫و ا‬
double[] myList;
‫او‬
double myList[]; // This style is allowed, but not preferred
Arrays Creating .٦.٢.٢

D array ‫ن ال‬E8‫ ه‬4‫اﺕ ا‬7‫ع ا‬0‫ و ﻥ‬array reference ‫ ت * ال‬4‫ء ا‬E%‫ ا‬
‫ ﺝ‬4* ‫ ور‬N‫ ﻡ‬reference ‫رى ی ال‬0 ‫ن ا‬6‫ﻥش ﻡ‬E%L‫ ﻡ‬20‫ د‬7L
‫ اي داﺕ‬array ‫ ال‬O‫رش ا‬72‫ة ان ﻡ‬7‫ ﻡ آ‬,‫ و ﻥ‬null 2 @‫ة ی‬76 ‫رى و‬0 ‫ا‬
‫ﻡ‬78‫ر اﺱ‬72‫ن ا‬4*(‫رى‬0 ‫ن ا‬6‫ ﻡ‬E%‫ )ا‬array ‫ ال‬P‫ ازاي اﻥ‬4‫ء دة @ ه‬E%‫ا‬
.‫ة‬7‫ آ‬7
‫! دة‬6 reference ! ‫رى‬0 ‫ن ا‬6‫ ﻡ‬E% @‫و >ی‬
arrayRefVar = new dataType[arraySize];
‫ ! ﺝ‬T‫ ﺕ‬4‫ ا‬4 %‫ا‬

=6 ‫اس‬02F‫ اﻥ ا‬X:‫[ و ﻥ‬new dataType[arraySize ‫ام‬78‫ ﺱ‬array ‫ ال‬U‫اﻥ‬.١
‫ ه@ ال‬array ‫م ال‬2‫ ار‬١٠ !%‫ *وزی ﻥ‬0 ‫ ا *وزی ی‬4‫ا ا‬
.arraySize = 10
‫ة‬7‫! آ‬2 ‫ آ ﻡ‬array ! reference ‫دﻥ‬7.٢
‫و اﻥ ا*ف ال‬F‫ﺕ ا‬0J‫زم ا* ! ﺥ‬F ‫ آن‬array ‫م‬78‫ن اﺱ‬4* ‫ة‬7‫! آ‬2 0 ‫زي ﻡ‬
‫ﺕ‬0J8‫ ا‬Z‫ﻡ‬7‫ ﻥ‬6 ‫ ا ﻡ‬,‫ ﻥ‬array ‫ ال‬P‫ و اﻥ اﻥ اﻥ‬data type ‫ و ال‬reference
‫! دة‬6 7‫دول اﻡ وا‬
arrayRefVar = new dataType[arraySize];
‫ی@ دى‬J‫ ا‬4LB0‫ل ی‬A‫و دة ﻡ‬

double[] myList = new double[10];
‫ﻥ ﻡ‬06‫ اﻥ ﻡ‬02 ‫ و‬double ‫ع‬0‫! ﻥت ﻡ ا‬%‫ ه‬array U‫ ت اﻥ‬4‫ﻡ ا‬F‫ ا‬
.myList ‫ اﺱ‬reference ‫ *? و ان ال‬١٠
2 ١٠ ‫! ال‬%‫ ت و ﻡ‬4‫ل ا‬A ‫[ ا‬B0‫رة دى ﺕ‬0\‫و ا‬
١٠ ‫ﻥ ﻡ‬06‫ ﻡ‬double ‫ع‬0‫ ﻡ ا‬array ‫ ـ‬reference @@L‫ ا‬0‫ ه‬myList : ]0L4‫ﻡ‬
‫ق‬,‫ و ﻥ ! ا‬array `‫ ه‬myList ‫ل ان‬0@‫م دة ﻥ‬:6‫ل آ! ا‬0@‫ل ﻡ ﻥ‬7 6 ‫ ا ﻡ‬D ?*
.array ‫ و اـ‬reference ‫ ال‬
Values Array Size and Default .٦.٢.٣
6 ‫ ﻡ‬4‫د ا? ا‬7* =6‫د ﻡ ﻥ ﻥ‬7L ‫زم‬F array ! ‫رى‬0 ‫ن ا‬6‫ ﻡ‬E%L ‫اﻡ‬
array ‫ ﻥف ﻡ اي‬6 ‫ ﻥ& ﻡ و ﻡ‬N,‫ ﻡ اﻥﺉ ﻡ‬7 ‫ﻥ و‬E8‫ﻥ‬
.١٠ ‫ ﺕوى‬myList.length ‫ ت‬4‫ل ا‬A ‫ ا‬arrayRefVar.length ‫ام‬78‫ﺱ‬
‫اﺉ و‬7‫ ا‬2 !%‫ن ﻡ‬06 ‫ *وزی‬4‫ ا@ ا‬OL‫! ﻡ ﻥ‬2 array ‫ ال‬P ‫اول ﻡ‬
@‫! وف ی‬%‫ ه‬0 ‫ اﻥ‬٠ @‫م ی‬2‫ر‬F‫ع ﻡ ا‬0‫ن اي ﻥ‬E8‫ ه‬array ‫ ال‬0 `‫ه‬
.false !%‫ ه‬Boolean ‫ع‬0‫ ﻡ ا‬T‫ آﻥ‬0 ‫' و‬u0000\'
Variables Array Indexed .٦.٢.٤
-٠ ‫م‬g 0‫ و ه‬index ‫ام ال‬78‫م اي *\ ﺱ‬78‫ و ﻥ‬array ‫ ﻥ@! *? ال‬6 ‫ﻡ‬
‫اس‬02F‫= ا‬6 4‫ ا‬0‫ ه‬index ‫ ان ال‬X:‫ و ﻥ‬,\‫أ ﻡ ا‬7 7‫ ان ا‬j‫ و دة ﻡ‬based
‫رم دى‬0, array ‫ اﺱ ال‬7 []‫! دة‬6 4‫ا‬
arrayRefVar[index];
‫ و‬٠ ‫أ ب‬7‫ ی@ ه‬arrayRefVar.length ‫ ﻡ‬array ‫ ال‬0 ‫ ت ان‬4‫م ا‬:6‫ ﻡ ا‬,‫ﻥ‬
١٠ mylist (‫رة‬0\‫ ت ) ا‬4‫ل ا‬A ‫ ا‬arrayRefVar.length-1 ‫ﺕ ـ‬
.٩ 2‫ ا\ ر‬7* ‫ا‬0‫ و ی‬٠ ‫ا ﻡ‬0‫ﺉ‬7‫ ی‬double ‫ع‬0‫*? ﻡ ا‬
‫ زي ﻡ آ‬indexed variable ‫ام ال‬78‫م *?ه ﺱ‬78‫ ﻥ‬6 ‫ ﻡ‬array ‫ ال‬P ‫ ﻡ‬7
‫م دة‬:6‫ ا‬4* ‫ل‬A‫ ادى و دة ﻡ‬variable ‫م ال‬78
myList[2] = myList[0] + myList[1];
array ‫ آ! *\ ﻡ *? ال‬2 OL‫ *ن ﻥ‬loop ‫م ال‬78‫ل ﺕﻥ ه‬A‫ل ﻡ‬0@‫و ه‬
‫ا‬o6‫ و ه‬١ OL‫[ ه‬myList[1 ‫ و‬٠ OL‫[ ه‬myList[0 ‫ص ی‬8‫ ا‬index ‫ال‬
for (int i = 0; i < myList.length; i++) {
myList[i] = i;
}
Initializers Array .٦.٢.٥

‫ و‬U‫ و ﻥ‬array ‫ ﻥف ال‬7‫ ﺝت اﻡ وا‬٣ ! ‫ ﻥ‬6 ‫\ة ﻡ‬8‫ >ی@ ﻡ‬%‫ ا‬
‫ی@ دى‬J‫! ع ا‬6‫ ا@ و دة ا‬OL‫ﻥ‬
dataType[] arrayRefVar = {value0, value1, ..., valuek};
4* ‫ل‬A‫و دة ﻡ‬
double[] myList = {1.9, 2.9, 3.4, 3.5};
‫ ! دى‬%‫* ا‬0 %‫ ﻡ‬P6 T‫ ﺕ‬4‫ ا‬4 %‫ا‬
double[] myList = new double[4];
myList[0] = 1.9;
myList[1] = 2.9;
myList[2] = 3.4;
‫ آ‬array ‫د *? ال‬7* 0 ‫ﻥ‬7,‫ ه‬N‫\ة دى ﻡ‬8 ‫ی@ ا‬J‫ ا‬7‫ اآ‬D
@‫ی‬J‫ﻡ ا‬78‫ اﺱ‬0 ‫زم ﻥف ان‬F ‫ و‬new 4‫ﻡش آ‬78‫ ﻡﺱ‬T‫ ﺕ‬4‫ی@ ا‬J‫ ان ا‬X:‫ﻥ‬
4 * 0 ‫ة اﻥ‬7‫ وا‬4 ‫ ا@ آ! دة ﺝ‬4JL‫ و ﻥ‬U‫ و ﻥ‬array ‫زم ﻥف ال‬F @‫دى ی‬
4‫د ا‬06‫ ه&! زي ا‬N‫ ﻡ‬Z‫ و اﻥﻡ‬syntax error @‫ ه‬4 ‫ اآ ﻡ ﺝ‬4* ‫ﺝت دى‬L‫ا‬
qJ‫د ﺥ‬0‫ دة آ‬0@‫ه‬
double[] myList;
myList = {1.9, 2.9, 3.4, 3.5};
qJ8‫ ا‬D,‫ ﻥ‬N@‫ل *ن ﻡ‬A‫د ﻡ‬%‫ ﻡ‬0‫ و ه‬qJ‫د دة ﺥ‬06‫ا‬
Arrays Processing .٦.٢.٦

‫ و دة‬for loop ‫م ال‬78 array ‫ *? ال‬4* ‫ت‬4 * ‫ *وزی ﻥ ! اي‬0 ‫ا‬
‫ﻡ‬
‫ن‬06 4* 4 * ‫ال اي‬0F‫= ا‬4s‫ع و اي ا‬0‫ ا‬D,‫ ﻡ ﻥ‬array ‫ن آ! *? ال‬F•
‫ار‬6‫ام ا‬78‫ی@ ﺱ‬J‫ ا‬D,
.loop for ‫م ال‬78‫ اﻥ ﻥ‬J ‫ول‬F‫ن ﻡوف ﻡ ا‬06 array ‫ ال‬% ‫ن‬F•
array ‫اﺉ ال‬0* 2 OL‫ ازاي ﻥ‬4‫ل ی‬A‫و دة ﻡ‬
myList[i] = Math.random() * 100;
}
‫ و ﻥ= ﻡ‬7‫ وا‬J‫ ا ﺱ‬4* array ?* tJ‫ ازاي ﻥ‬4LB0‫ل ﺕﻥ ه‬A‫و دة ﻡ‬
2‫ آ! ر‬
System.out.print(myList[i] + " ");
}
loop ‫م ال‬78‫زم ﻥ‬F ‫ و آن‬double ‫ع‬0‫ ﻡ ا‬T‫ و آﻥ‬array ‫ ت > ال‬4‫ل ا‬A ‫ ا‬
@‫ی‬J *J‫ام اﻡ ا‬78‫ل ﺱ‬0> 4* >‫ ا‬6 ‫ ﻡ‬char ‫ع‬0‫ ﻡ ا‬array ‫ﻥ‬7* 0 ‫آ‬F
‫دى‬
char[] city = {'D', 'a', 'l', 'l', 'a', 's'};
System.out.println(city);
‫ و اﺱ‬double ‫ع‬0‫ ﻡ& ﻡ ا‬Z‫ اﺕ‬OL‫ و ﻥ‬array ‫ آ! *? ال‬t %‫ل ﺕﻥ ﻥ‬A‫ل ﻡ‬0@‫ه‬
array ! ?‫ ا‬t %‫أ ﻥ‬7‫ب ه‬04‫ار ا‬6‫ ﺕ‬t‫ و ﻡ‬٠ ‫اﺉ‬7‫ ا‬2 J ‫ول‬F‫ ا‬total
( ١ – %) ‫ ﻥی‬7L ٠ ‫ یوى‬index ‫*\ *\ ﻡ ال‬
double total = 0;
total += myList[i];
}
‫ع‬0‫ و هف ﻡ& ﻡ ا‬array ‫ اآ *\ ﻡ *? ال‬t4J‫ن ﻥ‬4* ‫ل ﺕﻥ‬A‫و دة ﻡ‬
4‫ دة ا‬array ‫ اول *\ ال‬2 ‫اﺉ ﺕوى‬7‫ ا‬2 max ‫ دو اﺱ‬double
array ‫! *? ال‬6 ‫ و ه@رن ا & دة‬array ‫ \ ﻡ *? ال‬2 ‫! اآ‬%‫ه‬
‫ ا\ ا & و‬2 !%‫ اآ ﻡ ا & ه‬array ‫ *\ ال‬2 0 ‫ب‬04‫ام ا‬78‫ﺱ‬
‫ا‬o6‫ة و ه‬7 4‫\ ا‬4 !@‫ ه ! ﺝ و ﻥ‬N‫! ﻡ‬2‫ ا‬0 ‫ة‬7 4‫\ ا‬4 !@‫ﻥ‬
double max = myList[0];
if (myList[i] > max) max = myList[i];
}
‫د‬06‫ و ه@ ا‬2‫ ع اآ ر‬index ‫! ال‬%‫ اﻥ ﻥ‬vL ‫ق‬0 4‫د ا‬06‫ل ا‬7‫ ﻥ‬6 ‫ا ﻡ‬
‫! دة‬6
double max = myList[0];
int indexOfMax = 0;
if (myList[i] > max) {
max = myList[i];
indexOfMax = i;
}
}
indexOfMax & ‫ ا‬array ‫رت ال‬6‫ \ اﺕ‬2 ‫ اآ‬0 ‫ ت ان‬4‫د ا‬06‫ ا‬X:‫ﻥ‬
‫ و‬myList[3] = 33.5 ‫ض ان‬, ‫?& ﻡ ی‬F‫ ا‬index ‫! ال‬%‫ه‬
.٣ !%‫ ه‬indexOfMax & ‫ ی@ ا‬2 ‫ اآ‬٣٣.٥ T‫ و آﻥ‬myList[7]=33.5
Loops foreach .٦.٢.٧
‫ او‬foreach loop ‫ ﻡوف ﺱ‬for loop ‫ ﻡ ال‬7‫ی‬7‫! ﺝ‬6 ] JDK 1.5 ‫ ال‬
‫ ﻡ‬array ‫ آ! *? ال‬4* ‫ت‬4 ‫ﻡ ﻥ ! ا‬78‫ اﻡ ﻥ‬6 ‫ و دة ﻡ‬enhanced for loop
.index ‫م ال‬78‫ ﻡ ﻥ‬s
‫! ام‬6‫و دة ا‬
for (elementType element: arrayRefVar) {
// Process the element
}
foreach ‫ام‬78‫ ﺱ‬array ‫ آ! *? ال‬tJ‫ ازاي ﻥ‬4LB0‫ل ی‬A‫و دة ﻡ‬
for (double element: myList) {
System.out.println(element);
}
\‫ ا‬t>‫ ا‬myList ?* ‫! *\ ﻡ‬6) ‫! دة‬6 ‫د‬06‫ ﻥ@ى ا‬6 ‫ ت ﻡ‬4‫ل ا‬A ‫ ا‬
.,‫ ﻥ‬array ‫ زي ال‬data type ‫ ال‬D,‫ ﻥ‬7‫زم یﺥ‬F element & ‫دة( ا‬
Arrays Example: Testing .٦.٢.٨
‫اره‬6‫د ﺕ‬7* ‫ و‬2 ‫د اآ‬7L Z‫ و اﻥﻡ‬integer ‫ع‬0‫م ﻡ ا‬78 ‫ ﻡ ا‬2 ٦ 7‫ل ﺥ‬A‫دة ﻡ‬
‫م‬2‫ ار‬٦‫ ال‬
1 import javax.swing.JOptionPane;
2
3 public class TestArray {
4 /** Main method */
5 public static void main(String[] args) {
6 final int TOTAL NUMBERS = 6;
7 int[] numbers = new int[TOTAL NUMBERS];
8
9 // Read all numbers
10 for (int i = 0; i < numbers.length; i++) {
11 String numString = JOptionPane.showInputDialog(
12 "Enter a number:");
13
14 // Convert string into integer
15 numbers[i] = Integer.parseInt(numString);
16 }
17
18 // Find the largest
19 int max = numbers[0];
21 if (max < numbers[i])
22 max = numbers[i];
23 }
24
25 // Find the occurrence of the largest number
26 int count = 0;
28 if (numbers[i] == max) count++;
29 }
30
31 // Prepare the result
32 String output = "The array is ";
34 output += numbers[i] + " ";
35 }
36
37 output += "\nThe largest number is " + max;
38 output += "\nThe occurrence count of the largest number "
39 + "is " + count;
40
41 // Display the result
42 JOptionPane.showMessageDialog(null, output);
43 }
44 }
‫زر هﻡ! ﻡه‬0‫ ا‬4‫ ا‬messages ‫! ال‬6 ‫ن دة‬06‫و ه‬
Grades Example: Assigning .٦.٢.٩

‫أ ادﺥل‬7‫ة ه‬7‫ آ‬7 ‫ب‬:J‫د ا‬7* !‫ﺥ‬7‫زر ه‬0‫ول ا‬F‫ ا‬،‫ب‬:J‫یات ا‬7@‫= ﺕ‬L ‫ل ﺕﻥ‬A‫دة ﻡ‬
4‫زر دﺥ‬0‫ ا‬4‫رﺝت ا‬7‫ درﺝ ﻡ ا‬4*‫ة هف ا‬7‫ آ‬7 Z‫ اﻥﻡ‬١٠٠ ‫! >= ﻡ‬6 ‫رﺝ‬7‫ا‬
0@‫ ه‬4‫ﻡت ا‬04 ‫ = ا‬4* ‫رﺝ دى‬74 ‫ب‬:J‫یات ا‬7@‫= ﺕ‬L‫ة ی‬7‫ آ‬7
A ‫ی‬7@‫ ﺕ‬١٠ – ‫ درﺝ‬4*‫ا‬
B ‫ی‬7@‫ ﺕ‬٢٠ – ‫ درﺝ‬4*‫ا‬
C ‫ی‬7@‫ ﺕ‬٣٠ – ‫ درﺝ‬4*‫ا‬
D ‫ی‬7@‫ ﺕ‬٤٠ – ‫ درﺝ‬4*‫ا‬
F ‫ی‬7@‫ة ﺕ‬7‫! ﻡ آ‬2‫ا‬
‫ی‬7@‫ب و درﺝ آ! >= و ا‬:J‫م ا‬2‫ر‬q ‫م‬78 4 ‫ رﺱ‬g‫ة ه‬7‫ آ‬7
‫د‬06‫و دة ا‬
2
3 public class AssignGrade {
6 // Get number of students
7 String numberOfStudentsString = JOptionPane.showInputDialog(
8 "Please enter number of students:");
9
11 int numberOfStudents =
Integer.parseInt(numberOfStudentsString);
12
13 int[] scores = new int[numberOfStudents]; // Array scores
14 int best = 0; // The best score
15 char grade; // The grade
16
17 // Read scores and find the best score
18 for (int i = 0; i < scores.length; i++) {
19 String scoreString = JOptionPane.showInputDialog(
20 "Please enter a score:");
21
23 scores[i] = Integer.parseInt(scoreString);
24 if (scores[i] > best)
25 best = scores[i];
26 }
27
28 // Declare and initialize output string
29 String output = "";
30
31 // Assign and display grades
32 for (int i = 0; i < scores.length; i++) {
33 if (scores[i] >= best - 10)
34 grade = 'A';
35 else if (scores[i] >= best - 20)
36 grade = 'B';
38 grade = 'C';
40 grade = 'D';
41 else
42 grade = 'F';
43
44 output += "Student " + i + " score is " +
45 scores[i] + " and grade is " + grade + "\n";
46 }
47
48 // Display the result
49 JOptionPane.showMessageDialog(null, output);
50 }
‫زر‬0‫ ا‬t‫و دى ت اﻡ! ﻡ‬
Arrays Copying .٦.٣
‫ی@ دى‬J ( = ) ‫م‬78‫ ﻥ‬6 ‫ ﻡ‬array z‫ض اﻥ *وزی ﻥ‬,
list2 = list1;
list2 ‫ اﺱ‬4‫ ا‬reference ‫ ال‬48 `‫ ه‬array ‫ ال‬z N‫@@ ﻡ‬L‫ی@ دى ا‬J‫ ا‬D
‫ة‬76 ‫ و‬list1 ‫ اﺱ‬4‫ ا‬reference ‫ ال‬4* ‫ ور‬4‫رى ا‬0 ‫ ا‬array ‫ ال‬4* ‫یور‬
‫د‬%‫ ﻡ‬T@ ‫ و‬4* ‫ ور‬reference N,‫ ﻡ‬list2 4* ‫ آن ور‬4‫ ا‬array ‫ی@ ال‬
garbage ‫ه ﻡ ال‬70 E ‫ ﻡ و‬7, N‫رى ﻡ‬0 ‫ ا‬0&‫ﻡ ﻡ‬
array 4* ‫ وروا‬list2 ‫ و‬list1 @‫ ی‬Java Virtual Machine ‫ ال‬collector
list2 ‫ﺝ اﺕ&ت‬L‫ ا‬D,‫` ﻥ‬2:‫ ه‬list1 ‫ﻥ ﺝ‬s 0 ‫ة‬7‫ و > آ‬array ٢ N‫ة ﻡ‬7‫وا‬
j02 4‫م ا‬:6‫[ ا‬B0‫رة دى ه‬0\‫و ا‬
arrays ‫ ال‬z‫ ﻥ‬6 ‫ >ق ﺕﻥ ﻡ‬٣ ‫آ‬F‫و‬

.array ‫ *\ *\ ﻡ *? ال‬z‫وب و ﻥ‬0 ! ‫•ﻥ‬
.array ‫ ال‬z‫ اﻥ ﻥ‬6 arraycopy ‫ اﺱ‬System class ‫دة‬0‫ﺝ‬0‫د ﻡ‬0A‫• ﻡ‬
.٩ ‫ ه‬D arrays ‫ ال‬z clone method ‫م‬78‫ ﻥ‬6 ‫•ﻡ‬
array ‫ ال‬z ‫ب‬04‫م ا‬78‫ ازاي ﻥ‬4‫د دة ه‬06‫ا‬
int[] sourceArray = {2, 3, 1, 5, 10};
int[] targetArray = new int[sourceArray.length];
for (int i = 0; i < sourceArray.length; i++) {
targetArray[i] = sourceArray[i];
}
* arguments ‫ ی ال‬arraycopy method ‫! ال‬6 ‫و دة‬

‫(؛‬arraycopy(sourceArray, srcPos, targetArray, tarPos, length
8‫ *وزی ﻥ‬4‫ ا‬array ‫= اﺱ ال‬6 ‫ ه‬sourceArray
8‫أ ﻥ‬7‫= اول *\ *وزی ﻥ‬6 ‫ ه‬srcPos
‫ة‬7‫ی‬7%‫ ا‬array ‫= اﺱ ال‬6 ‫ وه‬targetArray
‫ة‬7‫ی‬7%‫ ا‬array ‫! ال‬%‫أ ا‬7‫= اول *\ ه‬6 @ ‫ ه‬tarPos
8‫ ه‬4‫د ا? ا‬7* ‫ دة‬length
‫زم ﻥ و‬F ‫ة‬7‫ی‬7%‫ ا‬array ‫ ان ال‬7‫زم ﻥﺥ‬F arrays ‫ ال‬z‫ی@ دى ﻥ‬J‫ﻡ ا‬78‫ اﺱ‬0
.‫د‬0A ‫اﻡ ا‬78‫! اﺱ‬2 % ‫د‬7L‫ﻥ‬
Methods Passing Arrays to .٦.٤

! arrays ‫ ال‬T‫ ﻥ‬6 ‫ دو ﻡ‬methods ! ‫ع‬0‫ ﻡ اي ﻥ‬variables T ‫زي ﻡ آ‬
.integer ‫ع‬0‫ ﻡ ا‬array ?* tJ array ‫ل ل‬A‫ و دة ﻡ‬method
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
‫ ه‬4‫ ا‬array ‫ ان ال‬X:‫ه و ﻥ‬4 * 4‫ ا‬method ‫ هدى ال‬6‫ ه‬4‫ﻡ ا‬F‫و ا‬
. ‫د ﻡة ﺕﻥ‬06‫ﻡ ا‬78‫ ه‬N‫ﻥ ﻡ‬F reference ‫ﻡش‬
printArray(new int[]{3, 1, 2, 6, 4, 2});
Pass by ‫ و دة @ اﺱ‬D @‫ ا‬T method ! ‫ ادی‬variables ‫ ال‬T ‫اﻡ‬
‫ و دة @ اﺱ‬array ‫ ع ال‬,‫ ﻥ‬reference ‫ ال‬T‫ ه‬array 0 ‫ اﻥ‬value
Pass by reference
‫ ت‬4‫م ا‬:6‫[ ا‬B0 ‫ل دة‬A ‫ا‬
public class Test {
public static void main(String[] args) {
int x = 1; // x represents an int value
int[] y = new int[10]; // y represents an array of int values
m(x, y); // Invoke m with arguments x and y

System.out.println("x is " + x);
System.out.println("y[0] is " + y[0]);
}
public static void m(int number, int[] numbers) {

number = 1001; // Assign a new value to number
numbers[0] = 5555; // Assign a new value to numbers[0]
}
}
‫ و اﻥ‬integer ‫ول‬F‫ ا‬arguments ٢ !@ m ‫د اﺱ‬0A‫ ﻡ‬4 * ‫ ت دة‬4‫ل ا‬A ‫ ا‬
@4 ‫ول‬F‫ ا & ا‬2 & ‫وض اﻥ‬, ‫ و ا‬integer ‫ع‬0‫ ﻡ ا‬array ‫ ل‬reference
‫ اﻡ‬return ‫ش‬4‫ و ﻡ‬٥٥٥٥ @4 array ‫ اول *\ ﻡ *? ال‬2 & ‫ و‬١٠٠١
‫ اﻥ‬N‫ول ﻡﺕ&ﺕ‬F‫ ا & ا‬2 ‫ت‬E,‫ ﻡ اﺕ‬7 ‫ ان‬2:‫ ه‬main method ‫ ال‬call 4 ‫ﻥ‬
‫ﻥ‬s 0 ‫ ی‬call-by-reference ‫ اﺕ&ت و دة = اﻥ‬array ‫ول ال‬F‫ ا\ ا‬2
.&‫ ه‬4?F‫ ا‬array ‫د ال‬0A ‫اﺥ! ا‬7 array ‫ﺝ ال‬
‫ﻥ ﻡ& *دى و‬q‫ آ‬j‫د و هﻡ! ﻡ‬0A array ‫ *\ ﻡ *? ال‬T‫ ﻥ‬6 ‫ ﻡ‬: ]0L4‫ﻡ‬
array \* ‫ﻥ‬q‫ آ‬N‫ﻡ‬
‫ ﻡ&ی ﻡ‬7‫و ﺥ‬F‫م ا‬2‫ی! ار‬7‫د ﺕ‬0A‫ ﻡ‬٢ 0‫ ه‬4‫ع آ‬0B0 ‫ة ا‬6 4LB0‫ل ه‬A‫و دة ﻡ‬
‫ اوى‬2 ‫ل‬7 integer ‫ع‬0‫ ﻡ ا‬array 7‫ﻥ ﺥ‬A‫ و ا‬2 ‫ل‬7 integer ‫ع‬0‫ا‬
‫*\ی دو‬
‫د‬06‫ف ا‬0‫و ﻥ‬
1 public class TestPassArray {
4 int[] a = {1, 2};
5
6 // Swap elements using the swap method
7 System.out.println("Before invoking swap");
8 System.out.println("array is {" + a[0] + ", " + a[1] + "}");
9 swap(a[0], a[1]);
10 System.out.println("After invoking swap");
12
13 // Swap elements using the swapFirstTwoInArray method
14 System.out.println("Before invoking swapFirstTwoInArray");
16 swapFirstTwoInArray(a);
17 System.out.println("After invoking swapFirstTwoInArray");
19 }
20
21 /** Swap two variables */
22 public static void swap(int n1, int n2) {
23 int temp = n1;
24 n1 = n2;
25 n2 = temp;
26 }
27
28 /** Swap the first two elements in the array */
29 public static void swapFirstTwoInArray(int[] array) {
30 int temp = array[0];
31 array[0] = array[1];
32 array[1] = temp;
33 }
34 }
output ‫! ال‬6 ‫ن دة‬06‫و ه‬
?‫ ا‬2 ‫د‬0A 4 ‫ آﻥ ﻡ&ات *دی‬array ‫ ان اﻡ اول *\ی ال‬X:‫ﻥ‬
‫ن‬6‫ت ﻡ‬E% ‫د‬0A ‫ن ا‬F ‫ و دة‬N‫ ﻡﺕ&ﺕ‬2 ‫د‬06‫ اﻥ @ ا‬D ‫د‬0A ‫اﺕ&ت ا‬
?8‫رى ا‬0 ‫ اي ﺝ ه& ا‬2 &‫? ی@ اﻡ ه‬8‫ &ات ا‬4 ‫رى‬0 ‫ا‬
‫ﻥ‬s ‫ و‬array ! reference ‫ اﻥ اﻡ ال‬،&‫ ه‬N‫ ﻡ‬4?F‫رى ا‬0 ‫د اﻥ ا‬0A
& ‫د‬0A ‫ی@ دى ا‬J ‫ن‬F 4‫د آ‬06‫ اول *\ی اﺕ&ت ا‬2 ‫ اول *\ی‬2
.array ‫ * ال‬4?F‫رى ا‬0 ‫ا‬
Method Returning an Array from a .٦.٥
array ‫ ــ‬return ! ‫ ازاي ﻥ‬46‫ ه‬20‫ د‬methods ‫ـ‬4 array T‫ ازاي ﻥ‬4* 46‫ا اﺕ‬
method ‫ ال‬
!@ method * ‫د دة *رة‬06‫ ا‬array ‫ ل‬return ! ‫ ازاي ﻥ‬4LB0‫د ه‬0‫دة آ‬
04@‫ ﻡ‬array ‫ ال‬t‫ و ﺕﺝ‬4@‫ و ﺕ‬array
‫ن‬4* ‫د و‬0A ‫ا ا‬0‫ه ﺝ‬4 * 4‫ ا‬array ‫ ع ال‬reference ‫ـ‬4 return 4 * ‫ اﻥ‬X:‫ﻥ‬
‫ع‬0‫ ا‬D,‫ ﻡ ﻥ‬array ‫ ـ‬reference ‫ دة‬return ‫زم اﻥ ﻥ@! ال‬F ‫د دى‬0A ‫م ا‬78‫ﻥ‬
‫! دة‬6
int[] list1 = {1, 2, 3, 4, 5, 6};
int[] list2 = reverse(list1);
Occurrences of Each Example: Counting the .٦.٥.١
Letter
}4* ‫= و‬L ‫ة‬7‫ آ‬7 ‫اﺉ و‬0* ‫ ف‬١٠٠ P ‫ول‬F‫ل ا‬A‫دة ﻡ‬
‫ام‬78‫ *\ ﺱ‬١٠٠ ‫ﻥ ﻡ‬06‫ ﻡ‬array 4%‫ ف و ﻥ‬١٠٠ ‫= ال‬6‫ة اﻥ ه‬0J‫•اول ﺥ‬
‫س‬:6‫دة ا‬0‫ﺝ‬0‫ ﻡ‬4‫)( ا‬getRandomLowerCaseLetter ‫د‬0A ‫ا‬
RandomCharacter
&4‫د وف ا‬7*)\* ٢٦ ‫ﻥ ﻡ‬06‫ ﻡ‬array ‫ دو‬4%‫ار آ! ف و اﺱ‬6‫د ﺕ‬7* =‫•ا‬
( ‫ی‬E4%‫ﻥ‬F‫ا‬
‫ﻡ‬78‫ ه‬4‫ ا‬arrays ‫ ال‬4‫رة دى ه‬0\‫و ا‬
‫د‬06‫و دة ا‬
1 public class CountLettersInArray {
3 public static void main(String args[]) {
4 // Declare and create an array
5 char[] chars = createArray();
6
7 // Display the array
8 System.out.println("The lowercase letters are:");
9 displayArray(chars);
10
11 // Count the occurrences of each letter
12 int[] counts = countLetters(chars);
13
14 // Display counts
15 System.out.println();
16 System.out.println("The occurrences of each letter are:");
17 displayCounts(counts);
18 }
19
20 /** Create an array of characters */
21 public static char[] createArray() {
22 // Declare an array of characters and create it
23 char[] chars = new char[100];
24
25 // Create lowercase letters randomly and assign
26 // them to the array
27 for (int i = 0; i < chars.length; i++)
28 chars[i] = RandomCharacter.getRandomLowerCaseLetter();
29
30 // Return the array
31 return chars;
32 }
33
34 /** Display the array of characters */
35 public static void displayArray(char[] chars) {
36 // Display the characters in the array 20 on each line
37 for (int i = 0; i < chars.length; i++) {
38 if ((i + 1) % 20 == 0)
39 System.out.println(chars[i] + " ");
40 else
41 System.out.print(chars[i] + " ");
42 }
43 }
44
45 /** Count the occurrences of each letter */
46 public static int[] countLetters(char[] chars) {
47 // Declare and create an array of 26 int
48 int[] counts = new int[26];
49
50 // For each lowercase letter in the array, count it
51 for (int i = 0; i < chars.length; i++)
52 counts[chars[i] - 'a']++;
53
54 return counts;
55 }
56
57 /** Display counts */
58 public static void displayCounts(int[] counts) {
59 for (int i = 0; i < counts.length; i++) {
60 if ((i + 1) % 10 == 0)
61 System.out.println(counts[i] + " " + (char)(i + 'a'));
62 else
63 System.out.print(counts[i] + " " + (char)(i + 'a') + " ");
64 }
65 }
Z‫! اﺕ‬6 ‫و دة‬
‫ ﻡ‬a ‫ح ف ال‬J ‫ ف و‬١٠٠ ‫ آ! ف ﻡ ال‬4* ‫ ا‬:‫وف‬L‫ ا‬7* @‫ح >ی‬
c ‫ف آن‬L‫ض ا‬, ‫ی‬7%F‫وف ا‬L‫ف ا‬L‫ ﺕﺕ= ا‬4‫ هﺝ‬7‫ح اآ‬J‫ ا‬Z‫آ! ف و ﻥﺕ‬
‫ و‬c ‫ف‬L‫ار ا‬6‫ ﺕ‬4* ‫ل‬7 4‫ﻥ ه` ا‬F 7‫ا‬0 [counts[2 ‫ود‬E‫ة ﻥ‬76 ‫ و‬c – a = 2 @‫ی‬
‫وف‬L‫! ا‬6 ‫ة‬7‫ ! آ‬
!‫ آ‬4* ‫ی! اﻥ ﻥ‬7‫ﻡش آن ه@ ا‬78‫ ﻡﺱ‬0 ‫ن‬F ‫ آ اوى‬4* ‫ی@ دى وت‬J‫ا‬
‫وف‬L‫ ی ا‬...............c ‫ یوى‬F‫ و‬b ‫ یوى‬F‫ و‬a ‫ یوى‬0‫ف و ﻥ‬
Lists Variable-Length Argument .٦.٦
‫دی ط اﻥ‬7L‫ ﻡ‬N‫ده ﻡ‬7* arguments *0 %‫ ﻡ‬method ‫ ل‬T‫ ﻥ‬6 ‫ ﻡ‬JDK 1.5
‫ام‬78‫ ﺱ‬argumentss ‫ع ال‬0‫ ﻥ‬7 O@‫ ﻥ‬٣ ‫ود‬E ‫ة ﻥ‬7‫ع و ! آ‬0‫ ا‬D,‫ا ﻡ ﻥ‬0‫ﻥ‬06‫ی‬
‫ی@ دى‬J‫ا‬
typeName... parameterName
‫ و ال ﺝ‬Variable-Length Argument ‫ @ اﺱ‬arguments ‫ دى اـ‬L‫ ا‬
OL‫ و ﺕ‬array P ‫ع دة‬0B0 ‫ﻡ ا‬78‫ اﻥ اﺱ‬2: ‫ ` اﻡ‬array ‫ﻡ! ﻡه آﻥ‬
‫* ﻡ&ات *دی‬0 %‫د ﻡ‬0A 4 T‫ ﻥ‬6 ‫ف اﻥ ﻡ‬:‫ اﺥ‬t‫ ﻡ‬4‫ ه‬4‫ ا &ات ا‬2
array 4‫د او ﻥ‬7* ‫ي‬
‫ع‬0B0 ‫ ا‬4LB0‫ل ه‬A‫و دة ﻡ‬
1 public class VarargsDemo {
3 printMax(34, 3, 3, 2, 56.5);
4 printMax(new double[]{1, 2, 3});
5 }
6
7 public static void printMax( double... numbers) {
8 if (numbers.length == 0) {
9 System.out.println("No argument passed");
10 return;
11 }
12
13 double result = numbers[0];
14
15 for (int i = 1; i < numbers.length; i++)
16 if (numbers[i] > result)
17 result = numbers[i];
18
19 System.out.println("The max value is " + result);
20 }
21 }
Arrays Searching .٦.٧
‫ا و‬7‫ری ﺝ‬0‫ی@ ﻡ‬J ‫ء دة ه‬E%‫ ا‬D arrays ‫ ال‬vL4 ‫ا‬7‫ >ق آ ﺝ‬
4‫ﺱ‬
Approach The Linear Search .٦.٧.١
\* !6 ‫ @رﻥ‬F F‫ و‬array ‫دة‬0‫ﺝ‬0‫ *وزی ﻥف ه` ﻡ‬2 ‫ﻥ‬7* ‫ی@ دى *دی‬J‫ا‬
F F‫د و‬0‫ﺝ‬0‫ة ف ه! ا\ ﻡ‬76 ‫ ﻥی و‬7L array ‫ﻡ *? ال‬
‫ *وزی‬4‫ ا@ ا‬2:‫ ه‬4‫ ا‬index ‫ ال‬2‫ ر‬t‫ ﺝ‬linear search ‫د ال‬0A ‫د‬0‫و دة آ‬
١- t‫ ا@ دى هﺝ‬N@4‫ ﻡ‬0 ‫و‬
method main ‫ ! دى و ا@ دى و > ﻡش ال‬%‫ام ا‬78‫د دى ﺱ‬0A ‫ب ا‬%‫ ﻥ‬6 ‫و ﻡ‬
[php/]‫{؛‬٢ ،php]int[] list = {1, 4, 4, 2, 5, -3, 6]
[php]
[center][b]int i = linearSearch(list, 4); // returns 1[/b][/center]
[center][b]int j = linearSearch(list, -4); // returns -1[/b][/center]
[b][/center][/php/]٥ center][b]int k = linearSearch(list, -3); // returns]
4‫م ا‬2‫ر‬F‫د ا‬7* 4* ‫ ﻡ@رﻥ ی‬list.length ‫ ی@رن‬J‫ ه‬4‫ﻡی‬06‫وف ا‬g‫ء ا‬0‫ه اﺱ‬
vL
Approach The Binary Search .٦.٧.٢
‫د ﻡ‬, ‫ﻥ‬F ‫ن ﻡﺕ‬06‫ ا? ﺕ‬2 ‫زم‬F ‫ی@ دى ط ان‬J‫ی@ اﻥ ا‬J‫و دى ا‬
‫ﻥ‬F ‫ی@ دى‬J‫م ا‬78‫ ا? ﻡﺕ ی@ ﻥ‬T‫ آﻥ‬04 ‫د ا @رﻥت‬7* !4@‫اﺕ= دة ﺕ‬
=‫ و هف ا‬T‫ ﺕ‬4‫ی@ ا‬J‫ ﻡ ا‬6 !‫ا‬
‫ ا‬4‫ \ ا‬2:‫ *وزی ﻥ‬4‫ی@ دى @رن ا@ ا‬J‫ ا‬
‫ول‬F‫ء ا‬E%‫ ا‬vL ! 6‫ ا\ ی@ ه‬2 ‫ ا?& ﻡ‬4* ‫ور‬7 4‫د ا‬7‫ @ ا‬0•
4‫ ﺥ‬vL‫ ا ی@ ا‬4‫ آن وى ا\ ا‬0•
‫ﺥ‬F‫ء ا‬E%‫ ا‬vL ! 6‫ ا\ ی@ ه‬2 ‫ اآ ﻡ‬4* ‫ور‬7 4‫د ا‬7‫ @ ا‬0 ‫•اﻥ‬
‫ ﻡة‬log2n ‫ ﻥ@رن‬J‫ت ه‬FL‫ء ا‬0‫ ی@ اﺱ‬n ‫د ا? آن‬7* ‫ض ان‬, ‫ اﻥ‬X:‫ه‬
‫ی@ دى‬J‫ة ا‬02 ‫ و ه` دى‬D ‫ ﻡات‬١٠ ‫ *\ ه@رن‬١٠٢٤ ‫ﻥ‬7* ‫ آن‬0 ‫ی‬
١١ 2‫ ر‬4* ‫ور‬7 ‫م و ا‬2‫* ار‬0 %‫ل ﻡ‬A‫[ ﻡ‬B0 ‫رة دى‬0\‫ا‬
2‫ ا‬0 ‫ ی اﻡ‬2‫ ا‬T@ 4‫ن ا‬6 ‫ ع ا‬index ‫ ال‬t‫د ﺝ‬0A‫ ﻡ‬0‫ ه‬binary search ‫ال‬
4‫ن ا‬6 ‫ – )ا‬,48‫ی@ ﻡ‬J ‫ن‬6 ‫ ا‬OL‫وض ی‬, ‫ ا‬4‫ن ا‬6 ‫ ا‬t‫د ﺝ‬0‫ﺝ‬0‫ ﻡ‬N‫ﻡ‬
@‫ ی‬2:‫ ه‬N‫ ﻡ‬٥ 4* ‫ور‬7 ‫ض اﻥ‬, ‫ ت‬4‫ل ا‬A ‫( ی ا‬١ + OL‫وض ی‬, ‫ا‬
٣- 4‫د ﺕﺝ‬0A ‫وض ا‬, ‫ا‬
‫د‬0A 4 ‫د‬06‫و دة ا‬
1 public class BinarySearch {
2 /** Use binary search to find the key in the list */
3 public static int binarySearch(int[] list, int key) {
4 int low = 0;
5 int high = list.length - 1;
6
7 while (high >= low) {
8 int mid = (low + high) / 2;
9 if (key < list[mid])
10 high = mid - 1;
11 else if (key == list[mid])
12 return mid;
13 else
‫‪14‬‬ ‫;‪low = mid + 1‬‬
‫‪15‬‬ ‫}‬
‫‪16‬‬
‫‪17‬‬ ‫;‪return -low - 1‬‬
‫‪18‬‬ ‫}‬
‫} ‪19‬‬
‫ﻥ‪ X:‬ا‪06‬د ا‪ 4‬ت ان ‪ 0‬ال ‪ low>high‬ﻡ آ‪7‬ة ان ا‪ 2‬ﻡ‪ N‬ﻡ‪0‬ﺝ‪0‬د ‪ t4J‬ﻡ ا ‪0A‬د‬
‫و ﻡ ‪ 6‬ﻥ‪%‬ب ا‪06‬د ا‪ 4‬ت ﺱ‪78‬ام ا‪ ! %‬دى‬
‫][‪int‬‬ ‫‪list = {2, 4, 7, 10,‬‬ ‫‪11, 45,‬‬ ‫‪50, 59,‬‬ ‫;}‪60, 66, 69, 70, 79‬‬
‫‪int i‬‬ ‫‪= binarySearch(list,‬‬ ‫‪2); //‬‬ ‫‪returns‬‬ ‫‪0‬‬
‫‪int j‬‬ ‫‪= binarySearch(list,‬‬ ‫‪11); //‬‬ ‫‪returns‬‬ ‫‪4‬‬
‫‪int k‬‬ ‫‪= binarySearch(list,‬‬ ‫‪12); //‬‬ ‫‪returns‬‬ ‫‪–6‬‬
‫ﻡ‪> : ]0L4‬ی@ ال ‪ linear search‬آ‪0‬ی ان ا‪F‬ر‪2‬م ا‪ 4‬ه‪ vL‬ﻡ‪ N‬آ او ‪0‬‬
‫آﻥ‪ T‬ﻡ‪ N‬ﻡﺕ اﻥ ‪ 0‬ا‪F‬ر‪2‬م ﻡﺕ ی@ ال ‪ binary search‬ا!‬
‫‪Arrays Sorting .٦.٨‬‬
‫اﺕ= زي ا‪78 vL‬ﻡ ﺝت آ و ا‪E%‬ء دة ه@‪0‬ل آ‪o‬ا >ی@ ‪4‬ﺕ=‬
‫‪Sort Selection .٦.٨.١‬‬
‫دى >ی@ ﻡ >ی اﺕ= ا و ‪, ،‬ض اﻥ *وزی ﻥﺕ= ﻡ‪ *0 %‬ار‪2‬م ﺕﺕ= ﺕ\*‪7‬ى‬
‫ال ‪ 4* selection sort‬آ! ا‪7*F‬اد و @! اآ ر‪ 2‬اﺥ ا ‪ *0 %‬و ‪ 7‬آ‪7‬ة ‬
‫*‪ 4‬ا‪7*F‬اد ا‪ 4‬اﺕ@‪ T‬ﻡة ﺕﻥ و ی‪0‬ف اآ ر‪ 2‬ا‪F‬ر‪2‬م ا‪ 4‬اﺕ@‪ T‬و ی@‪ !2 4‬ا‪F‬ﺥ و‬
‫ی ﻡة ﺕ و ی@! ا‪ 2‬ا‪F‬آ ا‪ 4‬اﺕ@‪0‬ا ‪ !2 !2‬ا‪F‬ﺥ و ی ! آ‪7‬ة ‪ 7L‬ﻡ ا‪7*F‬اد آ‪4‬‬
‫ﺕﺕ=‪.‬‬
‫و ا\‪0‬رة ﻡ‪A‬ل ی‪6 [B0‬ة ال ‪selection sort‬‬
‫ اول ﻡة ﻡی *‪ 4‬ا‪7*F‬اد آ‪ @ 4‬ان ر‪ ٩ 2‬ه‪ 0‬ا‪F‬آ * ‪ 4‬ﺕ‪7‬ی! ﻡ و ا‪2‬‬
‫ا‪F‬ﺥ ‪ 7‬آ‪7‬ة ﻡی *‪ 4‬ا‪7*F‬اد آ‪ 4‬ﻡ *‪7‬ا ا‪ 2‬ا‪F‬ﺥ @ ان ‪ ٨‬ه‪ 0‬ا‪F‬آ ﻥ@‪4‬ة ا ‪6‬ن‬
‫‪ !2‬ا‪F‬ﺥ و ه‪o6‬ا ‪ 7L‬ﻡ رﺕ آ! ا‪F‬ر‪2‬م‬
double ‫ع‬0‫ ﻡ ا‬array =‫م دة ﺕ‬:6‫ ا‬E,‫ ی‬4‫د ا‬06‫ف ا‬0‫ ه‬20‫و د‬
1 public class SelectionSort {
2 /** The method for sorting the numbers */
3 public static void selectionSort(double[] list) {
4 for (int i = list.length - 1; i >= 1; i--)
5 // Find the maximum in the list[0..i]
6 double currentMax = list[0];
7 int currentMaxIndex = 0;
8
9 {for (int j = 1; j <= i; j++) {
10 if (currentMax < list[j]) {
11 currentMax = list[j];
12 currentMaxIndex = j;
13 }
14 }
15
16 // Swap list[i] with list[currentMaxIndex] if necessary;
17 if (currentMaxIndex != i) {
18 list[currentMaxIndex] = list[i];
19 list[i] = currentMax;
20 }
21 }
22 }
‫} ‪23‬‬
‫و ﻡ ‪ 6‬ﻥ‪%‬ب ا‪06‬د ا‪ 4‬ت ‪ ! %‬دى‬
‫;)}‪selectionSort(new double[]{2, 1‬‬
‫;)}‪selectionSort(new double[]{2, 3, 1‬‬
‫;)}‪selectionSort(new double[]{1, 2, 1‬‬
‫‪Sort Insertion .٦.٨.٢‬‬
‫و دى >ی@ ﺕﻥ ﺕ= ﻡ‪ *0 %‬ار‪2‬م ا‪J‬ی@ دى ‪6‬ﺕ اﻥ ‪7‬أ ﻡ اول ر‪ 2‬و ﻥ‪ !8‬ان ان‬
‫ ﻡ‪ *0 %‬ار‪2‬م ﻡﺕ )اول ﻡ ‪7‬أﻥ ﻡ‪,‬ش ا‪ F‬اول ر‪ 7 (2‬آ‪7‬ة ﻥﺥ‪ 7‬ا‪ 2‬اﻥ و ﻥ‪0‬ف‬
‫ﻡ‪ 24 B0‬ا‪F‬ول ‪ 0‬ا?& ﻡ ی@ ه‪ 0 7‬اآ ﻡ ی@ ﻡ‪6‬ﻥ ?[ ‪ 7‬آ‪7‬ة‬
‫ﻥ‪0‬ف ا‪ 2‬ا‪ T‬و ﻥ@رﻥ ‪ 2‬ا‪ !2 4‬آ‪7‬ة و ﻥ‪ JL‬ﻡ‪6‬ﻥ ا ‪0g‬ط و ﻥ ! آ‪7‬ة ‪ 7L‬ﻡ‬
‫ﻥ‪ 48‬ا‪F‬ر‪2‬م آ‪ 4‬و دى رﺱ ﺕ‪ [B0‬ا‪:6‬م دة‬
‫زي ﻡ ‪ 02‬ا ‪ !8‬وﺝ‪0‬د ﻡ‪ *0 %‬ار‪2‬م ا‪F‬ول *\ وا‪) 7‬ا‪F‬ول( ‪7‬أ ﺉ‬
‫ﺕ= و آ! ﻡة ﺥ‪ 7‬ر‪ 2‬ﻡ ا ‪ *0 %‬ا‪ 4?F‬ا ‪ *0 %‬ا ﺕ ‪E‬ی‪ \ 7‬و ا ‪ *0 %‬‬
‫ا ﻡ‪ N‬ﻡﺕ @! \ ‪ 7L‬ﻡ ﺕ@ ﻡ‪ *0 %‬ا‪F‬ر‪2‬م ا‪ 4?F‬آ‪ 4‬ﻡﺕ ا‪F‬ﺥ اي *\‬
‫‪ JL‬ا ‪ *0 %‬ا ﺕ ‪F‬زم ﻥ‪7L‬د ﻡ‪6‬ﻥ اﺕ= *‪4‬ن ﻥ‪ 4* XL‬ﺕﺕ= ا ‪ *0 %‬و‬
‫ا\‪0‬رة دى ازاي ﻥ‪E‬ود *\ ا ‪ *0 %‬ا ﺕ ‬
‫و دة ا‪06‬د ا‪ E, 4‬ال ‪insertion sort‬‬

‫{ ‪1 public class InsertionSort‬‬
‫‪2 /** The method for sorting the numbers */‬‬
3 public static void insertionSort(double[] list) {
4 for (int i = 1; i < list.length; i++) {
5 /** insert list[i] into a sorted sublist list[0..i-1] so
that
6 list[0..i] is sorted. */
7 double currentElement = list[i];
8 int k;
9 for (k = i - 1; k >= 0 && list[k] > currentElement; k——) {
10 list[k + 1] = list[k];
11 }
12
13 // Insert the current element into list[k+1]
14 list[k + 1] = currentElement;
15 }
16 }
17 }
‫د‬06‫ب ا‬%‫ن ﻥ‬4* ‫ ! دى‬%‫م ا‬78‫ ﻥ‬6 ‫و ﻡ‬
insertionSort(new double[]{2, 1});
insertionSort(new double[]{2, 3, 1});
insertionSort(new double[]{1, 2, 1});
Class The Arrays .٦.٩
! \\8‫ة ﻡ‬E‫ آ ﺝه‬methods java.util.Arrays ‫ اﺱ‬%‫س & ا‬:‫ آ‬
‫ @رﻥ او ﺝت ﺕﻥ آ‬4 ‫ او‬vL‫ ﺕ او ا‬arrays
‫! دة‬6 ‫ﻡ‬78‫د اﺕ= و ﻥ‬0A ‫ام‬78‫ف اﺱ‬0‫ ﻥ‬6 ‫و ﻡ‬
double[] numbers = {6.0, 4.4, 1.9, 2.9, 3.4, 3.5};
java.util.Arrays.sort(numbers); // Sort the whole array
‫* وف‬0 %‫ن ﻥﺕ= ﻡ‬4* ‫! دة‬6 ‫ﻡ‬78‫او ﻥ‬

char[] chars = {'a', 'A', '4', 'F', 'D', 'P'};
java.util.Arrays.sort(chars, 1, 3); // Sort part of the array
overloading 0 ‫س دة ﻡ‬:6‫ آ ا‬methods : ]0L4‫ﻡ‬

‫ن ال‬06‫زم > ﺕ‬F ‫ة و‬7‫! آ‬2 j ‫ زي ﻡ‬binary search ‫د ال‬0‫ آ‬E, ‫د ﺕﻥ‬0A‫و ﻡ‬
‫ی@ دى‬J ‫ﻡ‬78‫ ﻥ‬6 ‫ى و ﻡ‬7*\‫ ﻡﺕ ﺕ‬array
int[] list = {2, 4, 7, 10, 11, 45, 50, 59, 60, 66, 69, 70, 79};
System.out.println("(1) Index is " +
java.util.Arrays.binarySearch(list, 11));
java.util.Arrays.binarySearch(list, 12));
‫* وف‬0 %‫ * ف ﻡ ﻡ‬vL4 ‫و دى‬

char[] chars = {'a', 'c', 'g', 'x', 'y', 'z'};
java.util.Arrays.binarySearch(chars, 'a'));
java.util.Arrays.binarySearch(chars, 't'));
T‫ ﺕ‬4‫اد ا‬0‫آ‬F‫ ﻡ ا‬Z‫ن اﺕ‬06‫و ه‬
(1) Index is 4
(2) Index is -6
(3) Index is 0
(4) Index is -4
F‫ و‬9 ‫ ووا‬array ٢ ‫ن ﻥف اذا آن‬4* equals ‫د ﺕﻥ اﺱ‬0A‫م ﻡ‬78‫ ﻥ‬6 ‫و ﻡ‬
[B0‫ل ی‬A‫ل ﻡ‬0@‫ ه‬0 ‫یﺕ وى‬0L‫ ان ﻡ‬9 ‫ وى‬arrays ‫ و ال‬F
‫اﻡ‬78‫اﺱ‬
int[] list1 = {2, 4, 7, 10};
int[] list2 = {2, 4, 7, 10};
int[] list3 = {4, 2, 7, 10};
System.out.println(java.util.Arrays.equals(list1, list2)); // true
System.out.println(java.util.Arrays.equals(list2, list3)); // false
‫ن‬F list3 ‫ وى‬N‫ ﻡ‬list1 ‫ اﻥ‬9 ‫یﺕ زي‬0L‫ن ﻡ‬F list2 ‫ وى‬list1 ‫ل دة‬A ‫ ا‬
,48‫یﺕ ﻡ‬0L‫ﻡ‬
‫ ﻡ و دة‬2 ‫ء ﻡ‬E‫ او ﺝ‬array 4 ‫ﻡه ﻥ‬78‫ اﺱ‬0 6 ‫ ﻡ‬fill ‫د ﺕﻥ اﺱ‬0A‫و ﻡ‬
‫اﻡ‬78‫ل ی اﺱ‬A‫ﻡ‬
int[] list1 = {2, 4, 7, 10};
int[] list2 = {2, 4, 7, 10};
java.util.Arrays.fill(list1, 5); // fill 5 to the whole array
java.util.Arrays.fill(list2, 1, 3, 8); // fill 8 to a partial array
Arrays Two-Dimensional .٦.١٠

‫م او‬2‫ر‬F‫ ﻡ ا‬I? !A D array-١ ‫ ادی‬array ‫ﻡ ال‬78‫ة اﺱ‬7‫! آ‬2 4‫ء ا‬E%‫ا ا‬
‫ی‬7@‫ آ * ا‬N,48‫ ﻡ‬arrays ‫ع ﺕﻥ ﻡ ال‬0‫ف ﻥ‬0‫ء دة ه‬E%‫ع ا‬0‫وف او اي ﻥ‬L‫ا‬
‫ل * اﻥ‬0@‫ ﻥ‬6 ‫ او ﻡ‬dimensional array-٢ ‫د‬F‫ ﺙﺉ ا‬array 7‫ی‬7%‫ع ا‬0‫ق ان ا‬,‫ا‬
(‫ة‬7 *‫ف و ا‬0,? ‫ﻥ ﻡ‬06‫ )ﻡ‬0,\ ‫! ا‬6 ‫م‬2‫! ار‬A ‫ ﺕ‬6 ‫ و ه` ﻡ‬array of arrays
Declaring Variables of Two-Dimensional .٦.١٠.١
Creating Two-Dimensional Arrays Arrays and
‫د‬F‫ ﺙﺉ ا‬array 4‫ﻡی‬064 ‫ی@ *ن ﻥف‬J‫و دى ا‬
dataType[][] arrayRefVar;
or
dataType arrayRefVar[][]; // This style is allowed, but not preferred
arrays ‫ ال‬I‫و ا! ی‬F‫ی@ ا‬J‫ام ا‬78‫ة ان اﺱ‬7‫! آ‬2 02 ‫و زي ﻡ‬
integer ‫ع‬0‫ ﻡ ا‬D array-٢ I‫ل ی‬A‫و دة ﻡ‬
int[][] matrix;
or
int matrix[][]; // This style is allowed, but not preferred

‫ی@ دى‬J j4 * 4‫ ا‬reference ‫ـ‬4 ‫رى‬0 ‫ن ا‬6‫ ﻡ‬E%‫ة اﻥ ﺥ‬0J8‫و ا‬
‫د‬7‫ن ا‬4* index ! 2‫م ر‬78‫ ﺱ‬T‫ آ‬array ‫ *? ال‬t‫ن اﺕﻡ! ﻡ‬4* ‫ة آن‬7‫! آ‬2
E‫ یﻡ‬2‫ و ر‬I\4 E‫ یﻡ‬2‫ ر‬2‫م ر‬78‫ ﺱ‬array D-٢ ‫ اﻥ ال‬j‫ هﺕﻡ! ﻡ‬4‫ا\ ا‬
‫م دة‬:6‫[ ا‬B0‫د و اﺱ دى ه‬0‫ﻡ‬4
2‫ و ر‬٢ ‫ اـ‬0‫ و ه‬I\4 E‫ یﻡ‬2‫ﻡ ر‬78‫ اﺱ‬b !6‫ ا‬٧ @‫ ا‬4‫د ا\ ا‬7L‫ن ﻥ‬4*
١ ‫ اـ‬0‫د و ه‬0‫ﻡ‬4 E‫یﻡ‬
0‫ ﺝ` ه‬4‫د ا‬06‫اﺉ ا‬7‫ ا‬2 4JL‫ و ﻥ‬array D-٢ ‫ر ﻥف ال‬7@‫م >ی@ ﻥ‬78‫ ﻥ‬6 ‫و ﻡ‬
(c) T‫ ﺕ‬4‫ اﺱ ا‬4‫ ا‬D array-٢ ‫ﻥء ال‬F ‫د‬0‫آ‬
b !6‫ ا‬4‫د ا‬06‫ ا‬P6‫ ی‬a !6‫ ا‬4‫د ا‬06‫ا‬

Obtaining the Lengths of Two-Dimensional .٦.١٠.٢
Arrays
‫ن‬4* ‫ ﺕﻥ‬array ‫ن ﻡ‬06‫آ آ! *\ ﻡ‬F‫ *دی و‬array @@L‫ ه` ا‬D array-٢ ‫ال‬
* ‫ *رة‬0‫ ه‬array ‫ل ال‬0> arrays array of ‫ اﻥ‬D array-٢ ‫ ال‬4* ‫ل‬0@‫ ﻥ‬6 ‫ة ﻡ‬7‫آ‬
‫دة‬0‫ﺝ‬0‫ ﻡ‬4‫د ا? ا‬7*
‫! دة‬6 D array-٢ * ‫ض اﻥ‬, ‫م دة‬:6‫[ ا‬B0‫ل *ن ﻥ‬A‫ل ﻡ‬0@‫و ه‬
matrix = new int[٣][٤];
‫آ‬F‫ *دی ﺥ و‬D arrays-١ ‫[ ه‬x[2 ،[x[0], x[1 ‫ل ان‬0@‫ ﻥ‬6 ‫ ﻡ‬T‫ ﺕ‬4‫ ا‬4 %‫ﻡ ا‬
‫[ و‬x[0][0], x[0][1], x[0][2], x[0][3 ‫ﻥ ﻡ‬06‫ ﺕﻥ ﻡ‬D array-١ ,‫ ه` ﻥ‬:A‫[ ﻡ‬x[0
@‫ة ی‬76
x.length = 3
٤ = x[0].length = x[1].length = x[2].length
‫ل دة اآ‬A ‫[ ا‬B0‫رة دى ﺕ‬0\‫و ا‬
Ragged Arrays .٦.١٠.٣

‫ة‬7‫ی‬7‫ ﺝ‬0@‫ ه‬4‫ و ا‬D array-١ ,‫ ﻥ‬0‫ ه‬D array-٢ ‫ ال‬I? !‫ ان آ‬02 ‫زي ﻡ‬
‫ف‬0,\‫! ا‬6 N‫ ی ﻡ‬I48‫ل ﻡ‬0> I? !6 @‫ ی‬6 ‫ ﻡ‬D array-٢ ‫ء دة ان ال‬E%‫ا‬
‫ء دة‬E%‫ ا‬4* ‫ل‬A‫ و دة ﻡ‬ragged array ‫ دى ی@ اﺱ‬L‫ و ا‬T‫ل ﺙ‬0>
@‫ ا‬OL‫ة ﻥ‬7‫ آ‬7 ‫ و‬D ‫ن‬6‫ ﻡ‬E%L‫ ﻥ‬6 ‫? دى ﻡ‬4 ‫اﺉ‬7F‫ *ر ا@ ا‬N‫ ﻡ‬0 ‫و‬
‫ی@ دى‬J
int[][] triangleArray = new int[5][];
triangleArray[0] = new int[5];
‫ی@ دى‬J @‫ ا‬I‫و ﻥ‬
triangleArray[0][3] = 50;
triangleArray[4][0] = 45;
‫ه و‬70 4 ‫ة ﺕف ﺝ‬7 *F‫د ا‬7* ‫ و‬D array-٢ ! ‫ف‬0,\‫د ا‬7* ‫ ﻥف‬6 ‫ ﻡ‬: ]0L4‫ﻡ‬
[][new int[5 ‫ام‬78‫ ﺱ‬D ‫ف‬0,\‫د ا‬7* I‫>ی@ ﺕی‬
Arrays Processing Two-Dimensional .٦.١٠.٤
‫ دى‬array ‫ض اﻥ * ال‬,
int[][] matrix = new int[10][10];
D arrays-٢ ‫ ال‬t‫ ﻥﻡ! ﻡ‬6 ‫ ازاي ﻡ‬4LB0‫ دى ﺕ‬array ‫ ال‬4* 4A‫ی اﻡ‬0 ‫ل‬0@‫ه‬
‫د دة‬06‫ام ا‬78‫ ﺱ‬٩٩ ‫ ا‬١ ‫اﺉ ﻡ‬7‫ ا‬2 OL‫ه‬.١
for (int row = 0; row < matrix.length; row++) {
for (int column = 0; column < matrix[row].length; column++) {
matrix[row][column] = (int)(Math.random() * 100);
}
}
‫د دة‬06 ‫ *?ه‬tJ‫ه‬.٢
System.out.print(matrix[row][column] + " ");
}
System.out.println();
}
total ‫ ﻡ& اﺱ‬4%‫ و ﺕ‬array ‫ آ! *? ال‬t ‫ﺝ‬.٣

int total = 0;
total += matrix[row][column];
}
}
‫د دة‬06 (:A‫ ﻡ‬٠ 2‫د ر‬0‫د )اﻡ‬7L‫د ﻡ‬0‫ آ! ا? *ﻡ‬t ‫ﺝ‬.٤
for (int column = 0; column < matrix[0].length; column++) {
int total = 0;
for (int row = 0; row < matrix.length; row++)
total += matrix[row][column];
System.out.println("Sum for column " + column + " is " + total);
}
‫ع ﻡ‬0 %‫د اآ ﻡ‬%‫ و ای‬I? !‫ع آ‬0 %‫ب ﻡ‬.٥
int maxRow = 0;
int indexOfMaxRow = 0;
// Get sum of the first row in maxRow

for (int column = 0; column < matrix[0].length; column++) {
maxRow += matrix[0][column];
}

int totalOfThisRow = 0;
totalOfThisRow += matrix[row][column];
if (totalOfThisRow > maxRow) {
maxRow = totalOfThisRow;
indexOfMaxRow = row;
}
}
}
System.out.println("Row " + indexOfMaxRow

+ " has the maximum sum" + " of " + maxRow);
Test Example: Grading a Multiple-Choice .٦.١٠.٥
‫ب و‬:> ٨ ‫دة( و‬7‫ )اﺥرات ﻡ‬4U‫ اﺱ‬١٠ ‫ﻥ‬7* ‫ل دة‬A ‫ ﻡ ﺝت آ ا‬,‫ل ه‬A‫دة ﻡ‬
4U‫ﺱ‬: LL\‫ﺝ ا‬F‫ﻥ ا‬7* ‫ و‬4U‫ ا‬4* ‫ب‬:J‫! اﺝت ا‬%‫ ﻡ‬D array-٢ ‫ﻥ‬7*
‫ آ! >= ﺝوب‬0@‫ﺥ ی‬F‫ و ا‬LL\‫ﺝ ا‬F => !‫د ی@رن اﺝ آ‬06‫وض ان ا‬, ‫ا‬
[? ‫ال‬G‫آم ﺱ‬
‫ب‬:J‫رة دى ﺕ اﺝت ا‬0\‫ا‬
LL\‫ﺝ ا‬F‫رة دى ﺕ ا‬0\‫و ا‬
Z‫ﻥﻡ‬4 ‫د‬06‫و دة ا‬
1 public class GradeExam {
4 // Students' answers to the questions
5 char[][] answers = {
6 {'A', 'B', 'A', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
7 {'D', 'B', 'A', 'B', 'C', 'A', 'E', 'E', 'A', 'D'},
8 {'E', 'D', 'D', 'A', 'C', 'B', 'E', 'E', 'A', 'D'},
9 {'C', 'B', 'A', 'E', 'D', 'C', 'E', 'E', 'A', 'D'},
10 {'A', 'B', 'D', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
11 {'B', 'B', 'E', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
12 {'B', 'B', 'A', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
13 {'E', 'B', 'E', 'C', 'C', 'D', 'E', 'E', 'A', 'D'}};
14
15 // Key to the questions
16 char[] keys = {'D', 'B', 'D', 'C', 'C', 'D', 'A', 'E', 'A',
'D'};
17
18 // Grade all answers
19 for (int i = 0; i < answers.length ; i++) {
20 // Grade one student
21 int correctCount = 0;
22 for (int j = 0; j < answers[i].length ; j++) {
23 if (answers[i][j] == keys[j])
24 correctCount++;
25 }
26
27 System.out.println("Student " + i + "'s correct count is " +
28 correctCount);
29 }
30 }
31 }
Z‫ ﻡ اﻥﻡ‬Z‫! اﺕ‬6 ‫و دة‬
Taxes Example: Computing .٦.١٠.٦

‫! ﻥ‬6 =‫ب ااﺉ‬L =‫ ﻥ‬٦ arrays ‫ام ال‬78‫ب ااﺉ= ﺱ‬L ‫ل ﺕﻥ‬A‫دة ﻡ‬
=‫= ﻥ ااﺉ‬L ‫د‬,‫ = دﺥ! ا‬4* ‫ ﻡ‬L‫ی‬
=‫ب ااﺉ‬L ‫ة‬7‫ی‬7‫ر ﺝ‬6‫ف ا‬0‫ ﻥ@اة و ﻥ‬6 ‫د دة ﻡ‬06‫ا‬
2
3 public class ComputeTax {
5 // Prompt the user to enter filing status
6 String statusString = JOptionPane.showInputDialog(
7 "Enter the filing status:\n" +
8 "(0-single filer, 1-married jointly,\n" +
9 "2-married separately, 3-head of household)");
10 int status = Integer.parseInt(statusString);
11
12 // Prompt the user to enter taxable income
13 String incomeString = JOptionPane.showInputDialog(
14 "Enter the taxable income:");
15 double income = Double.parseDouble(incomeString);
16
17 // Compute and display the result
18 JOptionPane.showMessageDialog(null, "Tax is " +
19 (int)(computeTax(status, income) * 100) / 100.0);
20 }
21
22 public static double computeTax(int status, double income) {
23 double[] rates = {0.10, 0.15, 0.27, 0.30, 0.35, 0.386};
24
25 int[][] brackets = {
26 {6000, 27950, 67700, 141250, 307050}, // Single filer
27 {12000, 46700, 112850, 171950, 307050}, // Married jointly
28 {6000, 23350, 56425, 85975, 153525}, // Married separately
29 {10000, 37450, 96700, 156600, 307050} // Head of household
30 };
31
32 double tax = 0; // Tax to be computed
33
34 // Compute tax in the first bracket
35 if (income <= brackets[status][0])
36 return tax = income * rates[0]; //Done
37 else
38 tax = brackets[status][0] * rates[0];
39
40 // Compute tax in the 2nd, 3rd, 4th, and 5th brackets, if
needed
41 for (int i = 1; i < brackets[0].length; i++) {
42 if (income > brackets[status][i])
43 tax += (brackets[status][i] - brackets[status][i - 1]) *
44 rates[i];
45 else {
46 tax += (income - brackets[status][i - 1]) * rates[i];
47 return tax; // Done
48 }
49 }
50
51 // Compute tax in the last (i.e., 6th) bracket
52 return tax += (income - brackets[status][4]) * rates[5];
53 }
54 }
Multidimensional Arrays .٦.١١
n- ‫ * ال‬46‫ء دة ه‬E%‫ ا‬array dimensional-٢ ‫ * ال‬46‫ ت اﺕ‬4‫ء ا‬E%‫ ا‬
‫ و‬٣<=n ‫ ق ان‬t‫ ﻡ‬D arrays-٢ ‫ ال‬t‫ اﻡ! ﻡه زي اﻡ! ﻡ‬dimensional arrays
D array-٣ I‫ل ی‬A‫دة ﻡ‬
double[][][] scores = new double[10][5][2];
‫ ﺕﻥ‬array \* !‫ *دی آ‬array * ‫ ه` *رة‬multidimensional array ‫ال‬
Scores Example: Computing Student .٦.١١.١
٥ ‫ب‬:J‫د ﻡ ا‬7* ‫ درﺝت‬multidimensional arrays ‫ ال‬4LB0‫ل دة ه‬A ‫ا‬
‫ل‬7 ‫ول‬F‫ ا‬2‫ ان ا‬vL arrays ‫رﺝ ال‬7‫! ا‬%‫ﺉ ه‬E‫ن ﻡ ﺝ‬06‫ن ﻡ‬L‫ﻥت آ! اﻡ‬L‫اﻡ‬
‫ء‬E%‫ول او ا‬F‫ء ا‬E%‫ ا‬4* ‫ل‬7 T‫ ا‬2‫ن و ا‬L‫ﻡ‬F‫ ا‬2‫ ر‬4* ‫ل‬7 ‫ اﻥ‬2‫= و ا‬J‫*! ا‬
.‫ﻥت‬L‫ﻡ‬F‫ع آ! >= آ! ا‬0 %‫= ﻡ‬L‫ ی‬Z‫اﻥ و اﻥﻡ‬
‫و ه‪06‬ن دة اﺕ‪Z‬‬
‫و ‪76‬ة ﻥ‪06‬ن ﺥ‪Arrays Chapter 6 \4‬‬

‫‪ 0‬ان ء ا
‬
‫*********‬

Introduction To Java Programming CH6

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introduction To Java Programming CH6

Uploaded by

Copyright:

Available Formats

‫ ا

Variables Declaring Array .٦.٢.١

double myList[]; // This style is allowed, but not preferred

Arrays Creating .٦.٢.٢

arrayRefVar = new dataType[arraySize];

‫  ! ﺝ‬T‫ ﺕ‬4‫ ا‬4 %‫ا‬

‫ی@ دى‬J‫ ا‬4LB0‫ل ی‬A‫و دة ﻡ‬

Initializers Array .٦.٢.٥

Arrays Processing .٦.٢.٦

Grades Example: Assigning .٦.٢.٩

arrays ‫ ال‬z ‫  ﻥ‬6 ‫ >ق ﺕﻥ ﻡ‬٣  ‫آ‬F‫و‬

* arguments ‫ ی ال‬arraycopy method ‫! ال‬6 ‫و دة‬

Methods Passing Arrays to .٦.٤

m(x, y); // Invoke m with arguments x and y

public static void m(int number, int[] numbers) {

‫و دة ا‪06‬د ا‪ E, 4‬ال ‪insertion sort‬‬

‫* وف‬0 %‫ن ﻥﺕ= ﻡ‬4* ‫! دة‬6 ‫ﻡ‬78 ‫او ﻥ‬

overloading 0 ‫س دة ﻡ‬:6‫ آ  ا‬methods  : ]0L4‫ﻡ‬

‫* وف‬0 %‫ * ف ﻡ ﻡ‬vL4 ‫و دى‬

Arrays Two-Dimensional .٦.١٠

dataType arrayRefVar[][]; // This style is allowed, but not preferred

int matrix[][]; // This style is allowed, but not preferred

b !6‫  ا‬4‫د ا‬06‫ ا‬P6‫ ی‬a !6‫  ا‬4‫د ا‬06‫ا‬

Ragged Arrays .٦.١٠.٣

total ‫  ﻡ& اﺱ‬4% ‫ و ﺕ‬array ‫ آ! *? ال‬t ‫ﺝ‬.٣

// Get sum of the first row in maxRow

for (int row = 1; row < matrix.length; row++) {

System.out.println("Row " + indexOfMaxRow

LL\‫ﺝ ا‬F‫رة دى ﺕ ا‬0\‫و ا‬

Taxes Example: Computing .٦.١٠.٦

‫و ‪76‬ة ﻥ‪06‬ن ﺥ‪Arrays Chapter 6 \4‬‬

You might also like

‫ ا

‫ ! ﺝ‬T‫ ﺕ‬4‫ ا‬4 %‫ا‬

‫ی@ دى‬J‫ ا‬4LB0‫ل ی‬A‫و دة ﻡ‬

arrays ‫ ال‬z‫ ﻥ‬6 ‫ >ق ﺕﻥ ﻡ‬٣ ‫آ‬F‫و‬

* arguments ‫ ی ال‬arraycopy method ‫! ال‬6 ‫و دة‬

‫و دة ا‪06‬د ا‪ E, 4‬ال ‪insertion sort‬‬

‫* وف‬0 %‫ن ﻥﺕ= ﻡ‬4* ‫! دة‬6 ‫ﻡ‬78‫او ﻥ‬

overloading 0 ‫س دة ﻡ‬:6‫ آ ا‬methods : ]0L4‫ﻡ‬

‫* وف‬0 %‫ * ف ﻡ ﻡ‬vL4 ‫و دى‬

b !6‫ ا‬4‫د ا‬06‫ ا‬P6‫ ی‬a !6‫ ا‬4‫د ا‬06‫ا‬

total ‫ ﻡ& اﺱ‬4%‫ و ﺕ‬array ‫ آ! *? ال‬t ‫ﺝ‬.٣

LL\‫ﺝ ا‬F‫رة دى ﺕ ا‬0\‫و ا‬

‫و ‪76‬ة ﻥ‪06‬ن ﺥ‪Arrays Chapter 6 \4‬‬