[Java] 배열

Notice

Recent Posts

Recent Comments

Link

« 2025/02 »
일	월	화	수	목	금	토
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28

Tags more

Archives

Today

Total

관리 메뉴

𝑆𝑢𝑛𝑠ℎ𝑖𝑛𝑒 𝑎𝑓𝑡𝑒𝑟 𝑟𝑎𝑖𝑛✧

[Java] 배열 본문

𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴💻/𝐉𝐚𝐯𝐚

[Java] 배열

🤍Ryusun🤍 2022. 9. 30. 16:41

⭐ 배열

일차원 배열
- 변수는 한 개의 데이터만 저장할 수 있음
동일한 데이터 타입을 여러 개 저장하고 싶을 경우 배열 사용
- 인덱스는 0부터 시작
- 배열 원소 사이에는 순서가 존재
- 하나의 배열 이름을 공유할 수 있기 때문에 나중에 for문과 같이 사용
선언
- 데이터타입[] 배열변수이름 = new 데이터타입[데이터 개수];
- 배열 선언시 원소값을 알고 있는 경우
  - 데이터타입[] 배열변수이름 = {..., ..., ..., ..., ...};
- 배열 객체가 없다면 null 초기화 가능
  - 데이터타입[] 배열변수이름 = null;

int[] scores = new int[100];

