[모던자바인액션] 자바 8로 오면서 생긴 일

💬 모던 자바 인 액션 챕터 1을 읽고 정리한 글입니다. 

 

---

✔️ 자바 함수

자바에서 흔히 '함수', 그리고 '메서드'라는 이름을 많이 들을 수 있다.

스터디에서 크루분이 함수와 메서드에 대해서 정의를 해주셨는데, 크게 다음과 같이 생각할 수 있다.

 

단순한 프로그래밍 언어에서 '함수'는 '메서드'와 동일한 의미로 쓰일 수 있으며, 특히 static method에 대해서 같은 의미로 사용된다. 그러나, 자바에서 함수는 '수학적인 함수'로, 부작용을 일으키지 않는 함수를 말할 수 있다.

 

그 외에 함수는 '독립적으로 존재하며, 하나의 기능을 구현하도록 구성한 것'이며, 메서드는 '클래스 내부에 정의되어, 객체의 속성을 다루기 위한 행위'라고도 하는데 독립적인지, 종속적인지에 따른다고 볼 수 있다.

 

✔️ 일급 객체 (First-class)

우리는 보통 프로그래밍을 할 때, '일급 객체'라는 말을 들어본 적이 있을 것이다. 일급 객체는 다른 객체들에 대해 '일반적으로 적용 가능한 연산을 모두 지원하는 객체'를 의미한다. 단순히 이 문장을 보면 무슨 소리인지 이해하기 어렵다. 여기서 말하는 '일반적으로 적용 가능한 연산'이라는 게 무엇을까?

1. 변수나 데이터에 값을 할당할 수 있어야 한다.
2. 객체의 인자로 넘길 수 있어야 한다.
3. 객체의 리턴값으로 리턴할 수 있어야 한다.

그럼, 각각의 요소들에 대해서 잘 생각해보자. 자바의 메서드는 왜 일급 객체라고 할 수 없을까?

public class Test {
    public static void main(String[] args) {
        // 메서드를 변수에 할당할 수 없다.
        Object value = sample;
    }

    public static void sample() {
        System.out.println("I'm Sample!");
    }
}

자바에서 메서드 그 자체를 변수 자체에 할당하는 것을 본 적 없을 것이다. 메서드의 리턴 값이 아닌, 메서드 그 자체를 할당하는 것은 불가능하기 때문이다.

public class Test {
    public static void main(String[] args) {
        // 메서드 자체를 매개변수로 전달할 수 없다.
        hello((Object) sample);
    }

    public static String hello(Object method) {
    	...
    }

    public static void sample() {
        System.out.println("I'm Sample!");
    }
}

public class Test {
    public static String hello() {
        return sample;
    }

    public static String sample() {
        return "Sample!";
    }
}

또한, 메서드 그 자체를 함수의 파라미터로 전달할 수 없으며, 메서드의 리턴 값으로 바로 반환할 수도 없다.

 

그래서 보통 자바의 메서드는 일급 객체라고 하지 않는다. (보통 '이급 객체, 이급 시민'이라고 한다) 하지만, 자바의 람다식이나 익명 클래스를 활용하게 되면 변수나 매개변수에 할당할 수 있기 때문에 일급 객체의 요건을 충족할 수 있다. 본 책에서는 자바 8에서 "함수"가 새로 추가되며, 이러한 일급 객체의 특성을 만족할 수 있도록 함수 자체를 "값"으로 취급하여 만들어 준다.

앞으로 본 책을 학습하면서 각각에 대해 학습할 예정이기 때문에, 여기서는 이정도만 간략하게 설명하고 넘어가도록 하겠다 🥹

---

✔️ 자바 8에서의 새로운 기능

- 자바 8에서는 메서드를 값처럼, 일급 객체로 취급하는 기능을 제공한다. 이러한 기능을 '메서드 참조'라고 한다.

File[] hiddenFiles = new File(".").listFiles(new FileFilter() {
public boolean accept(File file) {
        return file.isHidden();
        }
        });

 

위 코드를 보면, 기존에는 매개변수로 메서드를 전달해주기 위해서 다음과 같이 긴 구현체를 함께 선언해서 보내주는 것을 볼 수 있다. 위 코드를 메서드 참조를 통해서 수정해보자.

File[] hiddenFiles = new File(".").listFiles(File::isHidden);

다음과 같이 ::를 사용해서 메서드 참조를 구현할 수 있으며, 마치 '값'을 전달하는 것처럼 간결하게 전달하는 것을 볼 수 있다.

즉, ::는 ‘해당 메서드를 값으로 사용하라’는 의미로 볼 수 있다.

 

또한, 람다식을 활용하여 메서드를 값처럼 취급할 수 있다. 재사용성이 없고 간단한 코드의 경우 람다를 활용하자.

