[📕 Reactive] 4. Reactive 프로그래밍을 위한 사전 지식

1. 함수형 인터페이스

단 하나의 추상 메서드만 있는 정의되어있는 인터페이스 (Java 8부터 지원 가능)
함수를 값으로 취급하기 때문에 어떤 함수를 호출할 때 함수 자체를 파라미터로 전달 가능

public class Example {
	public static void main(String[] args){
    	List<CryptoCurrency> cryptoCurrencies = SampleData.cryptoCurrencies;
        
        Collections.sort(cryptoCurrencies, new Comparator<CryptoCurrency>() {
        	@Override
            public int compare(CryptoCurrency cc1, CryptoCurrency cc2) {
            	return cc1.getUnit().name().compareTo(cc2.getUnit().name());
            }
        });
    }
}

 

• CryptoCurrency 객체를 화폐 단위의 오름차순으로 정렬하기 위해 Comparator 인터페이스 사용 

 

 

 

 

2. 람다 표현식

함수형 인터페이스에 정의된 추상 메서드를 표현식으로 구현한 것
인터페이스의 익명 구현 클래스를 간결하게 표현하는 방법

 

public class Example {
	public static void main(String[] args) {
    	List<CryptoCurrency> cryptoCurrencies = SampleData.cryptoCurrencies;
        
        Collections.sort(cryptoCurrencies, 
        	(cc1, cc2) -> cc1.getUnit().name().compareTo(cc2.getUnit().name()));
    }
}

 

• 함수형 인터페이스의 추상 메서드를 람다 표현식으로 작성해서 메서드의 파라미터로 전달한다는 의미는
  메서드 자체를 파라미터로 전달하는 것이 아니라 함수형 인터페이스를 구현한 클래스의 인스턴스를 람다 표현식으로 작성해서 전달하는 것 !

---

✳️ 람다 캡쳐링

• 람다 표현식 외부에서 정의된 자유 변수를 람다 표현식에 사용하는 것
• 람다 표현식에서 사용되는 자유 변수는 final 또는 final 같은 효력을 지녀야 함

 

 

 

 

3. 메서드 레퍼런스

메서드의 이름과 구분자(::)를 사용하여 람다표현식을 더 간결하게 작성 

 

✳️ ClassName :: static method

public class Example {
	public static void main(String[] args) {
    	List<CryptoCurrency> cryptoCurrencies = SampleData.cryptoCurrencies;
        
        cryptoCurrencies.stream()
        .map(cc -> cc.getName())
//        .map(name -> StringUtils.upperCase(name))
        .map(StringUtils::upperCase)
        .forEach(name -> System.out.println(name));
    }
}

 

 

✳️ ClassName :: instance method

public class Example {
	public static void main(String[] args) {
    	List<CryptoCurrency> cryptoCurrencies = SampleData.cryptoCurrencies;
        
        cryptoCurrencies.stream()
        .map(cc -> cc.getName())
//        .map(name -> name.toUpperCase())
        .map(String::toUpperCase)
        .forEach(name -> System.out.println(name));
    }
}

 

 

✳️ object :: instance method

public class Example {
	public static void main(String[] args) {
    	List<CryptoCurrency> cryptoCurrencies = SampleData.cryptoCurrencies;
        int btcPrice = cryptoCurrencies.stream()
        	.filter(cc -> cc.getUnit() == CurrencyUnit.BTC)
            .findFirst()
            .get()
            .getPrice();
            
        int amount = 2;
        
        PaymentCalculator calculator = new PaymentCalculator();
        cryptoCurrencies.stream()
        	.filter(cc -> cc.getUnit() == CurrencyUnit.BTC)
            .map(cc -> new ImmutablePair(cc.getPrice(), amount())
//            .map(pair -> calculator.getTotalPayment(pair))
            .map(calculator::getTotalPayment)
            .forEach(System.out::println);
    }
}

 

 

✳️ ClassName :: new 👉 생성자

public class Example {
	public static void main(String[] args) {
    	List<CryptoCurrency> cryptoCurrencies = SampleData.cryptoCurrencies;
        
        int amount = 2;
        
        Optional<PaymentCalculator> optional =
        	cryptoCurrencies.stream()
            	.filter(cc -> cc.getUnit() == CurrencyUnit.BTC)
                .map(cc -> new ImmutablePair(cc.getPrice(), amount))
//                .map(pair -> new PaymentCalculator(pair))
                .map(PaymentCalculator::new)
                .findFirst();
    }
}

 

 

 

 

4. 함수 디스크립터

함수형 인터페이스의 파라미터 형식과 리턴 값의 형태 파악 가능

 

✳️ Predicate

• T -> boolean
  • T 타입의 람다 파라미터와 boolean 타입의 값을 리턴하는 Predicate의 함수 디스크립터
  • filter 메서드에서 주로 사용됨

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

public class Example {
	public static void main(String[] args){
    	List<CryptoCurrency> cryptoCurrencies = SampleData.cryptoCurrencies;
        List<CryptoCurrency> result = filter(cryptoCurrencies, cc -> cc.getPrice() > 500_000);
    }
    