for (int i = 0; i<100; i++){
    scores[i] = i+1; //1부터 값을 넣어준다.

int[] scores = {90, 83, 77, 100, ..., 60};

이차원 배열
- 행과 열을 가진 테이블 형태의 데이터 저장할 경우 이차원 배열 사용
- 선언 방법
  - 배열 선언시 저장할 행과 열의 개수만 알고 있는 경우
  - 데이터타입[][] 배열변수이름 = new 데이터타입[행의 크기][열의 크기];

int[][] scores = new int[1][3];

scores[0][0] = 10;
scores[0][1] = 20;
scores[0][2] = 30;

일차원배열 ↔ 이차원배열

public class Array1dtoArray2dExample {
    public static void main(String[] args) {
        final int ROW_NUM = 3;
        final int COL_NUM = 5;
        final int NUM = ROW_NUM * COL_NUM;
        int[] arr1d = new int[NUM];
        for (int i = 0; i < arr1d.length; i++) {
            arr1d[i] = i + 1;
        }
        for (int element: arr1d) {
            System.out.printf("%2d ", element);
        }
        System.out.println("\n");

        int[][] arr2d = new int[ROW_NUM][COL_NUM];
        for (int i = 0; i < arr2d.length; i++) {
            for (int j = 0; j < arr2d[i].length; j++) {
                arr2d[i][j] = arr1d[i * COL_NUM + j];
            }
        }
        for (int i = 0; i < arr2d.length; i++) {
            for (int j = 0; j < arr2d[i].length; j++) {
                System.out.printf("%2d ", arr2d[i][j]);
            }
            System.out.println();
        }
        System.out.println("\n");

        int[] arr1dRevert = new int[ROW_NUM * COL_NUM];
        for (int i = 0; i < arr2d.length; i++) {
            for (int j = 0; j < arr2d[i].length; j++) {
                arr1dRevert[i * COL_NUM + j] = arr2d[i][j];
            }
        }
        for (int element: arr1dRevert) {
            System.out.printf("%2d ", element);
        }
    }
}

배열 출력
- 1차원 배열 : toString 함수 사용한다.
- 다차원 배열 : deepToString 함수 사용한다.

import java.util.Arrays;

public class ArraysToStringExample {
    public static void main(String[] args) {
        // 일차원 배열 출력
        int[] arr1d = {1, 2, 3, 4, 5};
        String[] strArr1d = {"Java", "JSP", "Servlet", "Spring"};
        System.out.println(Arrays.toString(arr1d));
        System.out.println(Arrays.toString(strArr1d));
        Arrays.stream(arr1d).forEach((i) -> System.out.print(i + " ")); //stream 이용해서 람다식 활용
        Arrays.stream(strArr1d).forEach((i) -> System.out.print(i + " "));
        System.out.println("\n");

        // 이차원 배열 출력
        int[][] arr2d = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        String[][] strArr2d = {{"a", "ab", "abc"}, {"1", "12", "123"}, {"a1", "b2", "c3"}};
        System.out.println(Arrays.deepToString(arr2d)); //deepToString 함수 사용
        System.out.println(Arrays.deepToString(strArr2d));
        Arrays.stream(arr2d).forEach((i) -> {
            Arrays.stream(i).forEach((j) -> System.out.print(j + " "));
            System.out.println();
        });
        Arrays.stream(strArr2d).forEach((i) -> {
            Arrays.stream(i).forEach((j) -> System.out.print(j + " "));
            System.out.println();
        });
    }
}

배열 비교
- Equals 함수 사용

import java.util.Arrays;

public class ArraysEqualsExample {
    public static void main(String[] args) {
        // 일차원 배열 비교
        int[] arr1d = {1, 2, 3, 4, 5, 6};
        int[] arr1dCompare = {1, 2, 3, 4, 5, 6, 7};
        String[] strArr1d = {"Java", "JSP", "Servlet", "Spring"};
        String[] strArr1dCompare = {"Java", "JSP", "Servlet", "Spring"};

        System.out.println(arr1d == arr1dCompare); // 주소값 비교
        System.out.println(arr1d.equals(arr1dCompare)); // 주소값 비교
        System.out.println(strArr1d == strArr1dCompare); // 주소값 비교
        System.out.println(strArr1d.equals(strArr1dCompare)); // 주소값 비교

        System.out.println(isEquals(arr1d, arr1dCompare)); // 원소값 비교
        System.out.println(isEquals(strArr1d, strArr1dCompare)); // 원소값 비교
        System.out.println(Arrays.equals(arr1d, arr1dCompare)); // 원소값 비교
        System.out.println(Arrays.equals(strArr1d, strArr1dCompare)); // 원소값 비교
        System.out.println();

        // 이차원 배열 비교
        int[][] arr2d = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int[][] arr2dCompare = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        String[][] strArr2d = {{"a", "ab", "abc"}, {"1", "12", "123"}, {"a1", "b2", "c3"}};
        String[][] strArr2dCompare = {{"a", "ab", "abc"}, {"1", "12", "123"}, {"a1", "b2", "c3"}};

        System.out.println(arr2d == arr2dCompare); // 주소값 비교
        System.out.println(strArr2d == strArr2dCompare); // 주소값 비교
        System.out.println(arr2d.equals(arr2dCompare)); // 주소값 비교
        System.out.println(strArr2d == strArr2dCompare); // 주소값 비교

        for (int i = 0; i < arr2d.length; i++) {
            System.out.println(arr2d[i] == arr2dCompare[i]); // 주소값 비교
            System.out.println(strArr2d[i] == strArr2dCompare[i]); // 주소값 비교
            System.out.println(arr2d[i].equals(arr2dCompare[i])); // 주소값 비교
            System.out.println(strArr2d[i] != null && strArr2d[i].equals(strArr2dCompare[i])); // 주소값 비교
        }
        System.out.println(isDeepEquals(arr2d, arr2dCompare)); // 원소값 비교
        System.out.println(isDeepEquals(strArr2d, strArr2dCompare)); // 원소값 비교
        System.out.println(Arrays.deepEquals(arr2d, arr2dCompare)); // 원소값 비교
        System.out.println(Arrays.deepEquals(strArr2d, strArr2dCompare)); // 원소값 비교
        System.out.println();
    }
    public static boolean isEquals(int[] a, int[] b) {
        if (a.length != b.length) return false;

        for (int i = 0; i < a.length; i++) {
            if (a[i] != b[i]) return false;
        }
        return true;
    }
    public static boolean isEquals(String[] a, String[] b) {
        if (a.length != b.length) return false;

        for (int i = 0; i < a.length; i++) {
            if (a[i] != null && !a[i].equals(b[i])) return false;
        }
        return true;
    }
    public static boolean isDeepEquals(int[][] a, int[][] b) {
        if (a.length != b.length) return false;
        if (a[0].length != b[0].length) return false;

        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                if (a[i][j] != b[i][j]) return false;
            }
        }
        return true;
    }
    public static boolean isDeepEquals(String[][] a, String[][] b) {
        if (a.length != b.length) return false;
        if (a[0].length != b[0].length) return false;

        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                if (a[i][j] != null && !a[i][j].equals(b[i][j])) return false;
            }
        }
        return true;
    }
}

