람다 활용, 필터 만들기, 맵 만들기, 필터와 맵 활용, 스트림 만들기

필터 만들기

FilterMainV1 - 람다 미사용

package lambda.lambda5.filter;

public class FilterMainV1 {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 짝수만 거르기
        List<Integer> evenNumbers = filterEvenNumber(numbers);
        System.out.println("evenNumbers = " + evenNumbers);

        // 홀수만 거르기
        List<Integer> oddNumbers = filterOddNumber(numbers);
        System.out.println("oddNumbers = " + oddNumbers);

    }

    private static List<Integer> filterEvenNumber(List<Integer> numbers) {
        List<Integer> filtered = new ArrayList<>();

        for (Integer number : numbers) {
            if (number % 2 == 0) {
                filtered.add(number);
            }
        }
        return filtered;
    }

    private static List<Integer> filterOddNumber(List<Integer> numbers) {
        List<Integer> filtered = new ArrayList<>();

        for (Integer number : numbers) {
            if (number % 2 == 1) {
                filtered.add(number);
            }
        }
        return filtered;
    }
}

/* 실행 결과
evenNumbers = [2, 4, 6, 8, 10]
oddNumbers = [1, 3, 5, 7, 9]
*/

• 람다를 사용하지 않고 filterEvenNumber(), filterOddNumber() 각각 두 메서드를 만들어서 짝수만 거르기, 홀수만 거르기 문제를 해결하는 코드

FilterMainV2 - 람다 활용

package lambda.lambda5.filter;

    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 짝수만 거르기
        List<Integer> evenNumbers = filter(numbers, n -> n % 2 == 0);
        System.out.println("evenNumbers = " + evenNumbers);

        // 홀수만 거르기
        List<Integer> oddNumbers = filter(numbers, n -> n % 2 == 1);
        System.out.println("oddNumbers = " + oddNumbers);

    }

    private static List<Integer> filter(List<Integer> numbers, Predicate<Integer> predicate) {
        List<Integer> filtered = new ArrayList<>();
        for (Integer number : numbers) {
            if (predicate.test(number)) {
                filtered.add(number);
            }
        }
        return filtered;
    }
}
/* 실행 결과는 동일 */

• 람다를 활용하여 앞서 작성한 filterEvenNumber(), filterOddNumber() 두 메서드 대신에 filter()라는 하나의 메서드만 사용하여 중복을 제거하였음
• Predicate<Integer>를 filter()에 인자로 넘긴 후 predicate.test(number)를 사용하여 넘긴 코드 조각을 filter()안에서 실행함
  • 짝수: filter(numbers, n -> n % 2 == 0);, 홀수:  filter(numbers, n -> n % 2 != 0);
  • 메서드 내부에서 for 루프를 통해 리스트 안에 있는 각각의 항목에 람다가 모두 적용되어 결과가 참이면 새로운 리스트에 담기고 거짓이며 새로운 리스트에 담기지 않음

IntegerFilter - 유틸리티 클래스로 분리

package lambda.lambda5.filter;

public class IntegerFilter {
    public static List<Integer> filter(List<Integer> list, Predicate<Integer> predicate) {
        List<Integer> filtered = new ArrayList<>();
        for (Integer num : list) {
            if (predicate.test(num)) {
                filtered.add(num);
            }
        }
        return filtered;
    }
}

• 앞서 만든 filter() 메서드는 매개변수가 Predicate이므로 모든 곳에서 사용할 수 있으므로 별도의 유틸리티 클래스로 만들 수 있음

FilterMainV3 - IntegerFilter 사용

package lambda.lambda5.filter;

public class FilterMainV3 {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 짝수만 거르기
        List<Integer> evenNumbers = IntegerFilter.filter(numbers, n -> n % 2 == 0);
        System.out.println("evenNumbers = " + evenNumbers);

        // 홀수만 거르기
        List<Integer> oddNumbers = IntegerFilter.filter(numbers, n -> n % 2 == 1);
        System.out.println("oddNumbers = " + oddNumbers);

    }

}

• 이렇게 별도의 유틸리티 클래스로 만든 IntegerFilter를 사용할 수 있으며 필요에 따라 static import를 하면 더욱 간편하게 사용할 수 있음
• 하지만 Integer 숫자에만 사용할 수 있는 한계가 있음

GenericFilter - 제네릭 도입

package lambda.lambda5.filter;

public class GenericFilter {
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> filtered = new ArrayList<>();
        for (T t : list) {
            if (predicate.test(t)) {
                filtered.add(t);
            }
        }
        return filtered;
    }
}

• <T>를 선언하고 Integer로 되어있는 부분을 T로 변경하면 됨
• 기존에 num 변수로 되어있던 부분을 모든 타입이 다 들어올 수 있다는 뜻으로 소문자 t로 변경하였음

FilterMainV4 - GenericFilter 활용

package lambda.lambda5.filter;

public class FilterMainV4 {
    public static void main(String[] args) {

        // 숫자 사용 필터 - 짝수만 꺼내기
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> evenNumbers = GenericFilter.filter(numbers, n -> n % 2 == 0);
        System.out.println("evenNumbers = " + evenNumbers);

        // 문자 사용 필터 - 길이가 2이상인 문자 꺼내기
        List<String> strings = List.of("A", "BB", "CCC");
        List<String> stringResult = GenericFilter.filter(strings, s -> s.length() >= 2);
        System.out.println("stringResult = " + stringResult);

    }

}
/* 실행 결과
evenNumbers = [2, 4, 6, 8, 10]
stringResult = [BB, CCC]
*/

