#10 Modern Java (Java8~)

# 함수형 인터페이스(람다)

클래스를 함수형 인터페이스로 구현하면 람다 표현식을 사용 할 수 있다.

• 추상 메소드를 딱 하나만 가지고 있는 인터페이스
• SAM (Single Abstract Method, 단 하나의 추상메서드 사용) 인터페이스
• @FuncationInterface 애노테이션을 가지고 있는 인터페이스 ( 없더라도 위 2조건을 만족하면 동일 취급.)
  

public class Main {
    public static void main(String[] args) {
    // 익명함수 대신 람다를 사용하여 이렇게 메서드 구현이 가능하다.
        Hello hello = () -> System.out.println("Hello");
        hello.doSomething(); // Hello 객체 내부의 메서드를 구현한 것임을 유의하자.
    }
}

 

---

# 메소드 레퍼런스

함수를 직접 구현하지않고, 다른 함수를 재사용하여 함수형 프로그래밍을 쉽게 도와주는 기능이다.

JS에서 각각의 입력 값에 콜백함수를 적용시켜주는 문법(Array.map)과 비슷하다.

종류	사용방법	예제
Static 메서드	ContainingClass :: staticMethodName	Person::compareByAge
특정 객체(myObject)의 인스턴스 메서드	containingObject::instanceMethodName	myApp::appendStrings2
타입 객체(Type)의 인스턴스 메서드	ContainingType::methodName	String::compareToIgnoreCase String::concat
생성자	ClassName::new	HashSet::new

코드 예제

Static Method 레퍼런스 사용

// 내가 구현한 인터페이스
interface Executable {
    void doSomething(String text);
}

// 이미 존재하는 Static 메서드
public static class Printer {
    static void printSomething(String text) {
        System.out.println(text);
    }
}

// 꼭 람다로 함수를 새롭게 만들지 않더라도, 기존에 존재하는 함수를 이용 할 수 있다.
public static void main(String args[]) {
    // Executable exe = text -> Printer.printSomething(text); 와 동일한 코드
    Executable exe2 = Printer::printSomething;
    
    exe2.doSomething("do something");
    
    // 함수형 API를 이용하면 객체를 생성하지 않고도 사용할 수 있다.
    Consumer<String> consumer = Printer::printSomething;
    consumer.accept("do something");
}

Instance Method 레퍼런스 사용

// 내가 만든 임의의 클래스.
public static class Company {
    String name;
    public Company(String name) {
        this.name = name;
    }
    
	// static이 아닌 메서드.
    public void printName() {
        System.out.println(name);
    }
}

public static void main(String args[]) {
    List<Company> companies = Arrays.asList(new Company("google"),
        new Company("apple"), new Company("samsung"));
        
    //companies.stream().forEach(company -> company.printName());와 동일한 코드
    companies1.stream().forEach(Company::printName);
    
    
    // 이런식으로 응용 할 수 있다.
    List<String> myCompanies = Arrays.asList("google", "apple", "google", "apple", "samsung");

    myCompanies.stream()
         .mapToInt(String::length) // 람다식: company -> company.length()
         .forEach(System.out::println);
}

 

Constructor Method (new, 생성자 레퍼런스) 사용

public static class Company {
    String name;
    public Company(String name) {
        this.name = name;
    }

    public void printName() {
        System.out.println(name);
    }
}

public static void main(String args[]) {
    List<String> companies = Arrays.asList("google", "apple", "google", "apple", "samsung");

//  companies.stream() 이 코드와 동일함.
//      .map(name -> new Company(name))
//      .forEach(company -> company.printName());
    companies.stream()
        .map(Company::new)
        .forEach(Company::printName);
}

 

---

# 함수형 API

자바에서는 모든 메서드는 객체안에 존재한다. 그래서 메서드만 뽑아서 재사용하기 어려운데, 이를 쉽게 하기 위해 다양한 API 틀을 제공해준다.

// B실행 후 반환값 전달, 이후 A실행 즉 함수의 합성이다.
newFunc = funcA.compose(funcB)
 
// A실행 후 B실행. 그냥 단순히 연달아 실행하는 것 뿐이다.
newFunc = fucnA.andThen(funcB)

