[JAVA] Stream / 중간연산

기존 자바 컬렉션이나 배열의 원소를 가공할때 for문 foreach 등으로 원소 하나씩을 골라내어 가공했다면
stream을 이용하여 람다함수식으로 간결하고 깔끔하게 요소들의 처리가 가능하다.

 

스트림은 생성 , 중간연산 , 최종연산으로 나뉜다.

- 생성 
스트림은 한번 사용 후
생성한 스트림이 폐기되기때문에 다른곳에서 다시 사용할 땐 한번 더 생성 해주어야 한다.

---

- 중간연산 (여러번 사용가능) 

filter() : 요소 정제 - 거르기
 Stream에서 조건에 맞는 데이터만을 정제하여 더 작은 컬렉션을 만들어 낸다.
 filter() 메서드에서는 매개 값으로 조건(Predicate)이 주어지고, 조건이 참이 되는 요소만 필터링한다.

distinct() : 중복제거 
 Stream의 요소들에 중복된 데이터가 존재하는 경우, 중복을 제거하기 위해 사용한다.

public class FilteringExample {
    public static void main(String[] args) throws Exception {
        List<String> names = Arrays.asList("김코딩", "이자바", "김인기", "김코딩");

        names.stream()
                .distinct() //중복제거
                .forEach(n -> System.out.println(n));
        System.out.println();

        names.stream()
                .filter(n -> n.startsWith("김")) //필터링
                .forEach(n -> System.out.println(n));
        System.out.println();

        names.stream()
                .distinct() //중복제거
                .filter(n -> n.startsWith("김")) //필터링
                .forEach(n -> System.out.println(n));
    }
}

//출력 결과
김코딩
이자바
김인기

김코딩
김인기
김코딩

김코딩
김인기

 

map() : 기존의 요소들로 새로운 요소로 변환
 map()은 기존 Stream요소들을 주어진 함수에 전달하여, 그 반환 값들로 구성된 새로운 Stream을 형성하는 연산

flatMap() : 2차원 배열일 경우 하나의 배열로 만들어준다.
 map()과 유사하다. 스트림 요소가 만약 배열이라면 flatMap을 사용하여 배열의 각 요소의 반환값을 하나로 합친 스트림을 얻을 수 있다. 

List<String> names = Arrays.asList("kimcoding", "javalee", "ingikim", "kimcoding");
        names.stream()
        	.map(s -> s.toUpperCase()) // 요소들을 대문자로 대치
       	        .forEach(n->System.out.println(n));
/*
KIMCODING
JAVALEE
INGIKIM
KIMCODING

limit() : 뒷부분 생략
  limit() 메서드는 해당 스트림의 첫 번째 요소부터 전달된 개수만큼의 요소만으로 이루어진 새로운 스트림을 반환

stream.limit(4).forEach(n-> System.out.print(n + " "))
//결과 0~ 10까지 스트림이라 했을 때 0,1,2,3 출력

skip() : 앞부분 생략  
 skip() 메서드는 첫 번째 요소부터 전달될 개수만큼의 요소를 제외한 나머지 요소로 이루어진 새로운 스트림 반환

stream.skip(4).forEach(n-> System.out.print(n + " ")) 
// 0~ 10까지 스트림이라 했을 때 5,6,7,8,9,10 출력

 

sort() : 정렬 
 Stream의 요소들을 정렬하기 위해서 사용한다.
 ex) stream.sorted().forEach( n -> System.out.print(n + " ")) 오름차순
 ex) stream.sorted(Comparator.reverseOrder()).forEach(n-> System.out.print(n + " ")) 
                                //Comparator.reverseOrder() 를 sorted()에 넣어주면 내림차순

peek() : 확인 (연산 중간 디버깅을 위한 메서드)
  peek() 메서드는 forEach()와 동일하게 하나씩 돌면서 출력하는 기능을 가지고 있지만, peek ( ) 메서드는 중간
  연산 메서드이고, forEach()는 최종 연산 메서드이다. 주로 연산 중간에 디버깅을 위한 메서드
  ex) stream.peek(n-> System.out.print(n + " "))     

List<String> list = Arrays.asList("Java", "Scala", "Groovy", "Python", "Go", "Swift");

        list.stream()
            .sorted() // 오름차순 정렬
            .forEach(n -> System.out.println(n));
        System.out.println();

/*
Go, Groovy, Java, Python, Scala, Swift
*/
        list.stream()
            .sorted(Comparator.reverseOrder()) // 내림차순 정렬
            .forEach(n -> System.out.println(n));

/*
Swift, Scala, Python, Java, Groovy, Go
*/

class Employee implements Comparable<Employee>{
    int id;
    String name, department;

    public Employee(int id, String name, String department) {
        this.id = id;
        this.name = name;
        this.department = department;
    }

    String getName() {
        return name;
    }
    int getId() {
        return id;
    }
    String getDepartment() {
        return department;
    }
    public String toString() {
        return String.format("[%d, %s, %s]", id, name, department);
    }
    public int compareTo(Employee e) {
        return e.id - this.id;
    }

}

public class ComparatorExample {
    public static void main(String[] args) {
        Stream<Employee> workersStream =
                Stream.of(new Employee(11, "Kim Coding", "Software Engineering"),
                        new Employee(5, "Hello World", "Growth Marketing"),
                        new Employee(7, "Park Hacker", "Software Engineering"));
        workersStream.sorted(Comparator.comparing(Employee::getId)).forEach(System.out::println);

    }
}

// 출력 결과
[5, Hello World, Growth Marketing]
[7, Park Hacker, Sofrware Engineering]
[11, Kim Coding, Software Engineering]