• 제네릭을 도입한 덕분에 Integer, String 같은 다양한 타입의 리스트에 필터링 기능을 사용할 수 있게 되었음
• GenericFilter는 제네릭을 사용하기 때문에 제네릭을 사용할 수 있는 모든 타입의 리스트를 람다 조건으로 필터링할 수 있어 매우 유연한 필터링 기능을 제공함

맵 만들기

Map

맵(map)은 대응, 변환을 의미하는 매핑(mapping)의 줄임말고 어떤 것을 다른 것으로 변환하는 과정을 의미함

프로그래밍에서는 각 요소를 다른 값으로 변환하는 작업을 매핑(mapping, map)이라 하며 어떤 하나의 데이터를 다른 데이터로 변환하는 작업이라고 생각하면 됨

 

MapMainV1 - 람다 미사용

package lambda.lambda5.map;

public class MapMainV1 {
    public static void main(String[] args) {
        List<String> list = List.of("1", "12", "123", "1234");

        // 문자열을 숫자로 변환
        List<Integer> numbers = mapStringToInteger(list);
        System.out.println("numbers = " + numbers);

        // 문자열의 길이를 반환
        List<Integer> lengths = mapStringToLength(list);
        System.out.println("lengths = " + lengths);
    }

    private static List<Integer> mapStringToInteger(List<String> list) {
        List<Integer> result = new ArrayList<>();
        for (String s : list) {
            Integer value = Integer.valueOf(s);
            result.add(value);
        }
        return result;
    }

    private static List<Integer> mapStringToLength(List<String> list) {
        List<Integer> result = new ArrayList<>();
        for (String s : list) {
            int length = s.length();
            result.add(length);
        }
        return result;
    }
}
/* 실행 결과
numbers = [1, 12, 123, 1234]
lengths = [1, 2, 3, 4]
*/

• 문자열로 이루어진 List의 값을 람다를 사용하지 않고 다른 값으로 매핑하는 코드로 mapStringToInteger(), mapStringToLength() 두 메서드를 만들어서 문제를 해결하였음
• 문자열을 숫자로 변환: String -> Integer
  • 리스트에 있는 문자 "1", ... "1234"를 숫자(Integer) 1, ... 1234로 변환함
• 문자열을 문자열의 길이로 변환: String -> Integer
  • 리스트에 있는 문자 "1", ... "1234"를 각 문자의 길이인 1, ... 4로 변환함

MapMainV2 - 람다 사용

package lambda.lambda5.map;

public class MapMainV2 {
    public static void main(String[] args) {
        List<String> list = List.of("1", "12", "123", "1234");

        // 문자열을 숫자로 변환
        List<Integer> numbers = map(list, s -> Integer.valueOf(s));
        System.out.println("numbers = " + numbers);

        // 문자열의 길이를 반환
        List<Integer> lengths = map(list, s -> s.length());
        System.out.println("lengths = " + lengths);
    }

    private static List<Integer> map(List<String> list, Function<String, Integer> mapper) {
        List<Integer> result = new ArrayList<>();
        for (String s : list) {
            Integer value = mapper.apply(s);
            result.add(value);
        }
        return result;
    }
}
/* 실행 결과 동일 */

• Function<String, Integer>를 map()에 인자로 넘겨서 중복을 제거함
  • 문자열을 숫자로: s -> Integer.valueOf(s)
  • 문자열을 길이로: s -> s.length()
• Integer value = mapper.apply(s)를 사용하여 넘긴 코드 조각을 map()안에서 실행하여 for 루프를 통해 리스트 안에 있는 각각의 항목에 람다가 모두 적용되어 String이 람다를 통해 Integer로 변환됨

StringToIntegerMapper - 별도의 유틸리티 클래스로 만들기

package lambda.lambda5.map;

public class StringToIntegerMapper {
    public static List<Integer> map(List<String> list, Function<String, Integer> mapper) {
        List<Integer> result = new ArrayList<>();
        for (String s : list) {
            Integer value = mapper.apply(s);
            result.add(value);
        }
        return result;
    }
}

• 필터에서 했던 것과 마찬가지로 private 메서드를 별도의 유틸 클래스로 만들어서 활용할 수 있음

MapMainV3 - StringToIntegerMapper 활용

package lambda.lambda5.map;

public class MapMainV3 {
    public static void main(String[] args) {
        List<String> list = List.of("1", "12", "123", "1234");

        // 문자열을 숫자로 변환
        List<Integer> numbers = StringToIntegerMapper.map(list, s -> Integer.valueOf(s));
        System.out.println("numbers = " + numbers);

        // 문자열의 길이를 반환
        List<Integer> lengths = StringToIntegerMapper.map(list, s -> s.length());
        System.out.println("lengths = " + lengths);
    }

}

• 유틸 클래스로 만든 StringToIntegerMapper.map()을 활용하면 동일한 결과를 매우 깔끔하게 얻을 수 있음
• 하지만 해당 유틸 클래스는 필터에서 확인해봤듯이 타입이 고정되어있기 때문에 String -> Integer 변환만 가능함

GenericMapper - 제네릭 도입

package lambda.lambda5.map;

public class GenericMapper {
    public static <T, R>List<R> map(List<T> list, Function<T, R> mapper) {
        List<R> result = new ArrayList<>();
        for (T s : list) {
            R value = mapper.apply(s);
            result.add(value);
        }
        return result;
    }
}