(int x) -> x + 1

---

✔️ 동작 파라미터화 이해하기

동작 파라미터를 알아보기 전에, 간단한 예제를 살펴보자. 아래 예제는 초록색 사과에 대해서 필터링을 진행하는 코드이다.

public static List<Apple> filterGreenApples(List<Apple> inventory) {
        List<Apple> result = new ArrayList<>();
        for (Apple apple: inventory) {
        if (GREEN.equals(apple.getColor())) {
        result.add(apple);
        }
        } return result;
        }

물론, 이렇게 하면 직관적이고 잘 알아볼 수 있다. 하지만, 뭔가 코드를 리팩터링 하고 싶은 욕망이 생긴다 🤔

public static boolean isGreenApple(Apple apple) {
        return GREEN.equals(apple.getColor());
        }

public interface Predicate<T>{
        boolean test(T t);
        }

static List<Apple> filterApples(List<Apple> inventory,
        Predicate<Apple> p) {
        List<Apple> result = new ArrayList<>();
        for (Apple apple: inventory) {
        if (p.test(apple)) { // p에 대한 조건 검증
        result.add(apple);
        }
        }
        return result;
        }

Predicate를 활용해서 마치, 전략 패턴을 사용하는 것처럼 주입을 받아서 조건을 처리할 수 있다. 본 책에서는 Predicate를

'인수로 값을 받아 true 혹은 false를 반환하는 함수'라고 표현하였다. 이 내용은 Chapter 2에서 조금 더 자세히 다룰 예정이기 때문에 지금은 그냥 이런 것도 있구나... 🤔 하고 넘어가도 좋다.
아무튼, 이렇게 선언을 해주게 되면, filterApples(inventory, Apple::isGreenApple)과 같은 형식으로 메서드를 일급 객체처럼 넘겨서 사용할 수 있게 된다.

---

✔️ 메서드 말고, 람다로 해결해볼래?

메서드로 전달해 주려면, 결국 메서드를 선언해야 한다는 것이다. 하지만, 메서드를 선언한다는 것은 해당 메서드의 네이밍과 위치까지 고려해야 하는 게 많다. 귀찮다면! 익명함수 / 람다를 활용하여 바로 다음과 같이 정의해줄 수도 있다.

filterApples(inventory, (Apple a) -> GREEN.equals(a.getColor());

이 메서드 하나 안에서 "사과의 색상이 초록색인 사과를 필터링한다"가 바로 드러나는 걸 볼 수 있다. 그러나, 무분별하게 사용하는 건 좋지 않다. 람다 내부의 식이 길어진다면 오히려 보기 힘들기 때문에 메서드로 정의해서 메서드 네이밍을 통해 해당 메서드가 하는 일을 잘 정의하고, 메서드 참조를 진행하는 것이 좋다.

---

✔️  Stream 활용하기

하지만, 위 코드에서도 여전히 불편한 점이 존재한다.

List<Apple> result = new ArrayList<>();
        for (Apple apple: inventory) {
        if (p.test(apple)) { // p에 대한 조건 검증
        result.add(apple);
        }
        }

for-each를 통해 순회를 하게 되면, 명시적으로 결과를 넣기 위한 List 선언부터 넣어주는 과정까지 직접 선언해줘야 한다. 하지만, 개발자는 귀찮다. 컬렉션의 for-each 구문으로 통해 각 요소를 반복하면서 작업을 수행하던 (외부 반복) 형식에서 벗어나, 스트림 라이브러리 내부에서 모든 데이터를 처리할 수 있도록 (내부 반복) 진행해보자.

// 순차 처리
import static java.util.stream.Collectors.toList;
        List<Apple> heavyApples =
        inventory.stream()
        .filter((Apple a) -> a.getWeight() > 150)
        .collect(toList());

// 병렬 처리
        import static java.util.stream.Collectors.toList;
        List<Apple> heavyApples =
        inventory.parallelStream()
        .filter((Apple a) -> a.getWeight() > 150)
        .collect(toList());

위와 같이 조건을 작성하고, collect()를 통해서 해당하는 리스트를 바로 얻어올 수 있다. 이제, 리스트를 선언하고 add를 통해 직접 초과해주었던 과정이 없어져서 훨씬 간결해졌다. 또한, 컬렉션에서는 크기가 매우 큰 리스트에 대해서 단순히 for-each를 통해서 처리한다면 시간이 더 걸릴 테지만, stream의 병렬성을 사용하면 더 빠르게 처리할 수 있다는 장점이 있다.

 

여기서, parallelStream은 어떻게 병렬 처리를 진행할까? 자바에서는 ForkJoinPool 프레임워크를 활용하여 병렬처리를 진행한다.

 

ForkJoinPool은 동일한 작업을 여러 개의 서브 태스크로 분리(Fork)하여 처리하고, 이를 최종적으로 합쳐서(Join) 결과를 만드는 방법이다. 스트림에서는 하나는 앞부분을, 하나는 뒷부분을 처리하고 마지막에 두 개를 합쳐서 결과를 내보내는 형식이다. (내부적으로 Spliterator 인터페이스를 활용하여 분할을 진행한다)

 

또한, 스트림을 사용하게 되면 가변 공유 객체 (=인스턴스 생성 이후에, 내부 상태가 변경 가능한 객체. List, Map... etc)이더라도 서로 독립적이기 때문에 병렬성을 쉽게 누릴 수 있다는 것이 큰 장점이다.

---

✔️ 디폴트 메서드와 자바 모듈

이전에는 인터페이스(ex. List, Collection…)에 대해서 stream.filter를 사용하는 문법이 오류가 났었다. 그러나, 자바8에서는 구현 클래스에서 구현하지 않아도 되는 메서드를 인터페이스에 추가할 수 있도록 기능을 제공한다.

 

만약, 기존에 Collection 인터페이스에 stream()을 추가하고 싶다면, 인터페이스이기 때문에 해당 인터페이스를 구현하는 모든 구현체들에 대해서 stream() 메서드를 구현했어야 했다. 즉, 구현하는 클래스가 많아질수록 매우매우 개발자는 힘들어졌던 것이다 🥹 (또한, 'OCP - 확장에는 열려있지만 변경에는 닫혀있는 형태'를 만족하지 않게 된다. 이는 확장성이 매우 떨어지기 때문이다.)

 

하지만, 디폴트 메서드가 나오면서 인터페이스의 본문(body)에 기능을 구현할 수 있도록 추가하였으며, 기존의 코드를 건드리지 않고도 자유롭게 설계를 확장할 수 있도록 만들었다. 또한, 구현 클래스에서 원한다면 해당 클래스를 구현할 수 있도록 만들어서 더욱 더 확장성있는 설계를 가능하도록 만들었다.

 // List.java
default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
        i.next();
        i.set((E) e);
        }
        }