Compare 함수 사용

import java.util.Arrays;

public class ArraysCompareExample {
    public static void main(String[] args) {
        int[] arr1d = {1, 2, 3, 4, 5, 6};
        int[] arr1dCompare = {1, 2, 3, 4, 5, 6, 7};
        String[] strArr1d = {"Java", "JSP", "Servlet", "Spring"};
        String[] strArr1dCompare = {"Javp", "JSP", "Servlet", "Spring", "Python"};

        System.out.println(compare(arr1d, arr1dCompare)); // 원소값 비교
        System.out.println(Arrays.compare(arr1d, arr1dCompare)); // 원소값 비교
        System.out.println(compare(strArr1d, strArr1dCompare)); // 원소값 비교
        System.out.println(Arrays.compare(strArr1d, strArr1dCompare)); // 원소값 비교
        System.out.println();
    }

    public static int compare(int[] a, int[] b) {
        int minLength = Math.min(a.length, b.length);
        for (int i = 0; i < minLength; i++) {
            if (a[i] != b[i]) {
                return Integer.compare(a[i], b[i]);
            }
        }
        if (a.length < b.length) return -1;
        else if (a.length > b.length) return 1;
        else return 0;
    }
    public static int compare(String[] a, String[] b) {
        int minLength = Math.min(a.length, b.length);
        for (int i = 0; i < minLength; i++) {
            if (a[i] != null && !a[i].equals(b[i])) {
                return a[i].compareTo(b[i]);
            }
        }
        if (a.length < b.length) return -1;
        else if (a.length > b.length) return 1;
        else return 0;
    }
}

배열 복사
- 배열 이름이 아닌 배열 원소를 반복하면서 복사해야함
- Shallow Copy
  - "주소값"을 복사
  - 일차원 배열 복사할 경우

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

- Deep Copy
  - 실제 값'을 새로운 메모리 공간에 복사
  - 이중 구조를 가진 배열이나 객체를 복사할 경우

import java.util.Arrays;