    private static List<CryptoCurrency> filter(List<CryptoCurrency> cryptoCurrencies, 
    											Predicate<CryptoCurrency> p) {
    
    	List<CryptoCurrency> result = new ArrayList<>();
        
        for(CryptoCurrency cc : cryptoCurrencies) {
        	if(p.test(cc)) {
            	result.add(cc);
            }
        }
        
        return result;
    }
}

 

• filter 메서드는 파라미터로 Predicate을 가지며 filter 메서드 내부에서 이 Predicate을 사용하여 test 메서드의 리턴 값이 true인 데이터만 필터링함

 

 

 

✳️ Consumer

• T -> void
  
  • Consumer에 정의된 추상 메서드의 파라미터가 T 타입이고, 리턴 값이 없음
  • 전달받은 데이터로 어떤 처리를 하지만 결과 값을 반환할 필요는 없음

@FunctionalInterface
public interface Consumer<T> {
	void accept(T t);
    ...
    ...
}

public class Example {
	public static void main(String[] args){
    	List<CryptoCurrency> cryptoCurrencies = SampleData.cryptoCurrencies;
        List<CryptoCurrency> filtered = 
        			filter(cryptoCurrencies, 
                    		cc -> cc.getUnit() == CryptoCurrency.CurrencyUnit.BTC ||
                            	  cc.getUnit() == CryptoCurrency.CurrencyUnit.ETH);
        
        addBookmark(filtered, cc -> saveBookmark(cc));
    }
    
    private static List<CryptoCurrency> filter(List<CryptoCurrency> cryptoCurrencies,
    											Predicate<CryptoCurrency> p) {
        List<CryptoCurrency> result = new ArrayList<>();
        
        for(CryptoCurrency cc : cryptoCurrencies) {
        	if(p.test(cc)) {
            	result.add(cc);
            }
        }
        
        return result;
    }
    
    // 화폐 즐겨찾기
    private static void addBookmark(List<CryptoCurrency> cryptoCurrencies, 
    								Consumer<CryptoCurrency> consumer) {
    
    	for(CryptoCurrency cc : cryptoCurrencies) {
        	consumer.accept(cc);
        }
    }              
}

 

 

 

.✳️ Function

• T -> R
  • 구현해야되는 추상 메서드가 하나의 파라미터를 가지며 리턴 값으로 R 타입의 값을 반환
  • 함수 내에서 어떤 처리 과정을 거친 후에 그 결과로 특정 타입의 값을 반환하는 함수 역할 

@FunctionalInterface
public interface Function<T, R> {
	R apply(T t);
    ...
    ...
}

public class Example {
	public static void main(String[] args){
    	List<CryptoCurrency> cryptoCurrencies = SampleData.cryptoCurrencies;
        List<CryptoCurrency> filtered = 
        			filter(cryptoCurrencies, 
                    		cc -> cc.getUnit() == CryptoCurrency.CurrencyUnit.BTC ||
                            	  cc.getUnit() == CryptoCurrency.CurrencyUnit.ETH);
        
        int totalPayment = calculatePayment(filtered, cc -> cc.getPrice()*2);
    }
    
    private static List<CryptoCurrency> filter(List<CryptoCurrency> cryptoCurrencies,
    											Predicate<CryptoCurrency> p) {
        List<CryptoCurrency> result = new ArrayList<>();
        
        for(CryptoCurrency cc : cryptoCurrencies) {
        	if(p.test(cc)) {
            	result.add(cc);
            }
        }
        
        return result;
    }
    
    // 화폐별 총 구매 비용 계산
    private static int calculatePayment(List<CryptoCurrency> cryptoCurrencies, 
    								Function<CryptoCurrency, Integer> f) {
    
    	int totalPayment = 0;
        
    	for(CryptoCurrency cc : cryptoCurrencies) {
        	totalPayment += f.apply(cc);
        }
        
        return totalPayment;
    }              
}

 

 

 

✳️ Supplier

• () -> T
  • 추상 메서드가 파라미터를 갖지 않으며 리턴 값으로 T 타입의 값만 반환
  • 어떤 값이 필요할 때 데이터를 제공하는 용도로 사용

@FunctionalInterface
public interface Supplier<T> {
	T get();
}

public class Example {
	public static void main(String[] args) {
    	String mnemonic = createMnemonic();
        System.out.println(mnemonic);
    }
    
    public static String createMnemonic() {
    	return Stream
        		.generate(() -> getMnemonic())
                .limit(12)
                .collect(Collectors.joining(""));
    }
    
    private static String getMnemonic(){
    	List<String> menemonic = Arrays.asList(...);
        Collections.shuffle(mnemonic);
        return mnemonic.get(0);
    }
}

 

 

✳️ Bixxxxx

• 함수형 인터페이스에서 구현해야 하는 추상 메서드에 전달하는 파라미터가 하나 더 추가되어 두 개의 파라미터를 가지는 함수형 인터페이스