위 코드는 List<T> 인터페이스의 default 메서드이다. 이 덕분에 우리는 흔히 정렬을 진행할 때 다음과 같이 진행할 수 있게 되었다.

List<Integer> list = new ArrayList<>();
        list.sort(Integer::compareTo);

또한, ArrayList 내부를 보면 다음과 같이 오버라이딩을 통해 sort()를 재구현한 것을 볼 수 있다.

// ArrayList.java

@Override
@SuppressWarnings("unchecked")
public void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
        modCount++;
        }

 

 

💬 그렇다면, 만약 하나의 클래스가 여러 개의 인터페이스를 상속받아서, 해당 인터페이스에 있는 디폴트 메서드를 둘 다 구현하게 되면 어떻게 될까? 이게 곧 다중 상속을 허용한다는 것이 아닐까?

// Grand.java
public interface Grand {
    void hello();
}

// Mom.java
public interface Mom extends Grand{
    @Override
    default void hello() {
        System.out.println("I'm your Mom.");
    }
}

// Dad.java
public interface Dad extends Grand{
    @Override
    default void hello() {
        System.out.println("I'm your Dad.");
    }
}

다음과 같은 상황이 있을 때, Mom과 Dad 모두를 상속하는 클래스인 Child가 있다면 어떻게 될까?

class Child implements Mom, Dad{
}

다음과 같이 Mom과 Dad 모두에서 디폴트 메서드가 존재하기 때문에, 어떤 메서드를 사용해야 할지 알 수가 없어서 컴파일 에러가 발생한다. 그리고, 이러한 문제를 '다이아몬드 상속 문제'라고 부른다. 

---

✔️ Optional<T> 클래스

마지막으로, Optional을 통해 값을 갖거나 가지지 않을 수 있는 객체를 제공한다. 이를 사용하면 NPE를 피할 수 있으며, 값이 없을 때 어떤 식으로 처리할지 외부에서 결정할 수 있기 때문에 명시적으로 처리가 가능하다는 장점이 존재한다.

 

---

챕터 1에서는 자바8로 넘어오면서 간략하게 어떤 기능들이 추가되었는지 알아봤다.

추후 챕터를 진행하면서 해당 기능들에 대해 더 자세하게 공부해보자 😎

 

💡 정리

- 자바 8에서는 메서드를 '일급 객체'처럼 사용할 수 있는 기능을 제공한다. 람다와 익명 함수를 활용하자.
- 스트림을 통해서 반복되는 코드를 줄이고, 병렬성을 쉽게 처리할 수 있다.
- 디폴트 메서드를 통해 인터페이스에 대한 확장을 쉽게 할 수 있게 되었다.