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

ArrayList에 대해 속속들이 알아보는 시간^^ 

파이썬에서는 리스트 안에 여러 자료형을 막 담아서 자유롭게 쓸 수 있지만 자바에서는 자료형은 무조건 한 가지만 가능하다.

(사실 이게 기본)

 

1. 원소 추가(add)

ArrayList<String> list = new ArrayList<>();
list.add("element"); // 맨 뒤에 원소 추가
list.add(1, "element"); // 인덱스 1 위치에 원소 삽입

 

 

2. 원소 삭제(remove)

list.remove("element"); // "element"라는 값을 가진 첫 번째 원소 삭제
list.remove(1); // 인덱스 1의 원소 삭제

 

 

3. 맨 앞이나 맨 뒤 원소 확인 (Stack이나 Queue 역할) : 리스트이름.get(원하는 인덱스) 하면 원하는 위치의 원소 확인 가능

list.get(0); // 맨 앞 원소
list.get(list.size() - 1); // 맨 뒤 원소

 

4. 파이썬의 리스트이름.pop()에 대응하는 메소드 : remove와 get 조합하여 구현

list.remove(list.size() - 1); // 리스트의 마지막 원소 제거하며 반환

 

5. 리스트 길이 확인(size)

list.size(); 

 

 

6. 파이썬의 슬라이싱에 대응하는 기능 : subList

2023.12.10 - [Java] - [Java] subList 사용법

List<String> subList = list.subList(1, 3); // 인덱스 1부터 3 전까지 슬라이싱

 

// subList는 원본 리스트에도 영향이 간다. 독립적인 리스트를 만들려면 아래와 같은 방법 이용

ArrayList<String> originalList = new ArrayList<>(Arrays.asList("a", "b", "c", "d", "e"));
ArrayList<String> separateList = new ArrayList<>(originalList.subList(1, 3)); // 인덱스 1부터 3 전까지

 

 

7. 정렬

 

기본적으로 두 가지 방법이 있다. 

1)

Collections.sort(list); // 오름차순 정렬

Collections.sort(list, Comparator.reverseOrder()); // 내림차순 정렬

 

2)

list.sort(Comparator.naturalOrder()); // 오름차순

list.sort(Comparator.reverseOrder()); // 내림차순

 

그런데 리스트 안에 리스트들을 넣어서, 내부 리스트의 특정 위치의 원소를 기준으로 정렬하고 싶을 때도 있다. 

일단 이차원 리스트를 다루는 방법부터 알아보자.

 

1)
ArrayList<ArrayList<Integer>> twoDList = new ArrayList<>(); // 선언

 

2)

ArrayList<Integer> innerList1 = new ArrayList<>(Arrays.asList(1, 2, 3));
ArrayList<Integer> innerList2 = new ArrayList<>(Arrays.asList(4, 5, 6));
twoDList.add(innerList1); // 첫 번째 리스트 추가
twoDList.add(innerList2); // 두 번째 리스트 추가

// 내부 리스트들을 먼저 만든 뒤, 하나씩 add로 추가하는 방법

 

3) 내부 값 접근
int value = twoDList.get(0).get(1); // 첫 번째 리스트의 두 번째 원소

 

4) 초기화와 선언을 동시에도 가능

ArrayList<ArrayList<Integer>> twoDList = new ArrayList<>(
    Arrays.asList(
        new ArrayList<>(Arrays.asList(1, 2, 3)),
        new ArrayList<>(Arrays.asList(4, 5, 6))
    )
);

 

아래는 이차원 리스트를 내부 리스트의 특정 위치 원소 기준으로 정렬하는 방법

 

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

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

        // 두 번째 원소 기준으로 정렬하고, 충돌이 있으면 세 번째 원소 기준으로 정렬
        listOfLists.sort(Comparator.comparing((ArrayList<Integer> list) -> list.get(1))
                                   .thenComparing(list -> list.get(2)));

        // 결과 출력
        for (ArrayList<Integer> innerList : listOfLists) {
            System.out.println(innerList);
        }
    }
}

• Comparator.comparing을 사용하여 내부 리스트의 두 번째 원소(list.get(1))를 기준으로 정렬

• thenComparing을 사용해, 두 번째 원소가 동일할 경우 세 번째 원소(list.get(2))를 기준으로 추가 정렬

 

 

8. 얕은 복사(clone)

ArrayList<String> shallowCopy = (ArrayList<String>) list.clone();

 

 

9. 깊은 복사 : 그냥 for 돌려서 하나씩 새로운 객체로 복사본 만들어서 새 리스트에 집어넣기... 

ArrayList<String> deepCopy = new ArrayList<>();
for (String item : list) {
    deepCopy.add(new String(item)); // 새로운 객체로 복사
}