[Java] ArrayList 사용시 주의해야 할 점

출처

ChatGPT

---

1. 초기 용량 지정

ArrayList의 기본 용량은 10으로 설정되어 있다. 리스트의 크기가 기본 용량을 초과할 경우, ArrayList는 내부적으로 배열의 크기를 늘리기 위해 새로운 배열을 생성하고 기존 배열의 내용을 복사한다. 이 과정은 비싼 연산으로, 성능에 영향을 미칠 수 있다.

주의할 점

리스트의 크기를 미리 예측할 수 있다면, ArrayList를 생성할 때 초기 용량을 지정하는 것이 좋다.

List<String> list = new ArrayList<>(100); // 예상 크기에 따라 초기 용량 설정

 

 

2. 메모리 사용과 제거

ArrayList는 내부적으로 요소들을 배열로 관리한다. 따라서 리스트에서 요소를 제거하면 해당 위치를 null로 설정하지 않는다. 이로 인해 메모리 누수가 발생할 수 있다.

주의할 점

요소를 제거할 때 ArrayList가 참조하고 있는 객체를 null로 명시적으로 설정하여 메모리 누수를 방지할 수 있다.

list.remove(index);
list.set(index, null); // 요소가 더 이상 필요하지 않으면 명시적으로 null로 설정

 

 

Java 8 ArrayList 의 remove() 소스 코드 내부의 구현 사항을 보면 이렇게 해야하는 것에 의문이 생긴다. 

• 관련 글 -> [Java] ArrayList 내부 구현

1. index가 맨 끝 요소일 경우 : remove 내부에서 맨 끝 공간에 null을 할당한다. 구지 개발자가 할 필요가 없다.

2. index가 맨 끝 요소가 아닐 경우 : index 뒤에 있는 요소들이 다 한 칸씩 앞으로 옮겨진다. 마지막 공간은 null이 할당되고 사용 사이즈(접근 가능 크기)도 한 칸 줄어든다. 이 상태에서 index 칸의 요소를 null 처리 하는 건, 이미 옮겨진 값을 대체해 null을 할당하는 것이라서, 메모리 누수를 위한 방법과는 전혀 상관없다.

ArrayList에 메모리 누수 문제가 발생할 수는 있는데, 이렇게 대응하는 것은 아닌 거 같다.

 

 

 ArrayList 의 메모리 누수 문제

1. ArrayList의 내부 구조

ArrayList는 내부적으로 Object[] 타입의 배열을 사용해 데이터를 저장한다. 이 배열은 요소를 추가함에 따라 크기가 자동으로 증가하는데, 배열이 꽉 차면 현재 크기의 1.5배로 새로운 배열을 할당하고 기존 데이터를 복사한다.

예를 들어, 초기 용량이 10인 ArrayList가 있다고 가정하고, 여기에 10개의 요소를 추가하면 용량이 가득 차게 된다. 11번째 요소를 추가하려고 하면 ArrayList는 내부적으로 더 큰 배열(15개 크기)을 할당하고, 기존 배열의 모든 요소를 새 배열로 복사한 후 새로운 요소를 추가한다.

 

ArrayList의 크기 증가 배율

• ava 1.4 이하: Java 1.4 이전 버전에서는 ArrayList의 크기가 부족할 때마다 2배로 증가했다.
• Java 1.5 이후: Java 1.5부터는 크기 증가 정책이 변경되어, 배열의 크기가 부족할 때마다 현재 배열 크기의 1.5배로 증가하게 된다. 공식적으로는 (oldCapacity * 3) / 2 + 1 방식으로 계산하여 늘리도록 되어 있다.

 

2. 요소 제거 시 메모리 관리 문제

ArrayList에서 요소를 제거할 때, 다음과 같은 과정을 거친다.

• ArrayList에서 특정 위치의 요소를 제거하면 해당 요소 뒤에 있는 모든 요소들을 앞으로 한 칸씩 이동시켜 빈 공간을 메운다.
• 이때 ArrayList는 단순히 요소들을 이동시킬 뿐이며, 메모리 상에서 배열의 크기를 줄이거나 할당된 메모리를 해제하지 않는다.

 

이 과정에서 문제가 되는 부분은, ArrayList가 null을 명시적으로 설정하지 않는다면, 제거된 요소가 여전히 메모리 상에 남아 있을 수 있다는 점이다. 이는 메모리 누수(memory leak)를 유발할 수 있는 상황으로, 특히 크기가 큰 객체를 많이 포함하는 ArrayList에서는 심각한 성능 저하를 초래할 수 있다.

 

예시

import java.util.ArrayList;

public class Example {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>(10);
        
        // 10개의 객체를 추가
        for (int i = 0; i < 10; i++) {
            list.add(new Object());
        }
        
        // 5개의 객체를 제거
        for (int i = 0; i < 5; i++) {
            list.remove(0);
        }
        
        // 이 시점에서 ArrayList는 내부적으로 10개의 크기의 배열을 가지고 있지만,
        // 현재 5개의 요소만 저장하고 있음
        System.out.println("ArrayList size: " + list.size()); // 5 출력
    }
}

 

