๐ฆ ์๋ฐ์ ๋ฐฐ์ด(Array)
๐ง ๋ฐฐ์ด์ด๋?
๋ฐฐ์ด(Array)์
๊ฐ์ ์๋ฃํ์ ๊ฐ ์ฌ๋ฌ ๊ฐ๋ฅผ ์ ์ฅํ ์ ์๋ ์ฐ์๋ ๊ณต๊ฐ์ด์์.
๐ฅ ๊ณ๋ํ โ ๊ณ ์ ๋ ์นธ ์, ๊ฐ ์นธ์ 1๊ฐ์ฉ!
๋ง์น ๊ณ๋ํ์ฒ๋ผ ์ ํด์ง ์นธ์ ํ๋์ฉ ๋ฐ์ดํฐ๋ฅผ ๋ด์ ์ ์๋ ๊ตฌ์กฐ๊ฐ ๋ฐ๋ก ๋ฐฐ์ด์ด์์!
๊ทธ๋ฆฌ๊ณ ์ค์ํ ๊ฑด, ์นธ์ ๊ฐ์๋ ์ฒ์ ๋ง๋ค ๋๋ง ์ ํ ์ ์๊ณ , ๋์ค์ ๋ฐ๊ฟ ์ ์์ด์!
๐ข ๋ฐฐ์ด์ ์ ์ฐ๋์?
๐ โโ๏ธ ๋ฐฐ์ด ์์ด ๋ณ์๋ฅผ ์ฐ๋ฉด?
int score1 = 90;
int score2 = 85;
int score3 = 100;
์ ์๊ฐ 100๋ช ์ด๋ผ๋ฉดโฆ ๋ณ์ 100๊ฐ ์ ์ธํด์ผ ํ ๊น์?! ๐ฑ
โ ๋ฐฐ์ด์ ์ฐ๋ฉด!
int[] scores = new int[100];
ํ ์ค๋ก ์ ์ 100๊ฐ ์ ์ฅ ๊ฐ๋ฅ! ๐
โจ ๋ฐฐ์ด ์ ์ธ๊ณผ ์์ฑ
์๋ฃํ[] ๋ฐฐ์ด์ด๋ฆ = new ์๋ฃํ[๊ธธ์ด];
๐ ์์
int[] numbers = new int[5]; // ์ ์ 5๊ฐ ์ ์ฅ ๊ฐ๋ฅํ ๋ฐฐ์ด
์ด๋ ๊ฒ ํ๋ฉด ์ ์ 5๊ฐ๋ฅผ ์ ์ฅํ ์ ์๋ ๋ฐฐ์ด์ด ๋ง๋ค์ด์ ธ์!
โจ ๋ฐฐ์ด ์ ์ธ๊ณผ ์์ฑ์ ๋๋ ์๋ ๊ฐ๋ฅํด์!
int[] numbers; // ๋ฐฐ์ด "์ ์ธ"๋ง ํจ (์์ง ๋ฉ๋ชจ๋ฆฌ๋ ์์)
numbers = new int[5]; // ๋ฐฐ์ด "์์ฑ" (๋ฉ๋ชจ๋ฆฌ์ ๊ณต๊ฐ ํ ๋น)
์ด ๋ฐฉ์์ ๊ฐ์ฒด ์์ฑ๊ณผ๋ ๋น์ทํด์!
๐ ๋ฐฐ์ด ์ด๊ธฐํ ๋ฐฉ๋ฒ
1๏ธโฃ ๊ฐ์ ํ๋์ฉ ๋ฃ๊ธฐ
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
2๏ธโฃ ์ฒ์๋ถํฐ ๊ฐ์ ๋ฃ๊ธฐ
int[] numbers = {10, 20, 30, 40, 50};
๐ฅ ๋ฐฐ์ด์ ๊ฐ ๊บผ๋ด๊ธฐ
System.out.println(numbers[0]); // 10 ์ถ๋ ฅ
๐ง ๋ฐฐ์ด์ ์ธ๋ฑ์ค(index)๋ 0๋ถํฐ ์์ํด์!
numbers[0]์ ์ฒซ ๋ฒ์งธ ๊ฐ,numbers[1]์ ๋ ๋ฒ์งธ ๊ฐ์ ๋๋ค.
๐ ๋ฐฐ์ด๊ณผ ๋ฐ๋ณต๋ฌธ์ ์ฐฐ๋ก๊ถํฉ
for๋ฌธ์ ์ฌ์ฉํด ๋ฐฐ์ด ์ ์ฒด ์ถ๋ ฅํ๊ธฐ
for (int i = 0; i < numbers.length; i++) {
System.out.println("๊ฐ: " + numbers[i]);
}
ํฅ์๋ for๋ฌธ (Enhanced for)
for (int n : numbers) {
System.out.println("๊ฐ: " + n);
}
โ ๏ธ ๋ฐฐ์ด ์ฌ์ฉ ์ ์ฃผ์ํ ์
| ์ฃผ์ํ ์ | ์ค๋ช |
|---|---|
| ์ธ๋ฑ์ค ๋ฒ์ ์ด๊ณผ | ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํด์! ์๋ฅผ ๋ค์ด, int[5] ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ 0 ~ 4๊น์ง! ๐
numbers[5]์ฒ๋ผ ์๋ชป ์ ๊ทผํ๋ฉด: "ArrayIndexOutOfBoundsException" ์์ธ ๋ฐ์ |
| ๋ฐฐ์ด ๊ธธ์ด๋ ๊ณ ์ | ํ ๋ฒ ๋ง๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋ฐ๊ฟ ์ ์์ด์! ๋ง์ฝ ๋ ๋ง์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ์ถ๋ค๋ฉด? โ ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋ค๊ณ , ๋ณต์ฌํด์ผ ํด์ |
| ํ์ ๋ถ์ผ์น ์ ์ฅ | ๋ฐฐ์ด์ ์ ์ธ๋ ํ์
๊ณผ ๋ค๋ฅธ ํ์
์ ๊ฐ์ ์ ์ฅํ๋ ค๊ณ ํ๋ฉด ๋ฐํ์ ์๋ฌ ๋ฐ์ (ArrayStoreException) |
โ ์๋ชป๋ ์์: ์ธ๋ฑ์ค ์ด๊ณผ
int[] numbers = new int[3]; // ํฌ๊ธฐ 3
numbers[3] = 10; // โ ์ค๋ฅ! ์ธ๋ฑ์ค๋ 0~2๊น์ง๋ง ์์
๐ฅ ๊ฒฐ๊ณผ
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
๐ซ ์ปดํ์ผ ์๋ฌ๊ฐ ๋๋ ๊ฒฝ์ฐ
String[] arr = new String[3];
arr[0] = 123; // โ ์ปดํ์ผ ์๋ฌ
Stringํ์ ๋ฐฐ์ด์int(= 123)์ ๋ฃ์ผ๋ ค ํ์ฃ .- ์ด๊ฑด ๋ช ๋ฐฑํ ํ์ ๋ถ์ผ์น๋๊น ์ปดํ์ผ ํ์์ ๋ฐ๋ก ์๋ฌ๊ฐ ๋ฉ๋๋ค.
- ๐ฅ "Incompatible types" ๋ผ๋ ์๋ฌ ๋ฉ์์ง๋ฅผ ๋ณด๊ฒ ๋ผ์.
โ๏ธ ๋ฐํ์ ์๋ฌ๊ฐ ๋๋ ๊ฒฝ์ฐ (ArrayStoreException)
Object[] arr = new String[3]; // String ๋ฐฐ์ด์ Object ๋ฐฐ์ด์ฒ๋ผ ์ ์ธ
arr[0] = "yoooCo"; // โ
์ ์
arr[1] = 100; // โ ๋ฐํ์ ์๋ฌ (ArrayStoreException)
- ์ฌ๊ธฐ์ ์ปดํ์ผ๋ฌ๋
Object[]๋ผ๊ณ ๋ณด๋๊น,
"๋ฌธ์์ด"๋ ์ ์๋ ๋ฃ์ ์ ์๊ฒ ๋ค?๋ผ๊ณ ์๊ฐํด์. - ํ์ง๋ง ์ค์ ๋ก๋
String[]์ด๊ธฐ ๋๋ฌธ์,
100 ๊ฐ์ ๋ค๋ฅธ ํ์ ์ด ๋ค์ด๊ฐ๋ฉด ๋ฐํ์์ ๋นต! ํฐ์ง๋๋ค. ๐ฃ
๐จ๏ธ ๋ฐฐ์ด ๋ณต์ฌํ๊ธฐ!
๐ก ๋ฐฐ์ด์ "๊ทธ๋ฆ"์ฒ๋ผ ํ ๋ฒ ํฌ๊ธฐ๋ฅผ ์ ํ๋ฉด ๋ฐ๊ฟ ์ ์์ด์!
๋ ๋ด๊ณ ์ถ๋ค๋ฉด, ํฐ ๊ทธ๋ฆ์ผ๋ก ์ฎ๊ฒจ์ผ ํ๋ ์ ์ด์ฃ !
โ
1. for๋ฌธ ๋ณต์ฌ (๊ธฐ๋ณธ ๋ฐฉ์)
int[] oldArray = {1, 2, 3};
int[] newArray = new int[5];
// ๋ณต์ฌ
for (int i = 0; i < oldArray.length; i++) {
newArray[i] = oldArray[i];
}
๐ก ์๋์ด๋ผ์ ์ ์ฐํ์ง๋ง ์ฝ๋๊ฐ ๊ธธ์ด์ ธ์.
โ
2. System.arraycopy() ์ฌ์ฉ
int[] oldArr = {1, 2, 3};
int[] newArr = new int[5];
System.arraycopy(oldArr, 0, newArr, 0, oldArr.length);
//System.arraycopy(์๋ณธ ๋ฐฐ์ด, ๋ณต์ฌ ์์ ์ธ๋ฑ์ค, ๋ณต์ฌํ ๋ฐฐ์ด, ๋ณต์ฌ ์์ ์ธ๋ฑ์ค, ๋ณต์ฌํ ๊ฐ์);
๐ ํท๊ฐ๋ฆด ๊ฒ ๊ฐ์์ ์์ ๋ฅผ ํ๋ ๋ ๊ฐ์ ธ์์ด์!
import java.util.Arrays;
public class SystemArrayCopy {
public static void main(String[] args) {
int[] oldArr = {1, 2, 3};
int[] newArr = new int[6]; // ์ ๋ฐฐ์ด์ ๊ธธ์ด๋ ๋ ํฌ๊ฒ
// newArr์ ์ธ๋ฑ์ค 2๋ถํฐ ๋ณต์ฌ
System.arraycopy(oldArr, 0, newArr, 2, oldArr.length);//์๋ณธ, ์ธ๋ฑ์ค, ์๋ฐฐ์ด, ์ธ๋ฑ์ค, ๋ณต์ฌ์์ ๊ฐ์
// ์ถ๋ ฅ
System.out.println("์๋ณธ ๋ฐฐ์ด: " + Arrays.toString(oldArr));
System.out.println("๋ณต์ฌ๋ ๋ฐฐ์ด: " + Arrays.toString(newArr));
}
}
๐ฅ ์ถ๋ ฅ
์๋ณธ ๋ฐฐ์ด: [1, 2, 3]
๋ณต์ฌ๋ ๋ฐฐ์ด: [0, 0, 1, 2, 3, 0]
๐ก ๋น ๋ฅด๊ณ ํจ์จ์ ์ด์์. ๋ถ๋ถ ๋ณต์ฌ๋ ๊ฐ๋ฅ!
๐ ๋ค์ํ๋ฒ ํ๋ก ์ ๋ฆฌํ์ด์!
| ๋งค๊ฐ๋ณ์ | ์๋ฏธ |
|---|---|
| oldArr | ์๋ณธ ๋ฐฐ์ด |
| 0 | ๋ณต์ฌ ์์ ์ธ๋ฑ์ค (์๋ณธ) |
| newArr | ๋ณต์ฌ ๋์ ๋ฐฐ์ด |
| 0 | ๋ณต์ฌ ์์ ์ธ๋ฑ์ค (๋์) |
| oldArr.length | ๋ณต์ฌํ ์์ ์ |
โ
3. Arrays.copyOf() ์ฌ์ฉ
import java.util.Arrays;
int[] oldArr = {1, 2, 3};
int[] newArr = Arrays.copyOf(oldArr, 5);
๐ก ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์ํ๋ ๋งํผ ์ง์ ํ ์ ์์ด์! ๋จ์ ๋ถ๋ถ์ ๊ธฐ๋ณธ๊ฐ(0) ์ผ๋ก ์ฑ์์ง
๐คท ์ธ์ ๋ญ ์จ์ผ ํ ๊น?
| ์ํฉ | ์ถ์ฒ ๋ฐฉ๋ฒ |
|---|---|
| ๋น ๋ฅด๊ณ ๋ถ๋ถ ๋ณต์ฌ๊ฐ ํ์ํ ๋ | System.arraycopy() |
| ์ ์ฒด ๋ณต์ฌํ๊ณ ๋ฐฐ์ด ํฌ๊ธฐ๊น์ง ์กฐ์ ํ๊ณ ์ถ์ ๋ | Arrays.copyOf() |
| ์ง์ ๋ก์ง์ ์ ์ดํ๊ณ ์ถ์ ๋ | for๋ฌธ |
โ ๋ง๋ฌด๋ฆฌ ์ ๋ฆฌ
| ํญ๋ชฉ | ์ค๋ช |
|---|---|
| ์ ์ธ ๋ฐฉ๋ฒ | ์๋ฃํ[] ๋ฐฐ์ด์ด๋ฆ = new ์๋ฃํ[ํฌ๊ธฐ]; |
| ์ด๊ธฐํ ๋ฐฉ๋ฒ | {10, 20, 30} ๋๋ ํ๋์ฉ ๋ฃ๊ธฐ |
| ์ธ๋ฑ์ค ์์ | 0๋ถํฐ ์์ |
| ๋ฐ๋ณต ์ถ๋ ฅ ๋ฐฉ๋ฒ | for๋ฌธ / ํฅ์๋ for๋ฌธ |
| ์ฃผ์์ฌํญ | ์ธ๋ฑ์ค ๋ฒ์, ํฌ๊ธฐ ๊ณ ์ |
๋์ผ๋ก... ๐
๋ฐฐ์ด์ โ๊ฐ์ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ๊ฐ ์ ์ฅํ๋ ์์โ์ ๋๋ค!
์ซ์, ๋ฌธ์, ๊ฐ์ฒด ๋ฑ ์ด๋ค ์๋ฃ๋ ํ ๋ฒ์ ๋ค๋ฃฐ ์ ์์ด์.
ํ๋ก๊ทธ๋๋ฐ ์ ๋ฌธ์๋ผ๋ฉด ๋ฐ๋์ ์ตํ์ผ ํ ๊ฐ๋ ์ด์์! ๐ก
'Programming > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| ๋ฌธ์์ด String Class (0) | 2025.04.29 |
|---|---|
| Java์ ๋ฐ๋ณต๋ฌธ๊ณผ ํ๋ฆ ์ ์ด ํค์๋! (0) | 2025.04.23 |
| ์ ๊ทผ ์ ์ด์ (0) | 2025.04.17 |
| ์๋ฐ ์ค์ฒฉ ํด๋์ค๋? (0) | 2025.04.14 |
| ์ํผํด๋์ค & ์๋ธํด๋์ค (์์) (0) | 2025.04.13 |