1차원 · 2차원 배열

int[] scores;              // 1. 선언: "int 배열을 가리킬 변수 scores"  (아직 배열 없음, null)
scores = new int[5];       // 2. 생성: 힙에 int 5칸 배열을 만들고 주소를 scores에
scores[0] = 90;            // 3. 사용: 0번 칸에 90 저장

int[] scores = new int[5];              // 크기 지정, 모든 칸 기본값 0
int[] scores = {90, 85, 77, 92, 68};    // 값 나열 (선언과 동시에만 가능)
int[] scores = new int[]{90, 85, 77};   // 값 나열 (나중에 대입하거나 인자로 넘길 때)

int[] arr = new int[5];
arr.length      // 5  (필드. 메서드 아님. 괄호 없음!)
arr[4]          // 마지막 요소
arr[5]          // ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
arr[-1]         // ArrayIndexOutOfBoundsException

int[] a = {10, 20, 30};

스택                     힙
┌──────────┐            ┌────────────────────────────┐
│ a │ 0x100│──────────► │ length=3 │ 10 │ 20 │ 30    │  ← 0x100
└──────────┘            └────────────────────────────┘
                          (int 4바이트씩 연속 배치)

String[] names = {"Kim", "Lee"};

스택              힙
┌────────┐       ┌─────────────────┐        ┌───────┐
│ names  │─────► │ 0x200 │ 0x300   │───────►│ "Kim" │ 0x200
└────────┘       └─────────────────┘   └───►│ "Lee" │ 0x300
                  (주소들의 배열)            └───────┘

int[] arr = {5, 3, 8, 1};

// 1. 인덱스 순회: 인덱스가 필요하거나 값을 바꿀 때
for (int i = 0; i < arr.length; i++) {
    arr[i] *= 2;
}

// 2. 향상된 for: 읽기만 할 때
int sum = 0;
for (int v : arr) {
    sum += v;
}

// 3. 역순
for (int i = arr.length - 1; i >= 0; i--) { ... }

// 4. 최댓값 찾기: 첫 요소로 초기화
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) max = arr[i];
}

int[][] grid = new int[3][4];      // 3행 4열
grid[1][2] = 7;                    // 1행 2열
grid.length                        // 3 (행 수)
grid[0].length                     // 4 (0행의 열 수)

grid ──► ┌───────┐
         │ 0x10  │──► [0, 0, 0, 0]
         │ 0x20  │──► [0, 0, 7, 0]     ← grid[1]
         │ 0x30  │──► [0, 0, 0, 0]
         └───────┘

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

int[][] triangle = new int[3][];    // 행만 만들고 열은 나중에
triangle[0] = new int[1];
triangle[1] = new int[2];
triangle[2] = new int[3];
// 또는
int[][] jagged = {{1}, {2, 3}, {4, 5, 6}};

for (int i = 0; i < grid.length; i++) {
    for (int j = 0; j < grid[i].length; j++) {     // 행마다 길이 확인
        ...
    }
}
// 향상된 for 중첩
for (int[] row : grid) {
    for (int cell : row) { ... }
}

int[] original = {1, 2, 3};
int[] alias = original;          // 복사 아님! 같은 배열을 가리키는 두 번째 이름
alias[0] = 99;
System.out.println(original[0]); // 99

int[][] src = {{1, 2}, {3, 4}};
int[][] shallow = src.clone();       // 바깥 배열만 새로 만듦
shallow[0][0] = 99;
System.out.println(src[0][0]);       // 99 !! 안쪽 배열 {1,2}는 공유됨
shallow[0] = new int[]{7, 8};        // 바깥 배열의 칸을 바꾸는 건 독립적
System.out.println(src[0][0]);       // 여전히 99 (src[0]는 원래 안쪽 배열)

src ─────► [ 0xA, 0xB ]         0xA ──► [99, 2]
shallow ─► [ 0xA, 0xB ] (새 배열)      0xB ──► [3, 4]
           두 바깥 배열이 같은 안쪽 배열을 가리킴

int[][] deep = new int[src.length][];
for (int i = 0; i < src.length; i++) {
    deep[i] = src[i].clone();        // 각 행을 따로 복사
}

static void doubleAll(int[] arr) {
    for (int i = 0; i < arr.length; i++) arr[i] *= 2;
}
int[] data = {1, 2, 3};
doubleAll(data);            // data는 {2, 4, 6}

static int sum(int... nums) {           // nums는 int[]
    int s = 0;
    for (int n : nums) s += n;
    return s;
}
sum();          // 0
sum(1, 2, 3);   // 6
sum(new int[]{4, 5});  // 9