위 코드에서 ArrayList는 처음에 10개의 객체를 저장하고 있다가 5개의 객체를 제거했다. 하지만 내부 배열 크기는 여전히 10이며, 제거된 5개의 자리는 null로 처리하지 않기 때문에 만약 제거된 객체가 외부에서 참조하고 있다면 메모리 누수가 발생할 가능성이 있다.

3. 메모리 누수의 위험성

메모리 누수(memory leak)는 사용하지 않는 메모리가 해제되지 않고 남아 있는 상황을 말한다. ArrayList에서 메모리 누수가 발생할 수 있는 몇 가지 일반적인 상황은 다음과 같다.

1. 대용량 데이터 처리

대량의 데이터를 처리하면서 빈번한 삽입과 삭제가 이루어지는 경우, 제거된 객체에 대한 참조가 해제되지 않아 메모리가 계속 사용된 상태로 남아 있게 된다.

2. 롱런(long-running) 프로그램

서버 애플리케이션이나 데스크톱 애플리케이션처럼 오랜 시간 동안 실행되는 프로그램에서는 이러한 메모리 누수가 점점 쌓여 성능에 심각한 영향을 미칠 수 있다.

4. 메모리 누수를 방지하기 위한 조치

1. null 할당

필요 없는 객체를 제거할 때, 수동으로 null을 할당하여 참조를 해제할 수 있다.

대신 null 값 확인을 안하면 NPE가 발생할 수 있어서 조심해야 한다.

list.remove(index);
list.set(index, null); // 명시적으로 null 할당

 

2.  ArrayList의 용량 줄이기

요소를 많이 제거한 후, 메모리를 해제하고 싶다면 trimToSize() 메서드를 호출하여 실제로 필요한 메모리만 유지할 수 있다.

list.trimToSize();

 

3. WeakReference 사용

큰 객체를 참조할 때, 강한 참조 대신 WeakReference를 사용하여 메모리 누수를 방지할 수 있다.

 

4. 적절한 데이터 구조 사용

ArrayList는 크기 조정이 빈번한 경우 적절하지 않을 수 있다. 이러한 경우 LinkedList와 같은 다른 데이터 구조를 고려할 수 있다.

 

3. 스레드 안전성

ArrayList는 비동기적이며, 다중 스레드 환경에서는 스레드 안전하지 않다. 여러 스레드에서 동시에 ArrayList를 수정하면 ConcurrentModificationException이 발생할 수 있다.

 

주의할 점

다중 스레드 환경에서 ArrayList를 사용해야 할 경우, Collections.synchronizedList 메서드로 동기화된 리스트로 감싸야 한다.

List<String> syncList = Collections.synchronizedList(new ArrayList<>());

또는 CopyOnWriteArrayList와 같은 스레드 안전한 대안을 고려할 수 있다.

 

4. 성능 최적화

ArrayList에서의 요소 삽입과 삭제는 배열의 크기 조정과 이동 연산이 필요할 수 있어 O(n)의 시간 복잡도를 가질 수 있다. 특히, 리스트의 중간에 요소를 삽입하거나 삭제할 경우 성능 저하가 발생할 수 있다.

주의할 점

• 리스트의 끝에 요소를 추가할 때만 ArrayList를 사용하는 것이 좋다.
• 요소 삽입과 삭제가 빈번히 발생하는 경우 LinkedList와 같은 다른 자료 구조를 고려하는 것이 좋다.

 

5. Null 요소

ArrayList는 null 요소를 허용한다. 그러나 리스트에 null이 포함될 수 있음을 고려하지 않으면 NullPointerException이 발생할 위험이 있다.

주의할 점

리스트를 순회하거나 요소를 처리할 때, null 요소에 대한 처리를 명확히 해야 한다.

 

6. 배열 복사 비용

ArrayList가 내부적으로 사용하는 배열이 가득 차면, 배열의 크기를 (최신 버전에서)  1.5 배로 늘리고 기존의 배열을 새 배열에 복사한다. 이 배열 복사 작업은 O(n)의 시간 복잡도를 가지며, 큰 배열에서는 상당한 비용이 발생할 수 있다.

주의할 점

 

• 예상되는 최대 크기를 기반으로 적절한 초기 용량을 설정하여 배열 복사를 최소화해야 한다.
• 크기가 커질 경우 성능에 미치는 영향을 최소화하기 위해 용량 증가 로직을 제어할 수 있는 사용자 정의 리스트 클래스를 고려할 수 있다.

 

 

7. Boxing과 Unboxing 비용

ArrayList는 객체 타입만 저장할 수 있기 때문에, 원시 타입(int, char 등)을 저장하려면 래퍼 클래스(Integer, Character 등)를 사용해야 한다. 이 과정에서 Boxing과 Unboxing이 발생하며, 이는 성능에 영향을 줄 수 있다.

주의할 점

원시 타입을 많이 사용하는 경우 ArrayList 대신 원시 타입을 지원하는 컬렉션 라이브러리(예: Trove4j, FastUtil 등)를 고려할 수 있다.

 