public class ArraysCopyExample {
    public static void main(String[] args) {
        // 일차원 배열 복사
        int[] arr1d = {1, 2, 3, 4, 5, 6};
        int[] arr1dCopy = arr1d; // 주소값 대입
        String[] strArr1d = {"Java", "JSP", "Servlet", "Spring"};
        String[] strArr1dCopy = strArr1d; // 주소값 대입
        final int NEW_LEN = 7;

        arr1dCopy = Arrays.copyOf(arr1d, NEW_LEN); // 배열 원소값 복사
        strArr1dCopy = Arrays.copyOf(strArr1d, NEW_LEN); // 배열 원소값 복사
        System.out.println(Arrays.toString(arr1dCopy));
        System.out.println(Arrays.toString(strArr1dCopy));

        System.out.println(arr1d == arr1dCopy); // false
        System.out.println(Arrays.equals(arr1d, arr1dCopy)); // false
        System.out.println(strArr1d == strArr1dCopy); // false
        System.out.println(Arrays.equals(strArr1d, strArr1dCopy)); // false

        arr1dCopy = copy(arr1d, NEW_LEN); // 배열 원소값 복사
        strArr1dCopy = copy(strArr1dCopy, NEW_LEN); // 배열 원소값 복사
        System.out.println(Arrays.toString(arr1dCopy));
        System.out.println(Arrays.toString(strArr1dCopy));
//        Arrays.copyOfRange() // 배열 일부 원소만 복사

        System.out.println(arr1d == arr1dCopy); // false
        System.out.println(Arrays.equals(arr1d, arr1dCopy)); // false
        // String.equals()
        // for(int i = 0; i < str.length() ...) ...
        System.out.println(strArr1d == strArr1dCopy); // false
        System.out.println(Arrays.equals(strArr1d, strArr1dCopy)); // false


        // 이차원 배열 복사
        int[][] arr2d = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int[][] arr2dCopy = arr2d; // 주소값 대입
        String[][] strArr2d = {{"a", "ab", "abc"}, {"1", "12", "123"}, {"a1", "b2", "c3"}};
        String[][] strArr2dCopy = strArr2d; // 주소값 대입

        final int NEW_ROW = 3;
        final int NEW_COL = 5;
        arr2dCopy = deepCopy(arr2d, NEW_ROW, NEW_COL);
        strArr2dCopy = deepCopy(strArr2d, NEW_ROW, NEW_COL);
        System.out.println(Arrays.deepToString(arr2dCopy));
        System.out.println(Arrays.deepToString(strArr2dCopy));

        System.out.println(arr2d == arr2dCopy); // false
        System.out.println(Arrays.deepEquals(arr2d, arr2dCopy)); // false
        System.out.println(strArr2d == strArr2dCopy); // false
        System.out.println(Arrays.deepEquals(strArr2d, strArr2dCopy)); // false


        arr2dCopy = deepCopyWithStream(arr2d);
        strArr2dCopy = deepCopyWithStream(strArr2d);
        System.out.println(Arrays.deepToString(arr2dCopy));
        System.out.println(Arrays.deepToString(strArr2dCopy));

        System.out.println(arr2d == arr2dCopy); // false
        System.out.println(Arrays.deepEquals(arr2d, arr2dCopy)); // true
        System.out.println(strArr2d == strArr2dCopy); // false
        System.out.println(Arrays.deepEquals(strArr2d, strArr2dCopy)); // true

    }
    public static int[] copy(int[] original, int newLength) {
        int[] copied = new int[newLength];
        for (int i = 0; i < original.length; i++) {
            copied[i] = original[i];
        }
        return copied;
    }
    public static String[] copy(String[] original, int newLength) {
        String[] copied = new String[newLength];
        for (int i = 0; i < original.length; i++) {
            if (original[i] != null) {
                copied[i] = original[i];
            }
        }
        return copied;
    }
    public static int[][] deepCopy(int[][] original, int newRow, int newColumn) {
        int[][] copied = new int[newRow][newColumn];
        for (int i = 0; i < original.length; i++) {
            for (int j = 0; j < original[i].length; j++) {
                copied[i][j] = original[i][j];
            }
        }
        return copied;
    }
    public static String[][] deepCopy(String[][] original, int newRow, int newColumn) {
        String[][] copied = new String[newRow][newColumn];
        for (int i = 0; i < original.length; i++) {
            for (int j = 0; j < original[i].length; j++) {
                if (original[i][j] != null) {
                    copied[i][j] = original[i][j];
                }
            }
        }
        return copied;
    }
    public static int[][] deepCopyWithStream(int[][] original) {
        return Arrays.stream(original).map(r -> Arrays.copyOf(r, r.length)).toArray(int[][]::new);
    }
    public static String[][] deepCopyWithStream(String[][] original) {
        return Arrays.stream(original).map(r -> Arrays.copyOf(r, r.length)).toArray(String[][]::new);
    }
}

'𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴💻 > 𝐉𝐚𝐯𝐚' 카테고리의 다른 글

[Java] 캡슐화 (0)	2022.10.07
[Java] 객체, 생성자, 클래스 (0)	2022.10.07
[Java] 문자열 (0)	2022.09.30
[Java] 조건문 (0)	2022.09.30
[Java] 입출력, 자료형, 연산자 (4)	2022.09.23

'𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴💻/𝐉𝐚𝐯𝐚' Related Articles

𝑆𝑢𝑛𝑠ℎ𝑖𝑛𝑒 𝑎𝑓𝑡𝑒𝑟 𝑟𝑎𝑖𝑛✧

[Java] 배열 본문

[Java] 배열

⭐ 배열

'𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴💻 > 𝐉𝐚𝐯𝐚' 카테고리의 다른 글

티스토리툴바