• 제네릭 <T, R>을 선언하고 입력값이였던 String을 T로 바꾸고 반환값이였던 Integer를 R로 모두 변경하면 됨
  • T: 입력, R: 출력(반환)

MapMainV4 - GenericMapper 활용

package lambda.lambda5.map;

import java.util.List;

public class MapMainV4 {
    public static void main(String[] args) {
        List<String> fruits = List.of("apple", "banana", "orange");

        // String -> String
        List<String> upperFruits = GenericMapper.map(fruits, s -> s.toUpperCase());
        System.out.println(upperFruits);

        // String -> Integer
        List<Integer> lengthFruits = GenericMapper.map(fruits, s -> s.length());
        System.out.println(lengthFruits);

        // Integer -> String
        List<Integer> integers = List.of(1, 2, 3);
        List<String> starList = GenericMapper.map(integers, n -> "*".repeat(n));
        System.out.println(starList);
    }
}
/* 실행 결과
[APPLE, BANANA, ORANGE]
[5, 6, 6]
[*, **, ***]
*/

• 제네릭을 도입한 덕분에 다양한 타입의 리스트의 값을 변환(매핑) 할 수 있게 되었으며 GenericMapper는 제네릭을 사용할 수 있는 모든 타입의 리스트를 람다 조건으로 변환이 가능하므로 매우 유연한 매핑 기능을 제공함

** 참고 - String.repeat(int count)

• 자바 11에서 추가된 메서드로 같은 문자를 인자의 수 만큼 붙여서 반환함
• "hello".repeat(2): hello가 2만큼 붙여서 반환되어 "hellohello"가 반환됨

필터와 맵 활용

프로그래밍을 할 때 filter와 map을 활용해야하는 상황이 매우 빈번하게 발생함

필터와 맵 활용 - 문제1

문제

• 아래의 예시 코드를 참고하여 제시하는 문제를 해결
• 리스트에 있는 값 중에 짝수만 남기고 남은 짝수 값의 2배를 반환
• direct(): 앞서 작성한 작성한 유틸리티를 사용하지 말고 for, if등으로 코드를 직접 작성
• lambda(): 앞서 작성한 필터와 맵 유틸리티를 사용해서 코드를 작성

package lambda.mystream;

public class Ex1_Number {
    public static void main(String[] args) {
        // 짝수만 남기고 남은 값의 2배를 반환
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);

        List<Integer> directResult = direct(numbers);
        System.out.println("directResult = " + directResult);

        List<Integer> lambdaResult = lambda(numbers);
        System.out.println("lambdaResult = " + lambdaResult);

    }

    static List<Integer> direct(List<Integer> numbers) {
        // TODO: 코드 작성
        return null;
    }

    static List<Integer> lambda(List<Integer> numbers) {
        // TODO: 코드 작성
        return null;
    }


}

 

실행 결과

directResult = [4, 8, 12, 16, 20]
lambdaResult = [4, 8, 12, 16, 20]

 

해결 - Ex1_Number

package lambda.mystream;

public class Ex1_Number {
    public static void main(String[] args) {
        // 짝수만 남기고 남은 값의 2배를 반환
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);

        List<Integer> directResult = direct(numbers);
        System.out.println("directResult = " + directResult);

        List<Integer> lambdaResult = lambda(numbers);
        System.out.println("lambdaResult = " + lambdaResult);

    }

    static List<Integer> direct(List<Integer> numbers) {
        List<Integer> result = new ArrayList<>();
        for (Integer number : numbers) {
            if (number % 2 == 0) {
                result.add(number * 2);
            }
        }
        return result;
    }

    static List<Integer> lambda(List<Integer> numbers) {
        List<Integer> filteredList = GenericFilter.filter(numbers, n -> n % 2 == 0);
        List<Integer> mappedList = GenericMapper.map(filteredList, n -> n * 2);
        return mappedList;
    }

}

 

• direct()와 lambda()는 서로 다른 프로그래밍 스타일을 보여줌
• direct()는 프로그램을 어떻게 수행해야 하는지 수행 절차를 명시함
  • 개발자가 로직 하나하나를 어떻게 실행해야 하는지 명시함
  • 이런 프로그래밍 방식을 명령형 프로그래밍이라고 하며 이러한 명령형 스타일은 익숙하고 직관적이지만 로직이 복잡해질수록 반복 코드가 많아질 수 있음
• lambda()는 무엇을 수행해야 하는지 원하는 결과에 초점을 맞춤
  • 특정 조건으로 필터하고 변환하라고 선언하면 구체적인 부분은 내부에서 수행되어 개발자가 무엇을 해야 하는가(필터링을 해야할까, 변환을 해야할까)에 대해 초점을 맞춤
    • 실제 어떻게 for문과 if문 등을 사용해서 필터하고 변환할지를 개발자가 크게 신경쓰지 않음
  • 이러한 프로그래밍 방식을 선언적 프로그래밍이라고 하며 이러한 선언형 스타일은 무엇을 하고자 하는지가 명확히 드러나기 때문에 코드 가독성과 유지보수가 쉬워짐
    • 여기서는 필터하고 변환하는 것에만 초점을 맞추며 실제 어떻게 필터링하고 변환할지는 해당기능을 사용하는 입장에서 신경쓰지 않고 있음

명령형 vs 선언적 프로그래밍

