2D Arrays (row နဲ့ column ပါတဲ့ ဇယားကွက် array များ)

B2.2.2 - Construct programs that apply arrays and Lists. This page: two-dimensional (2D) arrays.
မြန်မာလို: array (အရွယ်အစား ပုံသေ၊ အမျိုးအစားတူ ဒေတာစု) တွေနဲ့ List (ကြီးလာ၊ သေးသွားနိုင်တဲ့ ဒေတာစု) တွေကို သုံးတဲ့ program တွေကို ကိုယ်တိုင် တည်ဆောက်နိုင်ရပါမယ်။ ဒီစာမျက်နှာမှာတော့ two-dimensional (2D) array (row နဲ့ column ပါတဲ့ ဇယားကွက် array) တွေကို လေ့လာပါမယ်။

---

အဓိက အယူအဆများ

2D array ဆိုတာ array တွေကို စုထားတဲ့ array ပါ၊ row (အလျားလိုက် အတန်း) တွေနဲ့ column (ဒေါင်လိုက် ကော်လံ) တွေ ပါတဲ့ ဇယား တစ်ခုပါ။ Spreadsheet (ဇယားကွက်နဲ့ တွက်ချက်တဲ့ software) တစ်ခု၊ ကစားကွက် တစ်ခု ဒါမှမဟုတ် အမှတ်စာရင်း စာအုပ် တစ်အုပ်ကို စဉ်းစားကြည့်ပါ။ (Python မှာ အဲဒီနဲ့ ညီတာက list of lists (list တွေကို စုထားတဲ့ list) ပါ၊ row နဲ့ column ပုံစံ အတူတူပါပဲ။)

Declaration (ကြေညာခြင်း)

// Declare with size: 3 rows, 4 columns
int[][] grid = new int[3][4];

