[Stream API] 스트림 중간연산 (1/3)

스트림의 중간연산!

 

1. 스트림 자르기 - skip(), limit()

스트림의 일부를 잘라낼 때 사용

Stream<T> skip (long n)
Stream<T> limit (long maxSize)

// 기본형 스트림
IntStream skip(long n)
IntStream limit(long maxSize)

// 사용 예시
IntStream intStream = IntStream.rangeClosed(1, 10); // 1~10 값을 가지는 intStream

// 상위 3개의 요소를 스킵하고, 그다음 5개 요소만 제한을 걸어 출력!
intStream.skip(3).limit(5).forEach(System.out::print); // 출력 결과 : 45678

 

 

 

2. 스트림의 요소 걸러내기 - filter(), distinct()

distinct() : 중복제거
filter() : 주어진 조건(Predicate)에 맞지 않는 요소만 가져옴

 

Stream<T> filter(Predicate<? super T> predicate)
Stream<T> distinct()

// distinct() 사용 예시
IntStream intStream = IntStream.of(1,2,2,3,3,3,4,5,5,6);
intStream.distinct().forEach(System.out::print); // 123456

// filter() 사용 예시
IntStream intStream = IntStream.rangeClosed(1,10);

// 짝수인 경우만 출력
intStream.filter(i -> i % 2 == 0).forEach(System.out::print); // 246810

// filter()는 여러번 사용 가능 마치 sql의 where 조건을 열거하는 느낌
intStream.filter(i -> i%2!=0).filter(i->i%3!=0).forEach(System.out::print);

 

 

 

* Predicate : 하나의 인수를 받고 boolean 값을 반환하는 함수형 인터페이스, 람다식 이용 가능!

- 간단히 설명하면 람다식을 작성해 비교 연산을 수행 후 반환값으로 true, false를 가짐

@FunctionalInterface
public interface Predicate<T> {

// Preicate는 아래와 같이 단일 메서드를 정의
    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }


    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }


    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

 

 

3. 정렬 - sorted()

스트림 정렬 시 사용

Stream<T> sorted()
Stream<T> sorted(Comprator<? super T> comparator)

// 사용 예시
Strema<String> strStream = Stream.of("dd", "aaa", "CC", "cc", "b");
strStream.sorted().forEach(System.out::print); // 출력 결과 : CCaaabccdd

 

 

 

* 문자열 스트림 정렬 방법

문자열 스트림 정렬	출력결과
// 기본정렬 strStream.sorted() strStream.sorted(Comparator.naturalOrder()) strStream.sorted((s1, s2) -> s1.compareTo(s2)) strStream.sorted(String::compareTo)	CCaaabccdd
// 기본정렬 역순 strStream.sorted(Comparator.reverseOrder()) strStream.sorted(Comparator.<String>naturalOrder().reversed())	ddccbaaaCC
// 대소문자 구분 X strStream.sorted(String.CASE_INSENSITIVE_ORDER)	aaabCCccdd
// 대소문자 구분 X 역순 strStream.sorted(String.CASE_INSENSITIVE_ORDER).reversed())	ddCCccbaaa
// 길이순 정렬 strStream.sorted(Comparator.comparing(String::length)) strStream.sorted(Comparator.comparingInt(String::length))	bddCCccaaa
// 길이순 정렬 역순 strStream.sorted((Comparator.comparing(String::length).reversed())	aaaddCCccb

 

 

3-1. Comparable 인터페이스와 Comparator 인터페이스

1) Comparable Interface

Comparable 인터페이스는 객체의 순서를 정의하는 데 사용
클래스가 Comparable 인터페이스를 구현하면, 해당 클래스의 인스턴스들은 서로 비교가 가능

인터페이스에는 compareTo(T o)라는 하나의 메서드가 정의되어 있음.

이 메서드는 객체 자신(this)을 인수로 전달된 객체(o)와 비교

• 현재 객체가 주어진 객체보다 "작을 때" : 음수를 반환
• 현재 객체와 주어진 객체가 "같을 때" : 0을 반환
• 현재 객체가 주어진 객체보다 "클 때" : 양수를 반환

 

public interface Comparable<T>{

	public int compareTo(T o);

}

 

'Comparable' 인터페이스를 구현한 객체는 'Arrays.sort()', 'Collection.sort()'와 같은 정렬 메서드를 사용할 때 객체에 정의한 순서대로 정렬됨(CompareTo 에서 정의한 순서)

import java.util.Arrays;

// Person 클래스는 Comparable을 구현해야 합니다.
public class Person implements Comparable<Person> {
    private int age;

    public Person(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }


    public static void main(String[] args) {
        // Person 객체의 배열을 생성합니다.
        Person[] people = {new Person(25), new Person(20)};

        // Comparable 인터페이스의 구현에 따라 Person 객체들을 정렬합니다.
        Arrays.sort(people);

    }
}

 

 

 

2) Comparator Interface

Comparator 인터페이스는 주어진 객체의 비교 순서를 외부에서 정의할 때 사용.
Comparable과 달리 별도의 클래스로 구현됨.
int compare(T o1, T o2) : 두 객체 o1, o2를 비교

• o1 객체 < o2 객체 : 음수 반환
• o1 객체 = o2 객체 : 0 반환
• o1 객체 > o2 객체 : 양수 반환

 

public class AgeComparator implements Comparator<Person> {

    @Override
    public int compare(Person a, Person b) {
        return Integer.compare(a.getAge(), b.getAge());
    }
    
}

 

※ Comparator와 Comparable 차이점

Comparable은 객체의 자연적인 순서를 내부적으로 정의하는 데 사용되고, 
Comparator 는 외부에서 별도의 순서를 정의할 때 사용됩니다.