명령형 프로그래밍(Imperative Programming)

• 정의: 프로그램이 어떻게(How) 수행되어야 하는지 수행 절차를 명시하는 방식임
• 특징
  • 단계별 실행: 프로그램의 각 단계를 명확하게 지정하고 순서대로 실행함
  • 상태 변화: 프로그램의 상태(변수 값 등)가 각 단계별로 어떻게 변화하는지 명시함
  • 낮은 추상화: 내부 구현을 직접 제어해야 하므로 추상화 수준이 낮음
  • 예시: 전통적인 for 루프, while 루프 등을 명시적으로 사용하는 방식
• 장점: 시스템의 상태와 흐름을 세밀하게 제어할 수 있음

선언적 프로그래밍(Declarative Programming)

• 정의: 프로그램이 무엇(What)을 수행해야 하는지 원하는 결과를 명시하는 방식
• 특징
  • 문제 해결에 집중: 어떻게(How) 문제를 해결할지보다 무엇(What)을 원하는지에 초점을 맞춤
  • 코드 간결성: 간결하고 읽기 쉬운 코드를 작성할 수 있음
  • 높은 추상화: 내부 구현을 숨기고 원하는 결과에 집중할 수 있도록 추상화 수준을 높임
  • 예시: filter, map 등 람다의 고차 함수를 활용, HTML, SQL
• 장점: 코드가 간결하고 의도가 명확하며 유지보수가 쉬운 경우가 많음

정리

• 명령형 프로그래밍
  • 프로그램이 수행해야 할 각 단계와 처리 과정을 상세하게 기술하여 어떻게 결과에 도달할지를 명시함
• 선언적 프로그래밍
  • 원하는 결과나 상태를 기술하며 그 결과를 얻기 위한 내부 처리 방식은 추상화되어 있어 개발자가 무엇을 원하는지에 집중할 수 있게 함
  • 특히 람다와 같은 도구를 사용하면 코드를 간결하게 작성하여 선언적 스타일로 문제를 해결할 수 있음

필터와 맵 활용 - 문제2

문제에 필요한 학생 Student 클래스

package lambda.mystream;

public class Student {

    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

문제

• 앞서 만든 필터와 맵을 활용하여 문제를 풀어보기
• 점수가 80점 이상인 학생의 이름을 추출
• direct()는 람다를 사용하지 않고 for, if등의 코드를 직접 작성
• lamda()는 앞서 작성한 필터와 맵을 사용해서 코드를 작성

package lambda.mystream;

public class Ex2_Student {
    public static void main(String[] args) {
        // 점수가 80점 이상인 학생의 이름을 추출
        List<Student> students = List.of(
                new Student("Apple", 100),
                new Student("Banana", 80),
                new Student("Berry", 50),
                new Student("Tomato", 40)
        );

        List<String> directResult = direct(students);
        System.out.println("directResult = " + directResult);

        List<String> lambdaResult = lambda(students);
        System.out.println("lambdaResult = " + lambdaResult);
    }

    private static List<String> direct(List<Student> students) {
        // TODO: 코드 작성
        return null;
    }
    private static List<String> lambda(List<Student> students) {
        // TODO: 코드 작성
        return null;
    }
}

 

실행 결과

directResult = [Apple, Banana]
lambdaResult = [Apple, Banana]

 

해결 - Ex2_Student

package lambda.mystream;

public class Ex2_Student {
    public static void main(String[] args) {
        // 점수가 80점 이상인 학생의 이름을 추출
        List<Student> students = List.of(
                new Student("Apple", 100),
                new Student("Banana", 80),
                new Student("Berry", 50),
                new Student("Tomato", 40)
        );

        List<String> directResult = direct(students);
        System.out.println("directResult = " + directResult);

        List<String> lambdaResult = lambda(students);
        System.out.println("lambdaResult = " + lambdaResult);
    }

    private static List<String> direct(List<Student> students) {
        List<String> studentNames = new ArrayList<>();

        for (Student student : students) {
            if (student.getScore() >= 80) {
                studentNames.add(student.getName());
            }
        }
        return studentNames;
    }
    private static List<String> lambda(List<Student> students) {
        List<Student> filteredList = GenericFilter.filter(students, s -> s.getScore() >= 80);
        List<String> mappedList = GenericMapper.map(filteredList, s -> s.getName());
        return mappedList;
    }
}

• direct() 분석
  • 그에 반해 direct()는 어떻게 수행해야 하는지 수행 절차를 명시해야 함
  • 구체적으로 어떻게 필터링하고 이름을 추출하는지 for, if 등을 통해 수행 절차를 지시함
• lambda() 분석
  • (Student s) -> s.getScore() >= 80: 80점 이상의 학생만 필터링하여 Student["Apple", 100], Student["Banana", 80] 객체만 걸러짐
  • (Student s) -> s.getName(): 학생을 학생의 이름으로 매핑
  • 앞서 만들어둔 필터와 맵 유틸리티와 람다 덕분에 매우 편리하게 리스트를 필터링하고 변환(매핑)할 수 있음
  • 요구사항인 "점수가 80점 이상인 학생의 이름을 추출해라"를 "점수가 80점 이상인 학생을 필터링, 학생의 이름을 추출" 처럼 선언적으로 해결하였음
  • 어떻게 필터링하고 이름을 추출하는지 보다는 요구사항에 맞추어 무엇을 하고 싶은지에 초점을 맞추고 있음

스트림 만들기

스트림1

지금까지는 필터와 맵 기능을 별도의 유틸리티에서 각각 따로 제공했기 때문에 두 기능을 함께 사용할 때 필터된 결과를 다시 맵에 전달하는 번거로운 과정을 거쳐야함

이번에는 필터와 맵을 함께 편리하게 사용할 수 있도록 하나의 객체에 기능 통합을 진행

 

필터와 맵을 사용할 때 흐름을 보면 데이터들이 흘러가면서 필터되고 매핑이 되어 마치 데이터가 물 흐르듯이 흘러간다는 느낌을 받을 수 있음

(흐르는 좁은 시냇물을 영어로 스트림이라 하는데 I/O에서 배운 스트림도 같은 뜻으로 데이터가 흘러간다는 뜻임, 하지만 여기서 설명하는 스트림이 I/O 스트림은 아님)

 

MyStreamV1

package lambda.mystream;

public class MyStreamV1 {

