// Apple에 Predicate의 test에 해당하는 isGreenApple, isHeavyApple 구현
public class Apple {
	public boolean isGreenApple() {
		return GREEN.equals(color);
	}
	public boolean isHeavyApple() {
		return weight > 150;
	}
}

// Predicate를 파라미터로 받는다
public List<Apple> filterApples(List<Apple> inventory, Predicate<Apple> applePredicate) {
	List<Apple> result = new ArrayList<>();
	for(Apple apple : inventory) {
		if(applePredicate.test(apple)) {
			result.add(apple);
		}
	}

	return result;	
}

// stream의 filter를 이용하면 더 간결하게 표현 가능
public List<Apple> filterApplesForStream(List<Apple> inventory, Predicate<Apple> applePredicate) {
	return inventory.stream().filter(applePredicate::test).collect(Collectors.toList());
}

// 다른 결과를 가져올 수 있음
List<Apple> greenApples = filterApples(inventory, Apple::isGreenApple);
List<Apple> heavyApples = filterApples(inventory, Apple::isHeavyApple);

List<Apple> redApples = filterApples(inventory, (Apple apple) -> RED.equals(apple.getColor()));
List<Apple> heavyApples2 = filterApples(inventory, (Apple apple) -> apple.getWeight() > 150);

/*
* 1. 통화별로 트랜잭션을 그룹화한 다음에 해당 통화로 일어난 모든 트랜잭션 합계를 계산하시오(Map<Currency, Integer>)
* 2. 트랜잭션을 비싼 트랜잭션과 저렴한 트랜잭션 두 그룹으로 분류하시오(Map<Boolean, List<Transaction>>)
*/

// Collection 버전
Map<Currency, List<Transaction>> transactionsByCurrencies = new HashMap<>();
for (Transaction transaction : transactions) {
	Currency currency = transaction.getCurrency();
	List<Transaction> transactionsForCurrency = transactionsByCurrencies.get(currency);
	if (transactionsForCurrency == null) {
		transactionsForCurrency = new ArrayList<>();
		transactionsByCurrencies.put(currency, transactionsForCurrency);
	}
	transactionsForCurrency.add(transaction);
}

// Stream(함수형 프로그래밍) 버전
Map<Currency, List<Transaction>> transactionsByCurrencies2 = transactions.stream().collect(groupingBy(Transaction::getCurrency));

// BEFORE
String name = null;
if(insurance != null){
	name = insurance.getName();
}

// AFTER
Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
Optional<String> name = optInsurance.map(Insurance::getName);

// 상속과 관련된 문제가 있음..
public interface A {
      default void hello {
            print A
      }
}

public interface B extends A {
      default void hello {
            print B
      }
}

public class C implements B, A {
      public static void main(String... args) {
            new C().hello();	// print B
      }
}

Map<String, List<String>> myMap = new HashMap<String, List<String>>();
-> Map<String, List<String>> myMap = new HashMap<>();

var list = new ArrayList<String>(); // infers ArrayList<String> 
var stream = list.stream(); // infers Stream<String> 

var numbers = List.of(1, 2, 3, 4, 5); 
for (var number : numbers) { 
	System.out.println(number); 
} 
for (var i = 0; i < numbers.size(); i++) { 
	System.out.println(numbers.get(i)); 
}

String multilineString = "Baeldung helps \n \n developers \n explore Java.";
List<String> lines = multilineString.lines()
                    .filter(line -> !line.isBlank())
                    .map(String::strip)
                    .collect(Collectors.toList());
assertThat(lines).containsExactly("Baeldung helps", "developers", "explore Java.");

Path filePath = Files.writeString(Files.createTempFile(tempDir, "demo", ".txt"), "Sample text");
String fileContent = Files.readString(filePath);
assertThat(fileContent).isEqualTo("Sample text");

List<String> sampleList = Arrays.asList("Java", "Kotlin");
String[] sampleArray = sampleList.toArray(String[]::new);