1. List 인터페이스

1.1 List 소개

Java의 컬렉션 프레임워크에서 List는 Collection을 상속받는 인터페이스입니다. Iterable <-- Collection <-- List.

Collection도 인터페이스이며, 이는 후속 컨테이너에서 사용되는 일반적인 메서드를 정의합니다.

Iterable은 요소를 개별적으로 순회할 수 있는 클래스를 나타내는 또 다른 인터페이스입니다.

데이터 구조 관점에서 보면, List는 동일한 타입의 요소로 이루어진 유한 시퀀스인 선형 리스트이며, 이 시퀀스에서는 추가, 삭제, 수정 및 검색 등의 연산을 수행할 수 있습니다.

2.1 주요 메서드

List 인터페이스는 다음과 같은 다양한 메서드를 제공합니다:

• boolean add(E e) - 요소 e를 리스트의 끝에 추가합니다.
• void add(int index, E element) - index 위치에 요소 e를 삽입합니다.
• E remove(int index) - index 위치의 요소를 제거합니다.
• E get(int index) - index 위치의 요소를 반환합니다.
• void clear() - 모든 요소를 제거합니다.

2. ArrayList와 순차 리스트

2.1 순차 리스트 구현

순차 리스트는 연속된 메모리 공간을 이용하여 데이터 요소를 저장하는 선형 구조입니다. 일반적으로 배열을 사용하여 구현됩니다.

2.1.1 IList 인터페이스

public interface IList {
    void append(int data); // 마지막에 요소 추가
    void insertAt(int pos, int data); // 특정 위치에 요소 삽입
    boolean contains(int toFind); // 요소 포함 여부 확인
    int findIndex(int toFind); // 요소의 인덱스 찾기
    int retrieveAt(int pos); // 특정 위치의 요소 가져오기
    void updateAt(int pos, int value); // 특정 위치의 요소 업데이트
    void delete(int toRemove); // 첫 번째 일치하는 요소 삭제
    int length(); // 리스트 길이 반환
    void empty(); // 리스트 비우기
    void display(); // 리스트 출력 (테스트 용)
    boolean isFull(); // 리스트가 가득 찼는지 확인
    boolean isEmpty(); // 리스트가 비어있는지 확인
}

2.2 MyArrayList 클래스

public class MyArrayList implements IList {
    private int[] elements;
    private int currentSize;
    private static final int DEFAULT_CAPACITY = 5;

    public MyArrayList() {
        elements = new int[DEFAULT_CAPACITY];
    }
}

2.3 리스트 출력

@Override
public void display() {
    for (int i = 0; i < this.currentSize; i++) {
        System.out.print(elements[i] + " ");
    }
    System.out.println();
}

2.4 요소 추가

@Override
public void append(int data) {
    if (isFull()) {
        elements = Arrays.copyOf(elements, elements.length * 2);
    }
    elements[currentSize++] = data;
}

@Override
public boolean isFull() {
    return currentSize == elements.length;
}

2.5 특정 위치에 요소 삽입

@Override
public void insertAt(int pos, int data) {
    checkPosition(pos);
    if (isFull()) {
        elements = Arrays.copyOf(elements, elements.length * 2);
    }
    for (int i = currentSize - 1; i >= pos; i--) {
        elements[i + 1] = elements[i];
    }
    elements[pos] = data;
    currentSize++;
}

private void checkPosition(int pos) {
    if (pos < 0 || pos > currentSize) {
        throw new IllegalArgumentException("Invalid position: " + pos);
    }
}

2.6 요소 포함 여부 확인

@Override
public boolean contains(int toFind) {
    for (int i = 0; i < currentSize; i++) {
        if (elements[i] == toFind) {
            return true;
        }
    }
    return false;
}

2.7 요소 인덱스 찾기

@Override
public int findIndex(int toFind) {
    for (int i = 0; i < currentSize; i++) {
        if (elements[i] == toFind) {
            return i;
        }
    }
    return -1;
}

2.8 특정 위치의 값 가져오기

@Override
public int retrieveAt(int pos) {
    checkPosition(pos);
    if (isEmpty()) {
        throw new IllegalStateException("List is empty");
    }
    return elements[pos];
}

private void checkPosition(int pos) {
    if (pos < 0 || pos >= currentSize) {
        throw new IllegalArgumentException("Invalid position: " + pos);
    }
}

@Override
public boolean isEmpty() {
    return currentSize == 0;
}

2.9 특정 위치의 값 업데이트

@Override
public void updateAt(int pos, int value) {
    checkPosition(pos);
    if (isEmpty()) {
        System.out.println("List is empty");
    } else {
        elements[pos] = value;
    }
}

2.10 요소 삭제

@Override
public void delete(int toRemove) {
    if (isEmpty()) {
        throw new IllegalStateException("List is empty");
    }
    int index = findIndex(toRemove);
    for (int i = index; i < currentSize - 1; i++) {
        elements[i] = elements[i + 1];
    }
    currentSize--;
}

2.11 리스트 크기 반환

@Override
public int length() {
    return currentSize;
}

2.12 리스트 비우기

@Override
public void empty() {
    currentSize = 0;
}

3. ArrayList 사용 예제

3.1 ArrayList 생성

public static void main(String[] args) {
    List<Integer> list1 = new ArrayList<>();
    List<Integer> list2 = new ArrayList<>(10);
    list2.add(1);
    list2.add(2);
    list2.add(3);

    ArrayList<Integer> list3 = new ArrayList<>(list2);
}

3.2 ArrayList 기본 연산

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("JavaSE");
    list.add("JavaWeb");
    list.add("JavaEE");

    System.out.println(list.get(1)); // 특정 위치의 요소 가져오기
    list.set(1, "JavaWEB"); // 특정 위치의 요소 변경
    list.add(1, "JavaDataStructures"); // 특정 위치에 요소 삽입
    list.remove("JVM"); // 특정 요소 삭제
    list.remove(list.size() - 1); // 마지막 요소 삭제
    System.out.println(list.contains("JavaSE")); // 요소 포함 여부 확인
    System.out.println(list.indexOf("JavaSE")); // 요소의 첫 번째 인덱스 반환
    System.out.println(list.lastIndexOf("JavaSE")); // 요소의 마지막 인덱스 반환
    List<String> subList = list.subList(0, 4); // 부분 리스트 반환
    list.clear(); // 리스트 비우기
}

3.3 ArrayList 반복 처리

ArrayList는 여러 방법으로 순회할 수 있습니다:

public static void main(String[] args) {
    ArrayList<Integer> arrayList = new ArrayList<>();
    arrayList.add(10);
    arrayList.add(20);
    arrayList.add(30);

    // for문을 통한 순회
    for (int i = 0; i < arrayList.size(); i++) {
        System.out.print(arrayList.get(i) + " ");
    }

    // foreach문을 통한 순회
    for (int x : arrayList) {
        System.out.print(x + " ");
    }

    // Iterator를 사용한 순회
    Iterator<Integer> it = arrayList.iterator();
    while (it.hasNext()) {
        System.out.print(it.next() + " ");
    }
}