    private List<Integer> internalList;

    public MyStreamV1(List<Integer> internalList) {
        this.internalList = internalList;
    }

    public MyStreamV1 filter(Predicate<Integer> predicate) {
        List<Integer> filtered = new ArrayList<>();
        for (Integer element : internalList) {
            if (predicate.test(element)) {
                filtered.add(element);
            }
        }
        return new MyStreamV1(filtered);
    }

    public MyStreamV1 map(Function<Integer, Integer> mapper) {
        List<Integer> mapped = new ArrayList<>();
        for (Integer element : internalList) {
            mapped.add(mapper.apply(element));
        }
        return new MyStreamV1(mapped);
    }

    public List<Integer> toList() {
        return internalList;
    }
}

• 해당 예제의 스트림은 자신의 데이터 리스트를 가지며 쉽게 설명하기 위해 타입을 Integer로 고정했음
• 스트림은 자신의 데이터를 필터(filter)하거나 매핑(map)해서 새로운 스트림을 만들 수 있음
  • 필터를 하면 필터링 된 데이터를 기반으로 새로운 스트림이 만들어지고 매핑을 하면 매핑된 데이터를 기반으로 새로운 스트림이 만들어짐
• 스트림은 내부의 데이터 리스트를 toList()로 반환할 수 있음

MyStreamV1Main - V1 활용

package lambda.mystream;

public class MyStreamV1Main {
    public static void main(String[] args) {
        // 짝수만 남기고 남은 값의 2배를 반환
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        returnValue(numbers);
    }

    private static void returnValue(List<Integer> numbers) {
        MyStreamV1 stream = new MyStreamV1(numbers);
        MyStreamV1 filteredStream = stream.filter(n -> n % 2 == 0);
        MyStreamV1 mappedStream = filteredStream.map(n -> n * 2);

        List<Integer> result = mappedStream.toList();
        System.out.println("result = " + result);
    }
}
/* 실행 결과
result = [4, 8, 12, 16, 20]
*/

• MyStreamV1을 활용하여 짝수만 남기고 남은 값의 2배를 반환하는 기능 개발
  • 필터: 짝수만 남김
  • 매핑: 값을 2배 곱함
• 데이터 변환 과정
  • 1. 스트림 생성
    • new MyStreamV1(numbers)로 스트림 객체를 생성하며 생성한 객체 내부(internalList)에는 1 ~ 10의 데이터가 들어있음
  • 2. 필터 적용
    • stream.filter(n -> n % 2 ==0)로 필터를 적용하고 새로운 MyStreamV1이 만들어지며 그 내부에는 필터된 결과인 [2, 4, 6, 8, 10]이 존재함
  • 3. 맵 적용
    • filteredStream.map(n -> n * 2)로 맵을 적용하고 새로운 MyStreamV1이 만들어지며 그 내부에는 매핑된 결과인 [4, 8, 12, 16, 20]이 존재함
  • 4. 리스트로 변환
    • mappedStream.toList()를 호출하여 스트림에 있는 리스트를 반환하며 그 결과로 스트림 내부에 있는 리스트를 받을 수 있음
    • 최종 반환된 결과는 [4, 8, 12, 16, 20]임

메서드 체인 - methodChain(numbers);

returnValue()메서드의 내부 코드를 보면 스트림 객체를 통해 필터와 맵을 편리하게 사용할 수 있는 것은 맞지만 이전에 만들었던 GenericFilter, GenericMapper를 사용한 코드와 비교해서 봤을 때 크게 편리해진 것 같지는 않음

 

MyStreamV1은 filter, map을 호출할 때 자기 자신을 반환하기 때문에 자기 자신의 메서드를 연결해서 호출할 수 있음

 

package lambda.mystream;

public class MyStreamV1Main {
    public static void main(String[] args) {
        // 짝수만 남기고 남은 값의 2배를 반환
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        returnValue(numbers);
        methodChain(numbers);
    }

    // returnValue() 생략