# Python lists grow dynamically - there is no fixed-size declaration.
# A 3-row x 4-column grid of zeros, one row per line:
grid = [
    [0, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
]

Java code ထဲက comment က row 3 ခု၊ column 4 ခု ရှိတဲ့ array ကို ကြေညာတယ်လို့ ပြောထားပါတယ်။ Python list တွေကတော့ လိုသလို ကြီးလာလို့ အရွယ်အစား ပုံသေနဲ့ ကြေညာတာ မရှိပါဘူး။ Python code က row 3 ခု၊ column 4 ခု ရှိတဲ့ သုည ဇယားကွက်ကို line တစ်ကြောင်းမှာ row တစ်ခုစီ ရေးထားပါတယ်။

Element (အစုထဲက အချက်) အားလုံးရဲ့ default value (သတ်မှတ်မထားရင် သုံးတဲ့ တန်ဖိုး) က int အတွက် 0၊ boolean အတွက် false နဲ့ object (class တစ်ခုကနေ ဖန်တီးထားတဲ့ instance) တွေအတွက် null (ဘာ object ကိုမှ မညွှန်းတဲ့ တန်ဖိုး) ဖြစ်ပါတယ်။

Initialisation (ပထမဆုံး တန်ဖိုး ထည့်ခြင်း): တန်ဖိုးတွေ ကြိုထည့်ပြီး ဖန်တီးခြင်း

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

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

Element တွေကို ယူသုံးခြင်း

// Access: matrix[row][col] - row first, column second
System.out.println(matrix[1][2]);   // 6 (row 1, column 2)
matrix[0][1] = 99;                  // modify an element

# Access: matrix[row][col] - row first, column second
print(matrix[1][2])   # 6 (row 1, column 2)
matrix[0][1] = 99     # modify an element

Comment တွေအရ matrix[row][col] မှာ row ကို အရင် ရေးပြီး column ကို ဒုတိယ ရေးပါတယ်။ matrix[1][2] က row 1၊ column 2 က တန်ဖိုး 6 ဖြစ်ပြီး matrix[0][1] = 99 က element တစ်ခုကို ပြင်လိုက်တာပါ။

အဖြစ်များတဲ့ အမှားက row နဲ့ column ကို နေရာလွဲ ရေးမိတာပါ: matrix[row][col] အစား matrix[col][row] လို့ ရေးမိတာမျိုးပါ။ Row ကို အရင်၊ column ကို ဒုတိယ လို့ အမြဲ မှတ်ထားပါ။

Dimension (အတိုင်းအတာ) များ

int rows = matrix.length;           // number of rows (3)
int cols = matrix[0].length;        // number of columns in row 0 (3)

rows = len(matrix)      # number of rows (3)
cols = len(matrix[0])   # number of columns in row 0 (3)

Comment တွေအရ matrix.length က row အရေအတွက် (3) ဖြစ်ပြီး matrix[0].length က row 0 ထဲက column အရေအတွက် (3) ပါ။

2D array ကို ပုံနဲ့ ကြည့်ခြင်း

ပုံထဲက English စာတွေရဲ့ အဓိပ္ပာယ်: “col 0”၊ “col 1”၊ “col 2” က column 0၊ 1၊ 2၊ “row 0”၊ “row 1”၊ “row 2” က row 0၊ 1၊ 2၊ “matrix[1][2] is 6” က matrix[1][2] က 6 ဖြစ်တယ်၊ “(rows)” က row အရေအတွက်၊ “(columns)” က column အရေအတွက် လို့ ဆိုလိုပါတယ်။ Python ကို ရွေးထားရင် ပုံက matrix.length နဲ့ matrix[0].length အစား len(matrix) နဲ့ len(matrix[0]) ကို ပြပါတယ်။

---

အဆင့်ဆင့် ရှင်းပြထားတဲ့ ဥပမာများ

ဥပမာ 1: ဇယားကွက်ကို print ထုတ်ခြင်း

အခြေခံ ပုံစံပါ: element တိုင်းကို ဝင်ကြည့်ဖို့ loop (ထပ်ခါထပ်ခါ run တဲ့ code အပိုင်း) တစ်ခုထဲမှာ နောက် loop တစ်ခု ထပ်ပါတဲ့ nested loop တွေကို သုံးပါတယ်။

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

// Outer loop: each row
for (int row = 0; row < matrix.length; row++) {
    // Inner loop: each column in this row
    for (int col = 0; col < matrix[row].length; col++) {
        System.out.print(matrix[row][col] + "\t");
    }
    System.out.println();  // new line after each row
}

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Outer loop: each row
for row in range(len(matrix)):
    # Inner loop: each column in this row
    for col in range(len(matrix[row])):
        print(matrix[row][col], end="\t")   # end="\t" adds a tab, stays on the line
    print()   # new line after each row

Output (program က ထုတ်ပြတဲ့ ရလဒ်):

1	2	3
4	5	6
7	8	9

Outer loop (အပြင်ဘက် loop) က row တွေကို တစ်ခုချင်း ဖြတ်သွားပါတယ်။ Row တစ်ခုစီအတွက် inner loop (အတွင်းဘက် loop) က column တွေကို တစ်ခုချင်း ဖြတ်သွားပါတယ်။ \t က တန်ဖိုးတွေကြားမှာ tab (ကွက်လပ် အရှည် တစ်ခု) ထည့်ပေးလို့ တန်ဖိုးတွေ သပ်သပ်ရပ်ရပ် တန်းစီနေပါတယ်။ Python code ထဲက comment အရ end="\t" က tab ထည့်ပေးပြီး line အသစ် မဆင်းဘဲ line တစ်ကြောင်းတည်းမှာ ဆက်နေစေပါတယ်။

---

ဥပမာ 2: Row တစ်ခုရဲ့ ပေါင်းလဒ်

Row တစ်ခုတည်းရဲ့ ပေါင်းလဒ်ကို တွက်ပါ။

int[][] grades = {
    {85, 92, 78},
    {90, 88, 95},
    {70, 65, 80}
};

int targetRow = 1;
int sum = 0;

for (int col = 0; col < grades[targetRow].length; col++) {
    sum = sum + grades[targetRow][col];
}

System.out.println("Row " + targetRow + " sum: " + sum);  // Row 1 sum: 273

grades = [
    [85, 92, 78],
    [90, 88, 95],
    [70, 65, 80]
]

target_row = 1
total = 0   # sum is a built-in function name in Python, so we call it total

for col in range(len(grades[target_row])):
    total = total + grades[target_row][col]

print("Row " + str(target_row) + " sum: " + str(total))  # Row 1 sum: 273

Python မှာ sum က built-in function (Python မှာ အသင့်ပါတဲ့ function) နာမည် ဖြစ်လို့ Python code မှာ total လို့ နာမည်ပေးထားပါတယ်။

သတိပြုပါ: row ကို ပုံသေ ထားပြီး column တွေကိုပဲ ဖြတ်သွားလို့ loop တစ်ခုတည်းပဲ လိုပါတယ်။

---

ဥပမာ 3: 2D Array ထဲမှာ ရှာခြင်း

Target value (ရှာနေတဲ့ တန်ဖိုး) က ဇယားကွက်ထဲ ဘယ်နေရာမှာမဆို ရှိမရှိ ရှာပါ။

int[][] data = {
    {12, 45, 67},
    {89, 23, 56},
    {34, 78, 90}
};

int target = 23;
boolean found = false;

for (int row = 0; row < data.length && !found; row++) {
    for (int col = 0; col < data[row].length && !found; col++) {
        if (data[row][col] == target) {
            found = true;
            System.out.println("Found " + target + " at [" + row + "][" + col + "]");
        }
    }
}

if (!found) {
    System.out.println(target + " not found.");
}

data = [
    [12, 45, 67],
    [89, 23, 56],
    [34, 78, 90]
]

target = 23
found = False

# while loops keep the early-exit check in the loop condition (no break needed)
row = 0
while row < len(data) and found == False:
    col = 0
    while col < len(data[row]) and found == False:
        if data[row][col] == target:
            found = True
            print("Found " + str(target) + " at [" + str(row) + "][" + str(col) + "]")
        col = col + 1
    row = row + 1

if found == False:
    print(str(target) + " not found.")

Output: Found 23 at [1][1] (23 ကို [1][1] မှာ တွေ့တယ်)

&& !found condition (မှန်လား မှားလား စစ်တဲ့ အခြေအနေ) က early exit (စောစော ရပ်ခြင်း) ကို ပေးပါတယ်: တန်ဖိုးကို တွေ့ပြီးရင် ဆက်ရှာစရာ အကြောင်း မရှိတော့ပါဘူး။ Python code ထဲက comment က while loop တွေက early exit စစ်တာကို loop condition ထဲမှာပဲ ထားပေးလို့ break မလိုဘူးလို့ ပြောထားပါတယ်။

---

ဥပမာ 4: Transpose (row နဲ့ column ကို နေရာချင်း လဲခြင်း)

Row တွေနဲ့ column တွေကို နေရာချင်း လဲပြီး array အသစ် တစ်ခုထဲ ထည့်ပါတယ်။

int[][] original = {
    {1, 2, 3},
    {4, 5, 6}
};

// Transpose: rows become columns and columns become rows
int[][] transposed = new int[original[0].length][original.length];

for (int row = 0; row < original.length; row++) {
    for (int col = 0; col < original[row].length; col++) {
        transposed[col][row] = original[row][col];
    }
}

// Print transposed (3 rows, 2 cols)
for (int row = 0; row < transposed.length; row++) {
    for (int col = 0; col < transposed[row].length; col++) {
        System.out.print(transposed[row][col] + "\t");
    }
    System.out.println();
}

original = [
    [1, 2, 3],
    [4, 5, 6]
]

# Transpose: rows become columns and columns become rows.
# Python lists grow dynamically - this pre-built grid of zeros just
# mirrors Java's new int[3][2] so we can write into each slot:
transposed = [
    [0, 0],
    [0, 0],
    [0, 0]
]

for row in range(len(original)):
    for col in range(len(original[row])):
        transposed[col][row] = original[row][col]

# Print transposed (3 rows, 2 cols)
for row in range(len(transposed)):
    for col in range(len(transposed[row])):
        print(transposed[row][col], end="\t")
    print()

Output:

1	4
2	5
3	6

Comment တွေအရ transpose လုပ်ရင် row တွေက column ဖြစ်လာပြီး column တွေက row ဖြစ်လာပါတယ်။ Transpose လုပ်ပြီးသား array မှာ row 3 ခု၊ column 2 ခု ရှိပါတယ်။ Python code ထဲက သုည ဇယားကွက်က Java ရဲ့ new int[3][2] နဲ့ တူအောင် ကြိုလုပ်ထားတာပါ၊ ဒါမှ နေရာ တစ်ခုချင်းထဲ တန်ဖိုး ရေးထည့်လို့ ရမှာပါ။

အဓိက line က transposed[col][row] = original[row][col] ပါ: element တစ်ခုချင်းရဲ့ row index (နေရာအမှတ်) နဲ့ column index ကို နေရာချင်း လဲလိုက်တာပါ။

---

Quick Check (အမြန် စစ်ဆေးမေးခွန်း)

Q1. int[][] matrix = new int[3][4] ဆိုရင် matrix.length က ဘာကို ပြန်ပေးသလဲ။

Q2. int[][] matrix = new int[3][4] ဆိုရင် element ကို ယူသုံးပုံ ဘယ်ဟာက မှန်ကန်သလဲ။

Q3. ဒီ code က ဘာကို print ထုတ်မလဲ။

int[][] m = { {1,2,3}, {4,5,6}, {7,8,9} };
for (int r = 0; r < m.length; r++) {
    for (int c = 0; c < m[r].length; c++) {
        System.out.print(m[r][c] + " ");
    }
    System.out.println();
}

m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for r in range(len(m)):
    for c in range(len(m[r])):
        print(m[r][c], end=" ")
    print()

Q4. 2D array ထဲက element တွေကို ယူသုံးတဲ့အခါ အောက်ပါတို့ထဲက ဘယ်ဟာက အဖြစ်များတဲ့ အမှားလဲ။

Q5. int[][] matrix = new int[5][3] ဆိုရင် matrix[0].length က ဘာလဲ။

---

Trace Exercise (code ကို တစ်ဆင့်ချင်း လိုက်ကြည့်ခြင်း)

3x3 matrix (row 3 ခု၊ column 3 ခု ရှိတဲ့ ကိန်းဇယား) ပေါ်မှာ run တဲ့ ဒီ nested loop ကို trace (တစ်ဆင့်ချင်း လိုက်ပြီး မှတ်) လုပ်ပါ။ အဆင့်တိုင်းမှာ matrix[row][col] ရဲ့ တန်ဖိုးနဲ့ တဖြည်းဖြည်း ပေါင်းသွားတဲ့ sum ကို ဖြည့်ပါ။

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

int sum = 0;
for (int row = 0; row < matrix.length; row++) {
    for (int col = 0; col < matrix[row].length; col++) {
        sum = sum + matrix[row][col];
    }
}
System.out.println("Total: " + sum);

matrix = [
    [2, 4, 6],
    [1, 3, 5],
    [8, 7, 9]
]

total = 0   # sum is a built-in function name in Python, so we call it total
for row in range(len(matrix)):
    for col in range(len(matrix[row])):
        total = total + matrix[row][col]
print("Total:", total)

row	col	matrix[row][col]	sum
0	0
0	1
0	2
1	0
1	1
1	2
2	0
2	1
2	2

နောက်ဆုံး output: Total:

---

Code Completion (code ကွက်လပ် ဖြည့်ခြင်း)

2D array ထဲက သတ်မှတ်ထားတဲ့ column တစ်ခုရဲ့ ပေါင်းလဒ် ကို တွက်တဲ့ code ကို ပြီးအောင် ဖြည့်ပါ။

Row ပေါင်းလဒ်က row ကို ပုံသေထားပြီး column တွေကို loop ပတ်ပါတယ်။ Column ပေါင်းလဒ်ကတော့ အဲဒီလို မဟုတ်ဘဲ column ကို ပုံသေထားပြီး row တစ်ခုချင်းကို loop ပတ်ပါတယ်။ Column ပေါင်းလဒ် တွက်တာ ပြီးအောင် ကွက်လပ်တွေကို ဖြည့်ပါ:

int[][] grades = {
    {85, 92, 78},
    {90, 88, 95},
    {70, 65, 80}
};

int targetCol = 1;
int sum = 0;

for (int row = 0; row < ; row++) {
    sum = sum + ;
}

System.out.println("Column " + targetCol + " sum: " + );

---

Spot the Error (အမှား ရှာခြင်း)

ဒီ code က nested loop တွေကို သုံးပြီး 2D array ထဲက element အားလုံးကို ပေါင်းရမှာပါ။ ဒါပေမယ့် ArrayIndexOutOfBoundsException နဲ့ crash (program ရုတ်တရက် ပျက်ပြီး ရပ်သွားခြင်း) ဖြစ်သွားပါတယ်။ Bug (code ထဲက အမှား) က loop boundary (loop ရဲ့ အစနဲ့ အဆုံး သတ်မှတ်ချက်) မှာ ဖြစ်တဲ့ နာမည်ကြီး off-by-one (တန်ဖိုး တစ် လွဲနေခြင်း) error ပါ။ အမှားပါတဲ့ line ကို ရွေးပါ၊ ပြီးရင် ပြင်နည်းကို ရွေးပါ။

1int[][] matrix = { {1,2}, {3,4}, {5,6} }; 2 3int sum = 0; 4for (int row = 0; row <= matrix.length; row++) { 5 for (int col = 0; col < matrix[row].length; col++) { 6 sum = sum + matrix[row][col]; 7 } 8} 9System.out.println("Sum: " + sum);

မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ:

---

Predict the Output (output ကို ကြိုခန့်မှန်းခြင်း)

ဒီ code က nested loop တွေကို သုံးပြီး 2D array ကို row တစ်ခုချင်း traverse (element တိုင်းကို တစ်ခုချင်း ဖြတ်သွား) လုပ်ပါတယ်။ Element တစ်ခုချင်းကို print ထုတ်ပြီး နောက်မှာ space တစ်ခု ထည့်ပါတယ်၊ row တစ်ခု ပြီးတိုင်း line အသစ် စပါတယ်။ ဒီ code ရဲ့ output အတိအကျ က ဘာလဲ။

int[][] arr = { {10, 20, 30}, {40, 50, 60} };
for (int r = 0; r < arr.length; r++) {
    for (int c = 0; c < arr[r].length; c++) {
        System.out.print(arr[r][c] + " ");
    }
    System.out.println();
}

အဖြေကို program ထုတ်ပေးတဲ့ အတိုင်း English လို ရိုက်ထည့်ပါ (line အသစ်ကို \n နဲ့ ပြပါ):

Output ကို ကြိုခန့်မှန်းရတဲ့ မေးခွန်းတွေမှာ space တွေနဲ့ line အသစ်တွေကို သေချာ ဂရုစိုက်ပါ။ print method (သီးခြား အလုပ်တစ်ခု လုပ်ပေးတဲ့ code အပိုင်း) က line အသစ် မထည့်ပေမယ့် println ကတော့ ထည့်ပါတယ်။

---

Practice Exercises (လေ့ကျင့်ခန်းများ)

Core (အခြေခံ အဆင့်)

1. မြှောက်ဇယား။ table[r][c] = (r+1) * (c+1) ဖြစ်တဲ့ 5x5 int[][] တစ်ခုကို ဖန်တီးတဲ့ code ကို main (program စ run တဲ့ method) ထဲမှာ ရေးပါ။ ရလဒ်ကို သပ်သပ်ရပ်ရပ် ဇယားကွက် ပုံစံနဲ့ print ထုတ်ပါ။

2. အကြီးဆုံးကို ရှာခြင်း။ int[][] data = { {3,7,2}, {9,1,5}, {4,8,6} } ပေးထားပါတယ်။ အကြီးဆုံး တန်ဖိုးနဲ့ သူ့နေရာ [row][col] ကို ရှာပြီး print ထုတ်တဲ့ code ကို ရေးပါ။

3. Row တစ်ခုချင်းရဲ့ ပျမ်းမျှ။ ကျောင်းသားတွေရဲ့ အမှတ်တွေ ပါတဲ့ 2D array တစ်ခု ပေးထားပါတယ် (row တွေက ကျောင်းသားတွေ၊ column တွေက ကျောင်းအလုပ် (assignment) တစ်ခုစီ)။ ကျောင်းသား တစ်ယောက်ချင်းရဲ့ ပျမ်းမျှ အမှတ်ကို တွက်ပြီး print ထုတ်ပါ။

Extension (တိုးချဲ့ အဆင့်)

4. Transpose။ 2x4 array တစ်ခုကို 4x2 array အဖြစ် transpose လုပ်တဲ့ code ကို ရေးပါ။ မူလ array နဲ့ transpose လုပ်ပြီးသား array နှစ်ခုလုံးကို print ထုတ်ပါ။

5. Matrix ပေါင်းခြင်း။ 3x3 array နှစ်ခု a နဲ့ b ပေးထားပါတယ်။ result[r][c] = a[r][c] + b[r][c] ဖြစ်တဲ့ array အသစ် result ကို ဖန်တီးပါ။ Matrix သုံးခုလုံးကို print ထုတ်ပါ။

Challenge (စိန်ခေါ်မှု အဆင့်)

6. Tic-Tac-Toe ကစားကွက်။ Tic-tac-toe (X နဲ့ O ကို တစ်တန်းတည်း သုံးကွက် ရအောင် ကစားတဲ့ 3x3 ကစားကွက် ဂိမ်း) ကစားကွက်ကို ကိုယ်စားပြုတဲ့ char[3][3] array တစ်ခုကို ဖန်တီးပါ။ အောက်ပါတို့ကို လုပ်တဲ့ code ကို ရေးပါ:
   • အကွက် အားလုံးကို '-' နဲ့ initialise လုပ်ပါ
   • 'X' နဲ့ 'O' တန်ဖိုး တချို့ကို နေရာချပါ
   • Column တွေကြားမှာ | ခြားပြီး ကစားကွက်ကို print ထုတ်ပါ
   • ပေးထားတဲ့ row တစ်ခုမှာ အလွတ် မဟုတ်တဲ့ တူညီတဲ့ character (စာလုံး ဒါမှမဟုတ် သင်္ကေတ) သုံးလုံး ပါမပါ စစ်ပါ (ပါရင် နိုင်ပါပြီ)

---

GitHub Classroom (အလိုအလျောက် စစ်ဆေးတဲ့ test တွေပါတဲ့ programming assignment များ)

2D Arrays Practice

Practice nested loops with a grade table: print the grid, calculate row totals, column averages, find the highest grade, and search for a value. Includes a Practice Rooms challenge: build a weekly table from the sign-up sheet for three music practice rooms, then check it against each room's daily limit.

A class assignment on GitHub Classroom: use it when your teacher has set it. It needs a free GitHub account.

Core + Challenge Accept the assignment on GitHub

Working in the Codespace

1. Accept and open. Accept the assignment above, open the link in the email from GitHub, then press Open in Codespace. In Java, change the status bar from Lightweight to Standard mode.
2. Write and check. Open src/TwoDArrays.java and complete each TODO using nested for loops. Press Run and compare the output with the comments, or run bash run-tests.sh in the Terminal.
3. Submit. In Source Control, write a message, press Commit, then Sync Changes. Your teacher’s feedback arrives as a pull request called Feedback.

There is also a challenge file src/PracticeRooms.java - this is optional and harder.

The full Codespace guide, with pictures

---

ဆက်စပ် ခေါင်းစဉ်များ

• အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်များ: 1D Arrays (တန်းတစ်တန်းတည်းမှာ စီထားတဲ့ ဒေတာအစုများ)၊ Iteration (ထပ်ခါထပ်ခါ လုပ်ခြင်း)
• ဆက်စပ် ခေါင်းစဉ်: Linear Search (တစ်ခုချင်း ဆက်တိုက် ရှာနည်း): ရှာတဲ့ ပုံစံတွေကို 2D array မှာလည်း သုံးလို့ ရပါတယ်
• နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: ArrayList (ကြီးလာ၊ သေးသွားနိုင်တဲ့ list)
• ဆက်ပြီး လေ့လာရန်: File I/O (file ကနေ ဒေတာ ဖတ်ခြင်းနဲ့ file ထဲ ရေးခြင်း): CSV (comma နဲ့ ခြားထားတဲ့ စာသား file) ဒေတာကို 2D array ထဲ ဖတ်ထည့်ခြင်း၊ OOP (object တွေကို အခြေခံပြီး program ရေးနည်း): object တွေကို သိမ်းတဲ့ array များ