8. UnsupportedOpertationException

ArrayList를 다른 리스트에서 생성할 때 주의해야 한다. 예를 들어, Arrays.asList()로 생성된 리스트를 기반으로 ArrayList를 초기화할 경우 UnsupportedOperationException이 발생할 수 있다.

주의할 점

리스트 생성 시 명확히 새로운 ArrayList 객체를 생성해야 한다.

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));

 

Arrays.asList()와 ArrayList의 차이점

1. Arrays.asList() 메서드

 

• 이 메서드는 고정된 크기의 리스트 뷰를 반환한다.
• 이 리스트는 기본적으로 주어진 배열을 백업으로 사용하며, 배열의 길이가 변경되지 않기 때문에 크기를 변경할 수 없다.
• 리스트의 내용을 변경할 수는 있지만(set() 메서드 사용), 리스트의 크기를 변경하는 메서드(add(), remove(), 등)를 호출하면 UnsupportedOperationException이 발생한다.

예시

String[] array = {"a", "b", "c"};
List<String> list = Arrays.asList(array); // 리스트의 크기는 변경할 수 없음
list.set(0, "x");  // 가능, 리스트의 요소를 수정할 수 있음
list.add("d");     // UnsupportedOperationException 발생

 

 

2. ArrayList 클래스

 

• ArrayList는 동적 배열을 기반으로 하며, 내부적으로 객체 배열을 사용하여 데이터를 저장한다.
• 크기를 조정할 수 있으며, add(), remove(), set(), 등 다양한 메서드를 통해 리스트의 요소와 크기를 동적으로 변경할 수 있다.

예시

ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("a"); // 가능
arrayList.add("b"); // 가능
arrayList.remove("a"); // 가능

 

 

Arrays.asList()를 사용하여 ArrayList를 초기화할 때의 문제점

 

불변 리스트의 생성

Arrays.asList()로 생성된 리스트는 크기를 변경할 수 없는 고정된 크기의 리스트다. 이 리스트는 원본 배열의 뷰 역할을 하며, 원본 배열과 동일한 크기를 가지며 같은 요소들을 공유한다.

 

원본 배열의 뷰라는 의미

원본 배열을 직접 참조하고 있다는 의미. 원본 배열과 리스트가 같은 데이터 요소를 공유한다. 리스트를 수정하면 배열의 요소도 변경되곡, 배열의 요소를 수정하면 리스트에서 변경된 내용을 볼 수 있다.

 

UnsupportedOperationException 발생

만약 Arrays.asList()로 생성된 리스트를 기반으로 ArrayList를 생성한다면, 이 리스트는 여전히 원본 배열에 대한 고정된 크기의 뷰이므로 add()나 remove()와 같은 크기 변경 메서드를 호출할 때 UnsupportedOperationException이 발생한다.

 

예시

List<String> list = Arrays.asList("a", "b", "c");
List<String> arrayList = new ArrayList<>(list); // `ArrayList`를 생성하지만 내부적으로 여전히 고정된 크기
arrayList.add("d"); // 가능, ArrayList는 새로운 동적 배열을 사용함

List<String> fixedSizeList = Arrays.asList("x", "y", "z");
fixedSizeList.add("w"); // UnsupportedOperationException 발생

 

 

ArrayList로 변환하기

Arrays.asList()로 생성된 고정 크기의 리스트를 완전한 동적 ArrayList로 변환하고 싶다면, ArrayList의 생성자에 고정 크기의 리스트를 전달하여 새로운 리스트 객체를 생성해야 한다. 이 새로운 리스트는 원본 배열과 독립적이며, 고유의 동적 크기를 갖게 된다.

String[] array = {"a", "b", "c"};
List<String> fixedSizeList = Arrays.asList(array); // 고정 크기 리스트
List<String> dynamicArrayList = new ArrayList<>(fixedSizeList); // 새로운 동적 ArrayList 생성
dynamicArrayList.add("d"); // 가능, 동적 크기의 리스트

 

이 코드는 fixedSizeList의 요소들을 갖는 새로운 ArrayList를 생성한다. 이 새로운 리스트는 원본 배열과 독립적이며, 크기 조정 메서드를 사용해도 UnsupportedOperationException이 발생하지 않는다.

 

주의점과 Best Practice

1. 원본 배열과의 독립성

Arrays.asList()는 원본 배열에 대한 뷰이므로, 배열의 변경이 리스트에도 영향을 줄 수 있다. 독립적인 리스트가 필요하다면, 새로운 ArrayList를 생성하는 것이 좋다.

2. 불변 리스트와 수정 가능 리스트의 차이

Arrays.asList()로 생성된 리스트는 크기 변경이 불가능한 불변 리스트이다. 이 점을 명확히 인지하고 사용해야 다.

3. 배열의 사용 시점

만약 고정 크기 리스트가 필요한 경우 Arrays.asList()를 사용해도 좋지만, 크기 변경이 필요한 경우 반드시 새로운 ArrayList를 생성하여 사용해라.