    private static void methodChain(List<Integer> numbers) {
        MyStreamV1 stream = new MyStreamV1(numbers);
        List<Integer> result = stream
                .filter(n -> n % 2 == 0)
                .map(n -> n * 2)
                .toList();
        System.out.println("result = " + result);
    }
}

• 자기 자신의 타입을 반환한 덕분에 메서드를 연결하는 메서드 체인 방식을 사용할 수 있게 되어 지저분한 변수들을 제거하고 깔끔하게 필터와 맵을 사용할 수 있게 되었음
• 메서드 체인을 활용한 methodChain()의 작동 방식은 기존에 작성한 returnValue()와 완전히 단시 중간 변수들이 없을 뿐임

** 참고

• 메서드 체인 방식이 잘 이해가 되지 않으면 자바 중급 1편 - String 클래스 메서드 체이닝 - MethodChaining을 복습
• 2025.01.17 - [자바 로드맵 강의/중급 1 - 클래스, 날짜, 예외] - String 클래스(기본, 비교, 불변 객체, 주요 메서드), StringBuilder - 가변 String, String 최적화, 메서드 체이닝(Method Chaining)

스트림2

MyStreamV2 - 정적 팩토리(static factory)메서드 추가

package lambda.mystream;

// static factory 추가
public class MyStreamV2 {

    private List<Integer> internalList;

    private MyStreamV2(List<Integer> internalList) {
        this.internalList = internalList;
    }

    static MyStreamV2 of(List<Integer> internalList) {
        return new MyStreamV2(internalList);
    }

    public MyStreamV2 filter(Predicate<Integer> predicate) {
        List<Integer> filtered = new ArrayList<>();
        for (Integer element : internalList) {
            if (predicate.test(element)) {
                filtered.add(element);
            }
        }
        return MyStreamV2.of(filtered);
    }

    public MyStreamV2 map(Function<Integer, Integer> mapper) {
        List<Integer> mapped = new ArrayList<>();
        for (Integer element : internalList) {
            mapped.add(mapper.apply(element));
        }
        return  MyStreamV2.of(mapped);
    }

    public List<Integer> toList() {
        return internalList;
    }

}

• 기존 생성자를 외부에서 사용하지 못하도록 private으로 설정
• 이제 MyStreamV2를 생성하려면 of() 메서드를 사용해야 함
• filter와 map 메서드에서 결과 스트림을 반환할 때도 MyStreamV2.of()로 변경

MyStreamV2Main

package lambda.mystream;

public class MyStreamV2Main {
    public static void main(String[] args) {
        // 짝수만 남기고 남은 값의 2배를 반환
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        List<Integer> result = MyStreamV2.of(numbers)
                .filter(n -> n % 2 == 0)
                .map(n -> n * 2)
                .toList();
        System.out.println("result = " + result);
    }
}
/* 실행 결과 V1Main과 동일 */

• MyStreamV2.of()로 정적 팩토리 메서드를 사용하도록 변경하면 매우 가독성 있는 코드를 작성할 수 있음

정적 팩토리 메서드 - static factory method

정적 팩토리 메서드는 객체 생성을 담당하는 static 메서드로 생성자(constructor) 대신 인스턴스를 생성하고 반환하는 역할을 함

즉, 일반적인 생성자(constructor) 대신에 클래스의 인스턴스를 생성하고 초기화하는 로직을 캡슐화 하여 제공하는 정적(static) 메서드임

 

주요 특징

• 정적 메서드: 클래스 레벨에서 호출되며 인스턴스 생성 없이 접근할 수 있음
• 객체 반환: 내부에서 생성한 객체(또는 이미 존재하는 객체)를 반환
• 생성자 대체: 생성자와 달리 메서드 이름을 명시할 수 있어 생성 과정의 목적이나 특징을 명확하게 표현할 수 있음
• 유연한 구현: 객체 생성 과정에서 캐싱, 객체 재활용, 하위 타입 객체 반환 등 다양한 로직을 적용할 수 있음

생성자는 이름을 부여할 수 없는 반면 정적 팩토리 메서드는 의미있는 이름을 부여할 수 있어 가독성이 더 좋아지는 장점이 있음

인자들을 받아 간단하게 객체를 생성할 때는 주로 of(...)라는 이름을 사용함

 

예시) 회원 등급별 생성자가 다른 경우

// 일반 회원 가입시 이름, 나이, 등급
new Member("회원1", 20, NORMAL);

// VIP 회원 가입시 이름, 나이, 등급, 선물 주소지
new Member("회원1", 20, VIP,"선물 주소지");

• VIP 회원의 경우 객체 생성시 선물 주소지가 추가로 포함된다고 가정하면 생성자만 사용해서 처리할 때 햇갈릴 수 있는 포인트가 있음

 

// 일반 회원 가입시 인자 2개
Member.createNormal("회원1", 20)

// VIP 회원 가입시 인자 3개
Member.createVip("회원2", 20, "선물 주소지")

• 정적 팩토리를 사용하면 메서드 이름으로 명확하게 회원과 각 회원에 따른 인자를 구분할 수 있음

추가로 객체를 생성하기 전에 이미 있는 객체를 찾아서 반환하는 것도 가능함

• ex) Integer.valueOf(): -128 ~ 127 범위는 내부에 가지고 있는 Integer 객체를 반환함

 

** 참고

• 정적 팩토리 메서드를 사용하여 생성자에 이름을 부여할 수 있기 때문에 보통 가독성이 더 좋아짐
• 하지만 반대로 이야기하면 이름도 부여해야 하고 준비해야 하는 코드도 더 많기 때문에 객체의 생성이 단순한 경우에는 생성자를 직접 사용하는 것이 단순함의 관점에서 보면 더 나은 선택일 수 있음

스트림3

MyStreamV3 - 제네릭 추가

package lambda.mystream;

public class MyStreamV3 <T> {

    private List<T> internalList;

    private MyStreamV3(List<T> internalList) {
        this.internalList = internalList;
    }

