하루만에 코딩테스트 언어 갈아타기(Python → Java)(3 Array)

파이썬에는 Array와 List가 구분되어있지 않기 때문에 가장 생소하게 느껴질 수 있다.

사실상 코테 언어 바꿀 때 가장 문제가 되는 지점이 여기 같다. 자잘한 메소드야 외우면 그만인데, 자바에서는 어떤 타이밍에 리스트를 쓰고 어떤 타이밍에 배열을 써야하는지 빠르게 판단해야 하는 과제가 하나 더 얹어지는 느낌이다.

실제 시험에서는 무조건 리스트로 처리하다가 문제가 배열로 리턴하라고 할 때만 바꾸면 그만인 건가?(? 해봐야 알듯)

 

리스트와 달리 배열은 크기 변경이 불가능하기 때문에 제약이 많다.

 

0. 알아둘 것

배열 안에 배열 들어갈 수 있다. 이차원 배열

배열 안에 ArrayList도 들어갈 수 있다. 반대로 ArrayList 안에 배열 들어가는 것도 가능하다.

 

// 2차원 배열
int[][] array = { 
    {1, 2, 3}, 
    {4, 5, 6}, 
    {7, 8, 9} 
}; 
// 배열 안에 리스트 
ArrayList<Integer>[] arrayOfLists = new ArrayList[3];
arrayOfLists[0] = new ArrayList<>(Arrays.asList(1, 2, 3));
arrayOfLists[1] = new ArrayList<>(Arrays.asList(4, 5, 6));
arrayOfLists[2] = new ArrayList<>(Arrays.asList(7, 8, 9));
// 리스트 안에 배열
ArrayList<int[]> listOfArrays = new ArrayList<>();
listOfArrays.add(new int[] {1, 2, 3});
listOfArrays.add(new int[] {4, 5, 6});
listOfArrays.add(new int[] {7, 8, 9});

 

 

1. 원소 추가 : 를 하려면 ArrayList로 바꾼 다음 add로 추가하고 다시 새로운 Array로 바꾸는 방법밖에 없다. 기존 배열에는 추가 불가능

2. 원소 삭제 : 일단 생각 안 하는 게 정신건강에 좋다.

 

~~

 

 

3. 원하는 위치 원소 확인 

int firstElement = array[0]; // 첫 번째 원소
int lastElement = array[array.length - 1]; // 마지막 원소

 

4. 배열 길이 확인

int length = array.length; // list.size(), 문자열1.length();와 구분하기.

 

5. 파이썬의 슬라이싱에 대응하는 기능(copyOfRange)

int[] slicedArray = Arrays.copyOfRange(array, 1, 4); // 인덱스 1부터 3까지 복사

 

6. 얕은 복사(clone)

int[] shallowCopy = array.clone();

 

7. 깊은 복사(copyOf)

int[] deepCopy = Arrays.copyOf(array, array.length);

 

8. 정렬

 

공통 상황은 내부 자료구조의 2번째 인덱스 원소 기준으로 내림차순 정렬하고, 충돌 발생 시 3번째 인덱스 원소 기준으로 오름차순 정렬하는 것이다.

 

1) 이차원 배열에서

import java.util.Arrays;
import java.util.Comparator;

public class ArraySortExample {
    public static void main(String[] args) {
        int[][] array = {
            {1, 4, 5, 2},
            {2, 3, 6, 4},
            {3, 2, 5, 5},
            {4, 1, 6, 3}
        };

        Arrays.sort(array, new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                if (a[2] != b[2]) {
                    return Integer.compare(b[2], a[2]); // 인덱스 2 기준 내림차순
                } else {
                    return Integer.compare(a[3], b[3]); // 인덱스 3 기준 오름차순
                }
            }
        });

        for (int[] row : array) {
            System.out.println(Arrays.toString(row));
        }
    }
}

 

2) 배열 안에 리스트 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class ArrayOfListsSortExample {
    public static void main(String[] args) {
        ArrayList<Integer>[] arrayOfLists = new ArrayList[4];
        arrayOfLists[0] = new ArrayList<>(Arrays.asList(1, 4, 5, 2));
        arrayOfLists[1] = new ArrayList<>(Arrays.asList(2, 3, 6, 4));
        arrayOfLists[2] = new ArrayList<>(Arrays.asList(3, 2, 5, 5));
        arrayOfLists[3] = new ArrayList<>(Arrays.asList(4, 1, 6, 3));

        Arrays.sort(arrayOfLists, new Comparator<ArrayList<Integer>>() {
            @Override
            public int compare(ArrayList<Integer> a, ArrayList<Integer> b) {
                if (!a.get(2).equals(b.get(2))) {
                    return Integer.compare(b.get(2), a.get(2)); // 인덱스 2 기준 내림차순
                } else {
                    return Integer.compare(a.get(3), b.get(3)); // 인덱스 3 기준 오름차순
                }
            }
        });

        for (ArrayList<Integer> list : arrayOfLists) {
            System.out.println(list);
        }
    }
}

 

3) 리스트 안에 배열

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class ListOfArraysSortExample {
    public static void main(String[] args) {
        ArrayList<int[]> listOfArrays = new ArrayList<>();
        listOfArrays.add(new int[] {1, 4, 5, 2});
        listOfArrays.add(new int[] {2, 3, 6, 4});
        listOfArrays.add(new int[] {3, 2, 5, 5});
        listOfArrays.add(new int[] {4, 1, 6, 3});

        listOfArrays.sort(new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                if (a[2] != b[2]) {
                    return Integer.compare(b[2], a[2]); // 인덱스 2 기준 내림차순
                } else {
                    return Integer.compare(a[3], b[3]); // 인덱스 3 기준 오름차순
                }
            }
        });

        for (int[] array : listOfArrays) {
            System.out.println(Arrays.toString(array));
        }
    }
}

 

리스트든 배열이든 compare 메소드를 오버라이딩해서 쓰는 방법은 똑같다.

 

다만 준비시간이 너무 짧아서 이게 체화가 될지는 모르겠다. 그냥 어떤 문제가 나오든 무조건 내부 외부 다 ArrayList로 바꾸고 시작하는 게 지금 상황에서는 가능성 높은 방법일 수도 있겠다. 

 

 

+ 추가

Arrays.toString(배열); // 배열의 내용을 문자열로 바꿔 확인할 수 있게 해준다.