[6/8 TIL] JAVA(Collection, Iterator, Stream, Optional)

🍃프로그래머스 백엔드 데브코스 4기 교육과정을 듣고 정리한 글입니다.🍃

Collection

List

• List 인터페이스는 순서가 있는 데이터의 집합을 표현합니다.
• 데이터의 중복을 허용합니다.
• 구현 클래스로는 ArrayList, LinkedList 등이 있습니다.
• 인덱스를 사용하여 요소에 접근할 수 있습니다.

Set

• Set 인터페이스는 순서가 없는 고유한 데이터의 집합을 표현합니다.
• 데이터의 중복을 허용하지 않습니다.
• 구현 클래스로는 HashSet, TreeSet 등이 있습니다.
• 해시 기반 또는 정렬된 순서로 요소를 저장하고 관리합니다.

Map

• Map 인터페이스는 키와 값으로 이루어진 데이터의 집합을 표현합니다.
• 키-값 쌍으로 데이터를 저장하고 관리합니다.
• 키는 고유해야 하며, 값은 중복이 가능합니다.
• 구현 클래스로는 HashMap, TreeMap, LinkedHashMap 등이 있습니다.

Queue

• Queue 인터페이스는 선입선출(FIFO) 형태의 데이터 구조를 표현합니다.
• 데이터의 삽입은 한쪽 끝에서, 삭제는 다른 한쪽 끝에서 이루어집니다.
• 구현 클래스로는 LinkedList, PriorityQueue 등이 있습니다.

Stack

• Stack 클래스는 후입선출(LIFO) 형태의 데이터 구조를 표현합니다.
• 데이터의 삽입과 삭제가 같은 쪽에서 이루어집니다.
• 주요 메서드로는 push(), pop(), peek() 등이 있습니다.

Iterator

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Iterator를 사용하여 컬렉션의 요소에 접근
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }

        // Iterator를 사용하여 특정 조건의 요소 삭제
        iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            if (fruit.equals("Banana")) {
                iterator.remove(); // 현재 요소 삭제
            }
        }

        System.out.println(fruits); // 출력: [Apple, Orange]
    }
}

• 컬렉션의 요소를 순차적으로 접근할 수 있습니다.
  • hasNext() 메소드를 통해 다음 요소의 존재 여부를 확인하고, next() 메소드를 호출하여 다음 요소를 얻습니다.
• 요소를 안전하게 삭제할 수 있습니다.
  • Iterator를 통해 remove() 메소드를 호출하면 현재 요소를 삭제합니다.
• Iterator는 자바의 모든 컬렉션 인터페이스에서 사용할 수 있습니다.

Stream

• 자바 8부터 도입된 Stream은 데이터의 흐름을 나타내며, 컬렉션에 저장된 요소들을 다양한 연산을 통해 처리합니다.
• 병렬 스트림을 사용하면, 데이터를 병렬적으로 처리하여 성능을 향상시킬 수 있습니다.
• Stream은 한 번 사용한 후에는 재사용할 수 없습니다.
• 중간 연산과 최종 연산으로 구분됩니다.
  • 중간 연산은 데이터를 변환하거나 필터링하는 작업입니다.
  • 최종 연산은 결과를 반환합니다.

중간 연산

filter(Predicate<T> predicate)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());

// 결과 출력
System.out.println(evenNumbers); // [2, 4]

• 주어진 조건에 맞는 요소들로 구성된 새로운 Stream을 반환합니다.

map(Function<T, R> mapper)

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<Integer> nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());

// 결과 출력
System.out.println(nameLengths); // [5, 3, 7]

• 요소를 다른 요소로 변환하여 새로운 Stream을 반환합니다.

distinct()

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 5, 5);

List<Integer> distinctNumbers = numbers.stream()
                                       .distinct()
                                       .collect(Collectors.toList());

// 결과 출력
System.out.println(distinctNumbers); // [1, 2, 3, 4, 5]

• 중복된 요소를 제거한 새로운 Stream을 반환합니다.

sorted()

List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);

List<Integer> sortedNumbers = numbers.stream()
                                     .sorted()
                                     .collect(Collectors.toList());

// 결과 출력
System.out.println(sortedNumbers); // [1, 2, 3, 4, 5]

• 요소를 정렬한 새로운 Stream을 반환합니다.

limit(long maxSize)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> limitedNumbers = numbers.stream()
                                      .limit(3)
                                      .collect(Collectors.toList());

// 결과 출력
System.out.println(limitedNumbers); // [1, 2, 3]

• 요소의 개수를 maxSize만큼 갖는 새로운 Stream을 반환합니다.