    static <T> MyStreamV3<T> of(List<T> internalList) {
        return new MyStreamV3<>(internalList);
    }

    public MyStreamV3<T> filter(Predicate<T> predicate) {
        List<T> filtered = new ArrayList<>();
        for (T element : internalList) {
            if (predicate.test(element)) {
                filtered.add(element);
            }
        }
        return MyStreamV3.of(filtered);
    }

    public <R> MyStreamV3<R> map(Function<T, R> mapper) {
        List<R> mapped = new ArrayList<>();
        for (T element : internalList) {
            mapped.add(mapper.apply(element));
        }
        return MyStreamV3.of(mapped);
    }

    public List<T> toList() {
        return internalList;
    }

}

• MyStreamV3은 내부에 List<T> internalList를 가지므로 MyStreamV3<T>로 선언함
• map()은 T를 다른 타입인 R로 반환하며 R을 사용하는 곳은 map 메서드 하나이므로 map 메서드 앞에 추가로 제네릭 <R>을 선언함

MyStreamV3Main

package lambda.mystream;

public class MyStreamV3Main {
    public static void main(String[] args) {
        List<Student> students = List.of(
                new Student("Apple", 100),
                new Student("Banana", 80),
                new Student("Berry", 50),
                new Student("Tomato", 40)
        );

        // 점수가 80점 이상인 학생의 이름을 추출
        List<String> result1 = ex1(students);
        System.out.println("result1 = " + result1);

        // 점수가 80점 이상이면서, 이름이 5글자인 학생의 이름을 대문자로 추출
        List<String> result2 = ex2(students);
        System.out.println("result2 = " + result2);
    }

    private static List<String> ex1(List<Student> students) {
        return MyStreamV3.of(students)
                .filter(s -> s.getScore() >= 80)
                .map(s -> s.getName())
                .toList();

    }

    private static List<String> ex2(List<Student> students) {
        return MyStreamV3.of(students)
                .filter(s -> s.getScore() >= 80)
                .filter(s -> s.getName().length() == 5)
                .map(s -> s.getName())
                .map(s -> s.toUpperCase())
                .toList();
    }
}
/* 실행 결과
result1 = [Apple, Banana]
result2 = [APPLE]
*/

• 제네릭을 도입한 덕분에 MyStreamV3은 Student를 String으로 변환할 수 있게됨
• ex2()는 필터와 맵을 연속해서 사용할 수 있다는 것을 보여주는 예시이며 메서드 체인을 활용한 덕분에 필요한 기능을 얼마든지 연결해서 사용할 수 있음

스트림4 

스트림의 최종 결과까지 스트림에서 함께 처리하도록 개선해보기

MyStreamLoopMain - 외부 반복

package lambda.mystream;

public class MyStreamLoopMain {
    public static void main(String[] args) {
        List<Student> students = List.of(
                new Student("Apple", 100),
                new Student("Banana", 80),
                new Student("Berry", 50),
                new Student("Tomato", 40)
        );

        List<String> result = MyStreamV3.of(students)
                .filter(s -> s.getScore() >= 80)
                .map(s -> s.getName())
                .toList();
        
        // 외부 반복
        for (String s : result) {
            System.out.println("name = " + s);
        }

    }
}
/* 실행 결과
name = Apple
name = Banana
*/

• 지금과 같은 경우 결과 리스트를 for문을 통해 하나씩 반복하며 출력함
• 그런데 filter, map 등도 스트림 안에서 데이터 리스트를 하나씩 처리(함수를 적용)하는 기능이므로 최종 결과를 출력하는 일도 스트림 안에서 처리할 수 있음

MyStreamV3 - forEach() 메서드 추가

package lambda.mystream;

public class MyStreamV3 <T> {

    // 기존코드 전부 동일

    public void forEach(Consumer<T> consumer) {
        for (T element : internalList) {
            consumer.accept(element);
        }
    }
}

• forEach() 메서드는 최종 데이터에 사용할 예정이므로 반환할 것 없이 요소를 하나하나 소비만 하면 되기 때문에 Consumer를 사용하였음

MyStreamLoopMain - forEach() 사용

package lambda.mystream;

public class MyStreamLoopMain {
    public static void main(String[] args) {
        // 기존 코드 동일

        // 추가
        MyStreamV3.of(students)
                .filter(s -> s.getScore() >= 80)
                .map(s -> s.getName())
                .forEach(name -> System.out.println("name = " + name));
    }
}
/* 실행 결과
... 기존 실행결과
name = Apple
name = Banana
*/

• forEach()에 함수(Consumer)를 전달하여 각각의 데이터 리스트를 출력하도록 하면 기존과 동일한 출력 결과를 얻을 수 있음

내부 반복 vs 외부 반복

스트림을 사용하기 전에 일반적인 반복 상식은 for 문, while 문과 같은 반복문을 직접 사용해서 데이터를 순회하는 외부 반복(External Iteration) 방식이었음 즉, 개발자가 직접 각 요소를 반복하며 처리함

 

스트림에서 제공하는 forEach() 메서드로 데이터를 처리하는 방식은 내부 반복(Internal Iteration)이라고 부름

외부 반복처럼 직접 반복 제어문을 작성하지 않고 반복 처리를 스트림 내부에 위임하는 방식으로 스트림 내부에서 요소들을 순회하고 개발자는 처리 로직(람다)만 정의해주면 됨

 

