๋ค์ฐจ์ ๋ฐฐ์ด(Multi-Dimensional Arrays)์ ๋ฐ์ดํฐ์ ํ(row)๊ณผ ์ด(column) ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํด ๋ณต์กํ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ ์ฅํ๊ณ ๊ด๋ฆฌํ ์ ์๋ ์๋ฃ ๊ตฌ์กฐ์ ๋๋ค. Java์์๋ 2์ฐจ์ ๋ฐฐ์ด์ด ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ๋๋ฉฐ, ๊ทธ ์ธ์๋ 3์ฐจ์ ์ด์์ ๋ฐฐ์ด์ ๊ตฌํํ ์ ์์ต๋๋ค. ์ด๋ฒ ๊ธ์์๋ Java ๋ค์ฐจ์ ๋ฐฐ์ด์ ๊ธฐ๋ณธ ๊ฐ๋ , ์ ์ธ๊ณผ ์ด๊ธฐํ ๋ฐฉ๋ฒ, ๊ทธ๋ฆฌ๊ณ ์ค์ํ ํ์ฉ ์์ ๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
1. ๋ค์ฐจ์ ๋ฐฐ์ด์ด๋?
๋ค์ฐจ์ ๋ฐฐ์ด์ ๋ฐฐ์ด ์์ ๋ ๋ค๋ฅธ ๋ฐฐ์ด์ด ์๋ ๊ตฌ์กฐ์ ๋๋ค. ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํํ๋ 2์ฐจ์ ๋ฐฐ์ด๋ก, ํ๊ณผ ์ด๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํฉ๋๋ค. ์๋ฅผ ๋ค์ด, 2์ฐจ์ ๋ฐฐ์ด์ ํ ํํ์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ ๋ ์ ์ฉํ๋ฉฐ, 3์ฐจ์ ์ด์์ ๋ฐฐ์ด์ ๋ ๋ณต์กํ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ํํํ ์ ์์ต๋๋ค.
2. ๋ค์ฐจ์ ๋ฐฐ์ด ์ ์ธ ๋ฐ ์ด๊ธฐํ
2.1 2์ฐจ์ ๋ฐฐ์ด ์ ์ธ
Java์์ 2์ฐจ์ ๋ฐฐ์ด์ ์ ์ธํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
int[][] matrix; // 2์ฐจ์ ์ ์ ๋ฐฐ์ด ์ ์ธ
String[][] names; // 2์ฐจ์ ๋ฌธ์์ด ๋ฐฐ์ด ์ ์ธ
2.2 2์ฐจ์ ๋ฐฐ์ด ์์ฑ
๋ฐฐ์ด ์์ฑ ์ ํ(row)๊ณผ ์ด(column)์ ํฌ๊ธฐ๋ฅผ ์ง์ ํด์ผ ํฉ๋๋ค.
matrix = new int[3][4]; // 3ํ 4์ด์ ์ ์ํ ๋ฐฐ์ด ์์ฑ
names = new String[2][3]; // 2ํ 3์ด์ ๋ฌธ์์ด ๋ฐฐ์ด ์์ฑ
2.3 ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ
2์ฐจ์ ๋ฐฐ์ด์ ์ ์ธ๊ณผ ๋์์ ๊ฐ์ ์ด๊ธฐํํ ์ ์์ต๋๋ค.
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
String[][] names = {
{"Alice", "Bob", "Charlie"},
{"David", "Eve", "Frank"}
};
3. 2์ฐจ์ ๋ฐฐ์ด ์์ ์ ๊ทผ
๋ฐฐ์ด์ ๊ฐ ์์๋ ํ๊ณผ ์ด์ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ฌ ์ ๊ทผํ ์ ์์ต๋๋ค. ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํฉ๋๋ค.
์์ : 2์ฐจ์ ๋ฐฐ์ด ์์ ์ถ๋ ฅ
public class ArrayAccess {
public static void main(String[] args) {
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
System.out.println("์ฒซ ๋ฒ์งธ ํ, ์ฒซ ๋ฒ์งธ ์ด์ ๊ฐ: " + matrix[0][0]); // 1
System.out.println("๋ ๋ฒ์งธ ํ, ์ธ ๋ฒ์งธ ์ด์ ๊ฐ: " + matrix[1][2]); // 6
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
์ฒซ ๋ฒ์งธ ํ, ์ฒซ ๋ฒ์งธ ์ด์ ๊ฐ: 1
๋ ๋ฒ์งธ ํ, ์ธ ๋ฒ์งธ ์ด์ ๊ฐ: 6
4. 2์ฐจ์ ๋ฐฐ์ด ์ํ
2์ฐจ์ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ถ๋ ฅํ๋ ค๋ฉด ์ค์ฒฉ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํฉ๋๋ค.
์์ : 2์ฐจ์ ๋ฐฐ์ด ์ํ
public class ArrayIteration {
public static void main(String[] args) {
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
1 2 3
4 5 6
7 8 9
5. ์ค์ํ ํ์ฉ ์์
5.1 ๊ฒ์์ ๋ณด๋ํ
2์ฐจ์ ๋ฐฐ์ด์ ์ฒด์คํ์ด๋ ํผ์ฆ ๊ฒ์๊ณผ ๊ฐ์ ๋ณด๋ํ์ ๊ตฌํํ๋ ๋ฐ ์ ์ฉํฉ๋๋ค.
public class GameBoard {
public static void main(String[] args) {
char[][] board = {
{'X', 'O', 'X'},
{'O', 'X', 'O'},
{'X', 'O', 'X'}
};
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[i].length; j++) {
System.out.print(board[i][j] + " ");
}
System.out.println();
}
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
X O X
O X O
X O X
5.2 ํ์ ์ฑ์ ๊ด๋ฆฌ
๊ฐ ํ์์ ๊ณผ๋ชฉ๋ณ ์ ์๋ฅผ ์ ์ฅํ๊ณ ํ๊ท ์ ๊ณ์ฐํ ์ ์์ต๋๋ค.
public class StudentScores {
public static void main(String[] args) {
int[][] scores = {
{85, 90, 80}, // ํ์ 1์ ์ ์
{78, 88, 92}, // ํ์ 2์ ์ ์
{95, 91, 89} // ํ์ 3์ ์ ์
};
for (int i = 0; i < scores.length; i++) {
int sum = 0;
for (int j = 0; j < scores[i].length; j++) {
sum += scores[i][j];
}
double average = (double) sum / scores[i].length;
System.out.println("ํ์ " + (i + 1) + "์ ํ๊ท ์ ์: " + average);
}
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
ํ์ 1์ ํ๊ท ์ ์: 85.0
ํ์ 2์ ํ๊ท ์ ์: 86.0
ํ์ 3์ ํ๊ท ์ ์: 91.66666666666667
5.3 ์ด๋ฏธ์ง ๋ฐ์ดํฐ ์ ์ฅ
์ด๋ฏธ์ง์ ํฝ์ ๋ฐ์ดํฐ๋ ๋ณดํต 2์ฐจ์ ๋ฐฐ์ด๋ก ์ ์ฅ๋ฉ๋๋ค. ๊ฐ ํฝ์ ์ ๋ฐ๊ธฐ ๊ฐ์ 2์ฐจ์ ๋ฐฐ์ด๋ก ํํํ ์ ์์ต๋๋ค.
public class ImageData {
public static void main(String[] args) {
int[][] pixels = {
{255, 128, 64},
{128, 64, 32},
{64, 32, 16}
};
for (int i = 0; i < pixels.length; i++) {
for (int j = 0; j < pixels[i].length; j++) {
System.out.print(pixels[i][j] + " ");
}
System.out.println();
}
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
255 128 64
128 64 32
64 32 16
6. ๋ค์ฐจ์ ๋ฐฐ์ด ์ฌ์ฉ ์ ์ฃผ์์ฌํญ
- ์ธ๋ฑ์ค ๋ฒ์: ์ธ๋ฑ์ค๊ฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ด๊ณผํ๋ฉด
ArrayIndexOutOfBoundsException
์ด ๋ฐ์ํฉ๋๋ค. - ๊ฐ๋ณ ๊ธธ์ด ๋ฐฐ์ด: Java์์๋ ํ๋ง๋ค ์ด์ ํฌ๊ธฐ๊ฐ ๋ค๋ฅธ ๊ฐ๋ณ ๊ธธ์ด ๋ฐฐ์ด์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
๊ฒฐ๋ก
Java์ ๋ค์ฐจ์ ๋ฐฐ์ด์ ๋ณต์กํ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์๋ ๊ฐ๋ ฅํ ๋๊ตฌ์ ๋๋ค. ๊ฒ์ ๋ณด๋, ํ์ ์ฑ์ ๊ด๋ฆฌ, ์ด๋ฏธ์ง ๋ฐ์ดํฐ ์ฒ๋ฆฌ ๋ฑ ๋ค์ํ ์ค์ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ์ ์ฉํฉ๋๋ค. ์ด๋ฒ ๊ธ์์ ์๊ฐํ ๊ฐ๋ ๊ณผ ์์ ๋ฅผ ๋ฐํ์ผ๋ก ๋ค์ฐจ์ ๋ฐฐ์ด์ ์ ๊ทน ํ์ฉํด ๋ณด์ธ์!
๋๊ธ ์ฐ๊ธฐ