1차원 배열

• 연속하여 저장됨
• 동일한 데이터 타입, 하나의 변수로 관리, 연속되므로 인덱스를 통해 원소 접근 가능 (인덱싱)
• 메모리상 배열의 첫번째 원소의 주소가 배열 이름에 들어가 있기 때문에 첫 인덱스 = 0 (for 주소 유추)
  -> 배열 첫번째 인덱스 주소 + 인덱스 * 데이터 타입
• 동적 할당
  컴파일러는 new 하면 메모리 사이즈, 주소값을 알지 못함.

선언

• int[] scores = {100, 50, 40, 50, 80};
• int[] scores2 = new int[5];
• int[] sores3 = new int[] {100, 50, 40, 50, 80};
  • 두줄 가능
  • 인자나 반환값이 배열인 경우 사용
• for vs. for each

public class ArraysExample {
    public static void main(String[] args) {

        // 변수 이름이 다 다르기 때문에 관리하기 어렵다
        int score1 = 100;
        int score2 = 50;
        int score3 = 40;
        int score4 = 50;
        int score5 = 80;

        // 하나의 변수 이름으로 인덱스만 달리해서 데이터 관리 용이
        // 일차원 배열 선언
        // 1.
        int[] scores = {100, 50, 40, 50, 80}; // {} 1개 // 선언과 초기화 한줄에 해야함

        // 2.
        int[] scores2 = new int[5]; // 배열의 크기 !== 인덱스
        scores2[0] = 100;
        scores2[1] = 50;
        scores2[2] = 40;
        scores2[3] = 50;
        scores2[4] = 80;
        scores2[5] = 90; // ArrayIndexOutOfBoundsException (컴파일에러 아닌 실행 오류) // 컴파일 할때마다 out 폴더에 .class로 변한되어 저장됨
        // 동적할당
        // 컴파일러는 new 하면 메모리 사이즈, 주소값을 알지 못함. 실행할때 메모리가 할당되고 값 들어가므로 컴파일 단계에서 잡지 못함

        // 3.
//        int[] sores3 = new int[] {100, 50, 40, 50, 80};
        int[] scores3;
        scores3 = new int[] {100, 50, 40, 50, 80}; // 선언과 초기화 두줄로 할 수 있음

        // 인자나 반환값이 배열인 경우 3번 방식 주로 사용
//        add(new int[] {100, 50, 40, 50, 80});
//        add({100, 50, 40, 50, 80}); // 이렇게 안함

        // 배열 + for
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
            scores[i] = 100; // 원소 수정 하려면 for each 불가
        }

        // 배열 + for each (인덱스 필요 없이 원소값만 하나씩 가지고 와야할 경우)
        // 코드가 더 깔끔함
        sum = 0;
        for (int score: scores) {
            sum += score;
            score = 100; // 원소 수정 불가, 일기만 가능
        }
    }
}

Equals and Copy

public class ArraysEqualsCopyExample {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {1, 2, 3, 4, 5};

        // isEquals()
        System.out.println(isEquals(arr1, arr2));

        // copy()
        int[] copy = copy(arr1);
        System.out.println(copy); // 주소값 출력
        System.out.println(Arrays.toString(copy)); // 원소 출력 (내부에서 for문 돔)
        System.out.println(arr1); // 주소 다름

        // Arrays.toString() : 주소값 출력
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2) + "\n");

        // Arrays.equals() : 원소 비교
        System.out.println(Arrays.equals(arr1, arr2) + "\n");
    }

    // 두 배열이 모두 동일한 원소를 가진 배열 인지 확인하는 함수
    // 하나라도 다른지를 체크, 다르지 않다면 true (항상 반대로 생각하기)
    public static boolean isEquals(int[] arr1, int[] arr2) {
        if (arr1.length != arr2.length) return false; // 예외 처리

        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) return false;
        }

        return true; // 두가지 조건을 통과하면 같은 배열
    }

    // 하나의 배열의 원소를 복사하는 함수
    public static int[] copy(int[] arr) {
        int[] copy = new int[arr.length];

        for (int i = 0; i < arr.length; i++) {
            copy[i] = arr[i];
        }
        return copy;
    }

//    public static int[] copy(int[] arr) { // 원본의 주소 반환 (복사 아님) -> 복사본 수정하면 원본도 같이 수정되므로 새로운 배열 할당 해야함
//        return arr;
//    }
}

원소가 참조타입인 배열

public class StringArraysExample {
    public static void main(String[] args) {
        String[] names = {"Sally", "John", "Jacob", "Kelly", "Minna"};
        System.out.println("names = " + names); // 주소 출력 (주소 identification 위한 해시코드값. 주소값은 JVM이 최적화하며 계속 변경됨)

        for (int i = 0; i < names.length; i++) {
            System.out.println("names[i] = " + names[i]); // 원소 출력 (배열과 다르게 Sting 클래스는 내부적으로 데이터 자체 출력하도록 toString() 재정의 되어있음)
        }

        // VM.current().addressOf() 사용하면 주소값 알 수 있지만 이것도 정확한 주소값 아니라함 (JVM이 계속 변경)
    }
}