종류	특징	함수 조합용 메서드
Runnable	인자와 반환값이 모두 없음. 단지 실행만 가능
Function<T,R>	인자1개, 반환1개 R apply(T t)	andThen, Compose
BiFunction<T,U,R>	인자2개, 반환1개 R apply(T t, U u)
Consumer<T>	인자만 있음. void accept(T t)	andThen
Supplier<T>	반환값만 있음. T get()
Predicate<T>	반환값만 있음. boolean test(T t)	And, Or, Negate
UnaryOperator<T>	Function<T, T> 와 동일, 인자와 같은 제네릭 타입을 반환함
BinaryOperator<T>	BiFunction<T, T, T> 와 동일, 입력값 두개를 받아 동일한 타입을 리턴함.
Comparator<T>	BiFunction<T,T,Integer> 와 동일, 객체간의 값 비교하는데 사용됨 (compare)
기타 생략	BiCosumer<T,U> BiPredicate<T,U>, ObjIntConsumer, LongSupplier 등.

import java.util.function.DoubleFunction;
import java.util.function.Function;
 
public class Main {
    public static void main(String[] args) {
        // 이렇게 함수를 정의하고 apply 를 이용하여 함수를 실행합니다.
        Function<String, Integer> toStr = str -> Integer.parseInt(str);
        Integer result = toStr.apply("10");
 
        // 입력값이 객체가 아니라면 DoubleFunction, IntFunction 등을 사용해도 됩니다.
        DoubleFunction<Integer> func = a -> (int) (a * 10);
        System.out.println(func.apply(3.2)); // 32
 
        // 이는 위에 코드와 같습니다.
        Function<Integer,Integer> multiply10 = a -> (int) (a * 10);
 
        // 이런식으로 함수를 합성해서 사용 할 수도 있습니다.
        Function<String,Integer> toStringAndMultiply10 = multiply10.compose(toStr);
        System.out.println(toStringAndMultiply10.apply("10")); // 100
    }
}

 

---

# 새로운 이터레이터 (forEach, spliteraor)

함수형 프로그래밍 개념이 등장하면서, 이를 쉽게 사용하기위해 새로운 형태의 iterator도 몇가지 추가되었다.

여담으로 모-던한 함수형 프로그래밍 방식을 사용하는게 무조건 좋은 건 아니다. 뭐든지 장단점은 있으므로 필요할 때 적절하게 사용해야 한다.

List<Integer> list = Arrays.asList(1, 2, 3);
 
// 기존의 forEach문
for (Integer i : list)
    System.out.println(i);

for (Integer i : list)
    for (int j = 0; j < i; j++)
        System.out.println(i * j);

// 새로운 forEach 메서드. 콜백함수를 주는 것 처럼 사용할 수 있다.
list.forEach(System.out::println);

// 이 정도로 단순한 작업은 함수형을 쓰지않는 것이 더 좋을 수도 있다.
list.forEach(i -> {
    IntStream.range(0, i).forEach(j -> {
        System.out.println(i * j);
    });
});

 

Split + erator는 이름에서도 알 수 있듯이, 작업을 여러개로 쪼갤 수 있는 이터레이터라고 이해하면 된다.

Stream이 생기면서 Stream을 여러개로 쪼개 파이프라이닝을 쉽게하기 위해 만들어진 메서드이다.

Spliterator의 소개 및 활용 (in JDK 1.8)

// Stream과 Collection의 경우 기본적으로 spliterator 메서드를 제공합니다.     
Spliterator<Integer> byStream = IntStream.range(0, 100).spliterator();    
Spliterator<Integer> byCollection = (new ArrayList<Integer>()).spliterator();    

// 배열의 경우 Spliterators 클래스를 통해 Spliterator 객체를 생성 할 수 있습니다.
Spliterator<Integer> byArray = Spliterators.spliterator(new int[]{1,2,3,4}, Spliterator.SORTED);

public void trySplit_test() {
    // 이렇게 리스트를 분할하여 사용할 수 있다.
    Spliterator<Integer> origin = IntStream.range(0, 19).spliterator();
    Spliterator<Integer> dest = origin.trySplit();

    System.out.println(dest.estimateSize());  // 크기를 확인하는 메서드 size is 9
    dest.forEachRemaining(System.out::print); // 분할된 iter 순회 print 0~8
    
    System.out.println(origin.estimateSize());  // size is 10
    origin.forEachRemaining(System.out::print);  // print 9 ~ 18
}