내부 반복은 반복 제어를 스트림이 대신 수행하기 때문에 사용자는 반복 로직을 신경쓸 필요가 없고 코드가 훨씬 간결해지며 선언형 프로그래밍 스타일을 적용할 수 있음

 

정리

• 내부 반복 방식의 제어를 스트림에게 위임하기 때문에 코드가 간결해짐
• 개발자는 어떤 작업을 할지를 집중적으로 작성하고 어떻게 순회할지는 스트림이 담당하도록 하여 생산성과 가독성을 높일 수 있는 선언형 프로그래밍 스타일임
• 외부 반복은 개발자가 반복 구조를 제어하는 반면 내부 반복은 반복을 내부에서 처리하여 코드의 가독성과 유지보수성을 향상시킴

내부 반복 vs 외부 반복 선택

많은 경우 내부 반복을 사용할 수 있다면 내부 반복이 선언형 프로그래밍 스타일로 직관적이기 때문에 더 나은 선택이지만 때때로 외부 반복을 선택하는 것이 더 나은 경우도 있음

 

단순히 한두 줄 수행만 필요한 경우

• 어떤 리스트를 순회하여 그대로 출력만 하면 되는 등의 매우 간단한 작업을 할 때는 굳이 스트림을 사용할 필요가 없음
• 예시와 같이 반복문 자체가 한두 줄로 끝나고, 특별한 연산(필터링, 변환 등)이 없다면 for문이 한눈에 이해 하기 쉬울 수 있음

반복 제어에 대한 복잡하고 세밀한 조정이 필요한 경우

• 반복 중에 특정 조건을 만나면 바로 반복을 멈추거나 일부만 건너뛰도록 break, continue등을 사용하는 경우 외부 반복을 사용하는 외부 반복이 단순함

정리

• 연속적인 필터링, 매핑, 집계가 필요할 때는 스트림을 사용한 내부 반복이 선언적이고 직관적임
• 아주 간단한 반복이거나, 중간에 break, continue가 들어가는 흐름 제어가 필요한 경우는 외부 반복이 더 간결하고 빠르게 이해될 수 있음

정리

명령형(Imperative) vs 선언형(Declarative) 프로그래밍

• 명령형 프로그래밍
  • 어떻게(How) 문제를 해결할지 로직 단계별로 명령(지시)을 상세히 기술함
  • 주로 for, if와 같은 제어문을 사용하여 로직이 복잡해질수록 중복 코드가 늘어날 수 있음
• 선언형 프로그래밍
  • 무엇을(What) 해야 하는지에 집중함
  • "짝수만 필터링하고, 그 값을 2배로 변환"처럼 원하는 결과만 기술하면 내부의 세부 로직(어떻게 필터링하고 변환하는지)은 외부에서 신경쓰지 않기 때문에 코드 가독성과 유지보수성을 높일 수 있음

Filter와 Map

• 조건에 맞는 값만 선별하는 작업을 필터라고하고 값을 다른 값으로 변환하는 과정을 매핑이라고 함
• 자바에서 제공하는 Predicate, Function 같은 표준 함수형 인터페이스를 사용하여 람다 형식으로 필터와 맵을 자유롭게 조합할 수 있음
• 필터와 맵을 유틸리티 메서드로 분리해두면 다양한 타입(T)에 대해 재사용할 수 있어 코드 중복을 줄이고 선언형 프로그래밍 스타일을 쉽게 적용할 수 있음

Stream(스트림)

• 필터와 맵을 포함한 여러 연산을 연속해서 적용하기 위해 이를 하나의 흐름(스트림)으로 표현한 것임
• 스트림을 사용하면 메서드 체인방식으로 filter(), map(), forEach() 등을 연결해 호출할 수 있으므로 중간 변수를 만들 필요 없이 깔끔하게 데이터를 가공할 수 있음
• 내부 반복(Internal Iteration)을 지원하여 개발자가 명시적으로 for 루프를 작성하지 않고도 반복 처리 로직을 스트림 내부에 위임할 수 있어 간결하고 직관적인 코드 작성이 가능함

내부 반복 vs 외부 반복

• 외부 반복: 기존의 for, while 루프처럼 개발자가 반복 제어를 직접 담당하는 명령형 스타일, 중간에 break, continue 등이 들어가는 로직을 구현하기 쉬움
• 내부 반복: 스트림의 forEach처럼 반복 제어를 스트림에 맡기고 개발자는 어떤 작업을 할지만 정의하는 선언형 프로그래밍 스타일, 코드가 짧고 의도가 명확함

정적 팩토리 메서드(static factory method)

• 객체 생성 과정을 메서드로 캡슐화하여 가독성을 높이는 기법
• 생성자에 이름을 붙이지 못하는 한계를 보완하며 객체 캐싱 또는 하위 타입 객체 반환 같은 유연한 로직을 적용할 수 있음

필터(Filter)와 맵(Map) 그리고 이를 포괄적으로 사용할 수 있는 스트림(Stream)을 적극적으로 활용하면 선언형 프로그래밍 스타일로 직관적인 코드를 작성할 수 있음

반면 더 세밀한 제어가 필요하다면 명령형 프로그래밍을 선택할 수 있으므로 상황에 따라 두 방식을 적절히 활용하면 됨

---

출처 : 인프런 - 김영한의 실전 자바 - 고급3편 (유료) / 김영한님  
유료 강의이므로 정리에 초점을 두고 코드는 일부만 인용함