1-2. ArrayList<>사용법 (기본 타입, 객체 배열)

개념

오로지 기본 타입 말고 래퍼 타입만 사용 가능

• 값 접근(읽기): O(1) - 인덱스를 사용하여 바로 접근 가능
• 값 삭제/삽입: O(n) - 주변에 있는 값들을 옮겨주는 오버헤드 발생. 삭제 시 뒤의 원소들을 앞으로 당김, 삽입 시 기존 원소들을 뒤로 밀어냄

ArrayList

연산 종류 정리

• 생성
• 값 접근(읽기): list.get(1);
• 값 삽입, 삭제: list.add(); list.remove();
• 리스트 크기: list.size()
• 리스트 최대,최소: Collections.max(list), Collections.min(list)
• 리스트 전체 초기화: Collections.fill(list, 값)
• 리스트 전체 출력: list.toString()
• 리스트 정렬: Collections.sort(list)

 

리스트 생성

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

// ArrayList 선언 및 초기화
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));

 

값 삽입

• 중간 삽입 방법: 기존 원소들을 뒤로 밀어냄 - O(N) 발생
• 맨 뒤 삽입 방법

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 4, 5));
list.add(2, 3);  // 인덱스 2에 '3'을 삽입 -> 결과: [1, 2, 3, 4, 5]

list.add(6);  // 리스트의 끝에 '6' 추가 -> 결과: [1, 2, 3, 4, 5, 6]

 

값 삭제

값을 삭제하면 뒤 요소들이 한칸씩 앞으로 당겨짐 - O(N) 발생

• 인덱스를 통한 삭제
• 값을 이용한 삭제

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
list.remove(2);  // 인덱스 2의 요소(값 '3') 삭제 -> 결과: [1, 2, 4, 5]

list.remove(Integer.valueOf(4));  // 값 '4' 삭제 -> 결과: [1, 2, 5]

 

 

리스트 크기

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));

list.size()  // 결과: 3

리스트 최대/최소

java.util.Collections 클래스 활용

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
int max = Collections.max(list);
int min = Collections.min(list);

리스트 전체 초기화

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

// 리스트를 1로 전체 초기화
Collections.fill(list, 1);

리스트 전체 출력

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(12, 3, 4, 5, 6, 7));

System.out.println(list.toString());
//결과: [12, 3, 4, 5, 6, 7]

리스트 정렬

java.util.Collections 클래스 함수 이용

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(3, 2, 0, 1, 4));
Collections.sort(list);  // 오름차순 정렬 -> [0, 1, 2, 3, 4]

// 내림차순 정렬
Collections.sort(list, Collections.reverseOrder());  // -> [4, 3, 2, 1, 0]

 

 

객체 배열

일반 타입이 아닌 객체를 배열에 넣는 경우 아래 연산 사용 방법이 달라진다.

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

ArrayList<Person> people = new ArrayList<>();
people.add(new Person("John", 30));
people.add(new Person("Alice", 22));
people.add(new Person("Bob", 25));

 

연산 종류

• 리스트 전체 출력: list.toString() + toString() 오버라이딩
• 객체 비교 방법 추가: Comparable 인터페이스 구현 or Comparator 제공 or Comparator 람다식 제공
  • 리스트 최대,최소: Collections.max(list), Collections.min(list)
  • 리스트 정렬: Collections.sort(list)

 

리스트 전체 출력

클래스에서 toString() 메서드에 대해서 오버라이딩을 해야한다.

class Person {
    @Override
    public String toString() {
        return name + ": " + age;
    }
}

ArrayList<Person> people = new ArrayList<>();

System.out.println(people.toString());
// 결과: [John: 30, Alice: 22, Bob: 25]

 

객체 비교 방법 추가

Comparable 인터페이스 구현 및 compareTo 메서드 오버라이딩

• 객체 내부에서 자체적으로 비교 가능
• 해당 방법을 사용하면 일반 자료형에서 사용한 방법과 동일하게 사용 가능

class Person implements Comparable<Person> {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;  // 나이를 기준으로 오름 차순 비교
    }
}

 

Comparator 구현 및 compare 메서드 오버라이딩

• 정렬 기준을 외부에서 전달하는 방법
• 해당 방법을 사용하면 각 메서드에 Comparator인자를 추가로 전달해야함
• 2가지 방법 존재:
  • Comparator를 구현을 하는 방법
  • 람다식을 이용해서 전달하는 방법이 존재

class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.age - p2.age //오름차순 비교
    }
}

 

리스트 최대, 최소

최대, 최소를 구할때는 오름차순, 내림차순 관계 없이 결과가 동일하게 나옴

ArrayList<Person> people = new ArrayList<>();

//구현한거 전달
Person youngest = Collections.min(people, new AgeComparator());
Person oldest = Collections.max(people, new AgeComparator());

//람다식 사용
Person youngest = Collections.min(people, (p1, p2) -> p1.age - p2.age);
Person oldest = Collections.max(people, (p1, p2) -> p1.age - p2.age);

 

 

리스트 정렬

// 나이에 따라 오름차순 정렬
Collections.sort(people, (p1, p2) -> p1.age - p2.age);

// 나이에 따라 내림차순 정렬
Collections.sort(people, (p1, p2) -> p2.age - p1.age);