---

# Stream

Sequence of elements supporting sequential and parallel aggregate operations
(시퀸스 요소 및 병렬 작업을 도와주는 연산)

스트림은 데이터를 담는 컬렉션이 아니다. 데이터를 복사하여 (=원본을 변경하지 않고) 함수형으로 작업할 수 있게 도와주는 API이다. 함수형 프로그래밍을 배웠다면, 다른 언어에서 비슷한 기능을 한번쯤 봤을 것이다.

• 순수함수, Immutable, 스트림이 처리하는 데이터 소스를 변경하지 않는다.
• 스트림은 재사용이 불가능하다. 스트림으로 처리하는 데이터는 오직 한번만 처리한다.
• 중개 오퍼레이션은 근본적으로 lazy 하다.
• lazy 하기 때문에 데이터 값이 무한이여도 사용 가능하다. (Short Circuit 메소드를 사용해서 크기를 제한)
• 함수형 프로그래밍을 사용하여 손쉽게 병렬 처리할 수 있다.

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

lang.stream() // 1. 스트림을 생성한다
  .sorted() // 2. 중개 연산
  .collect(Collectors.toList()); // 3. 종료 연산
// [Go, Groovy, Java, Python, Scala, Swift]

lang.stream()
  .sorted(Comparator.reverseOrder())
  .collect(Collectors.toList());
// [Swift, Scala, Python, Java, Groovy, Go]

// 스트림은 원본 값을 수정하지 않는다. 즉 기존 배열 lang의 값은 변하지 않음을 기억하자. 
// lang == ["Java", "Scala", "Groovy", "Python", "Go", "Swift"]

스트림에는 여러개의 중개 연산(intermediate operation)과 하나의 종료 연산(terminal operation)으로 구성된다.

중개 연산은 기본적으로 종료 연산이 오기 전까지 실행을 하지 않는다. 즉 lazy하게 동작하며 작업 최적화를 위해 중개 연산의 동작 순서는 바뀔 수 있다.

 

• 스트림 파이프라인
  
  • 0 또는 다수의 중개 오퍼레이션 (intermediate operation)과 한개의 종료 오퍼레이션
    (terminal operation)으로 구성한다.
  • 스트림의 데이터 소스는 오직 터미널 오퍼네이션을 실행할 때에만 처리한다.

• 중개 오퍼레이션
  
  • 중개 연산은 Stream을 리턴한다.
  • Stateless / Stateful 오퍼레이션으로 더 상세하게 구분할 수도 있다.
    (대부분은 Stateless지만 distinct나 sorted 처럼 이전 이전 소스 데이터를 참조해야 하는 오퍼레이션은 Stateful 오퍼레이션이다.)
  • filter, map, limit, skip, sorted, ...

• 종료 오퍼레이션
  
  • Stream을 리턴하지 않는다.
  • collect, allMatch, count, forEach, min, max, ...

스트링 API를 사용하여 함수형 프로그래밍을 구현하게되면, 코드의 가독성이 높아지고 원본을 수정하지 않으며 함수 실행에 있어 Side-effect를 없애 유지보수를 쉽게 만들어준다.

// 기존 코드
final List<Integer> NUMBERS = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer result = null;
for (final Integer number : NUMBERS) {
  if (number > 3 && number < 9) {
    final Integer newNumber = number * 2;
    if (newNumber > 10) {
      result = newNumber;
      break;
    }
  }
}
System.out.println("Imperative Result: " + result);

// Stream 사용
final List<Integer> NUMBERS = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println("Functional Result: " +
                   NUMBERS.stream()
                   .filter(number -> number > 3)
                   .filter(number -> number < 9)
                   .map(number -> number * 2)
                   .filter(number -> number > 10)
                   .findFirst()
                  );

---

# Stream API

2021.07.12 - [Backend/Java] - #11 Stream API

#11 Stream API

---

# Optional API (null값 처리)

2021.07.12 - [Backend/Java] - #12. Optional API (*Null값 처리)

---