최종 연산

forEach(Consumer<T> action)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.stream()
       .forEach(System.out::println); // 결과 출력: 각 숫자가 한 줄씩 출력됨

• Stream의 각 요소에 대해 주어진 동작을 수행합니다.

collect(Collector<T, A, R> collector)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

String concatenatedNumbers = numbers.stream()
                                    .map(Object::toString)
                                    .collect(Collectors.joining(", "));

// 결과 출력
System.out.println(concatenatedNumbers); // "1, 2, 3, 4, 5"

• Stream의 요소를 수집하여 컬렉션 또는 다른 형태로 결과를 반환합니다.

reduce(BinaryOperator<T> accumulator)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 모든 숫자의 합 구하기
Optional<Integer> sum = numbers.stream()
                               .reduce((a, b) -> a + b);

// 결과 출력
System.out.println(sum.orElse(0)); // 15

• Stream의 요소들을 반복적으로 조합하여 최종 결과를 Optional로 반환합니다.

count()

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 요소의 개수 세기
long count = numbers.stream()
                   .count();

// 결과 출력
System.out.println(count); // 5

• Stream의 요소의 개수를 반환합니다.

anyMatch(Predicate<T> predicate)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

boolean anyEvenNumber = numbers.stream()
                               .anyMatch(n -> n % 2 == 0);

// 결과 출력
System.out.println(anyEvenNumber); // true

• Stream의 요소 중 조건을 만족하는 요소가 하나라도 존재하면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

allMatch(Predicate<T> predicate)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

boolean allGreaterThanZero = numbers.stream()
                                   .allMatch(n -> n > 0);

// 결과 출력
System.out.println(allGreaterThanZero); // true

• Stream의 모든 요소가 조건을 만족하면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

noneMatch(Predicate<T> predicate)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

boolean noneGreaterThanFive = numbers.stream()
                                     .noneMatch(n -> n > 5);

// 결과 출력
System.out.println(noneGreaterThanFive); // true

• Stream의 모든 요소가 조건을 만족하지 않으면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

findFirst()

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

Optional<Integer> firstEvenNumber = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .findFirst();

// 결과 출력
System.out.println(firstEvenNumber.orElse(-1)); // 2

• Stream의 첫 번째 요소를 Optional로 반환합니다.
• 스트림의 요소가 정렬되어 있지 않거나, 특정한 요소를 찾는 것이 아니라면 일반적으로 findAny() 함수를 사용하는 것이 좋습니다.

findAny()

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

Optional<Integer> anyNumber = numbers.stream()
                                     .findAny();

// 결과 출력
System.out.println(anyNumber.orElse(-1)); // 1 or 2 or 3 or 4 or 5 (랜덤)

• Stream에서 임의의 요소를 Optional로 반환합니다.
• 스트림의 요소가 정렬되어 있고 첫 번째 요소를 찾아야 하는 경우에는 findFirst() 함수를 사용하는 것이 좋습니다.

Optional

public class Main {
    public static void main(String[] args) {
        String name = "John";
        Optional<String> optionalName = Optional.of(name);  // 값이 있는 Optional 생성

        // 존재 여부 확인
        boolean isEmpty = optionalName.isEmpty();
        boolean isPresent = optionalName.isPresent();

        // 값 가져오기
        String retrievedName = optionalName.get();

        // 기본값 설정
        String defaultValue = optionalName.orElse("Default");
        String defaultValueFromSupplier = optionalName.orElseGet(() -> "Default");

        // 함수형 스타일의 연산
        optionalName.map(String::toUpperCase)
                    .ifPresent(System.out::println);  // 결과 출력: JOHN
    }
}

• Optional은 자바 8부터 도입된 값을 감싸고 있는 래퍼 클래스로, null을 안전하게 처리하기 위한 기능을 제공합니다.
• null 대신에 Optional.empty()를 사용하며, NullPointException(NPE)를 방지합니다.
• isEmpty() 또는 IsPresent() 메소드를 사용하여 Optional이 값을 가졌는지 확인할 수 있습니다.
• get()메소드를 사용하면 Optional이 감싸고 있는 값을 가져올 수 있지만, 값이 없는 경우 NoSuchElementException이 발생하므로 먼저 값이 있는지 확인해야 합니다.
• Optional에 값이 없을 때 OrElse()나 orElseGet()로 기본값을 설정하거나 orElseThrow()로 예외를 발생시킬 수 있습니다.
• 맵(Map)이나 필터(Filter) 등의 함수형 스타일 연산을 제공합니다.