functionalInterface

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

// 오직 한개의 메소드만 가지는 인터페이스
@FunctionalInterface
interface Predicate {
	boolean test(User user);
	// boolean foo();
}

// staic 함수를 모아놓은 클래스
final class Users {
// private 생성자: 객체의 생성을 금지
private Users() {
}

static List<User> filter(List<User> users, Predicate predicate) {
	List<User> result = new ArrayList<>();
		for (User u : users) {
		if (predicate.test(u))
		result.add(u);
	}

	return result;
}

/*
static List<User> filter(List<User> users, int age) {
	List<User> result = new ArrayList<>();
		for (User u : users) {
		if (u.getAge() == age)
		result.add(u);
	}

	return result;
}

static List<User> filter(List<User> users, String name) {
	List<User> result = new ArrayList<>();
		for (User u : users) {
		if (name.equals(u.getName()))
		result.add(u);
	}

	return result;
}
*/
}


// Data class
class User {
private String name;
private int age;

String getName() {
return name;
}

int getAge() {
return age;
}

User(String name, int age) {
this.name = name;
this.age = age;
}

// Tom(42)
// 부모로부터 물려받은 메소드에 대해서는
// 접근 지정을 좁힐 수는 없다.
@Override
public String toString() {
// return this.name + "(" + this.age + ")";
return String.format("%s(%d)", name, age);
}

static List<User> data() {
	return Arrays.asList(
	new User("허재종", 28),
	new User("공현식", 23),
	new User("심민제", 26),
	new User("안동원", 26),
	new User("홍준엽", 24),
	new User("이영준", 22),
	new User("홍주원", 22),
	new User("이수정", 22),
	new User("구윤정", 22),
	new User("임진영", 22)
	);
}
}


class NamePredicate implements Predicate {
private String name;

public NamePredicate(String name) {
this.name = name;
}


@Override
public boolean test(User user) {
return user.getName().equals(name);
}
}

class AgePredicate implements Predicate {
private int age;

public AgePredicate(int age) {
this.age = age;
}

@Override
public boolean test(User user) {
return age == user.getAge();
}
}

// 명령형 프로그래밍 - 알고리즘
// 선언적 프로그래밍 - 데이터베이스 SQL
// SELECT * FROM users WHERE age == 42
// => Stream API
// => C# LINQ

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

List<User> users = User.data();
	users = users.stream()
	.filter(user -> user.getAge() == 22)
	.collect(Collectors.toList());

	// 익명 클래스 장점
	// 1. 이름을 별도로 지을 필요가 없다.
	// 2. 클로져를 사용할 수 있다.

	// 문제점
	// 1. 프로그램의 구동 시간에 영향이 간다.
	// 2. 보일러플레이트
	// : 반드시 필요하지만, 반복되는 코드
	// 3. 클로져를 사용할 때 반드시 final이 지정되어 있어야 한다.
	// => Java 7

	// 자바 8
	// => 람다(lambda)
	// : 코드의 조각을 레퍼런스 할 수 있는 기술
	// (함수의 인자로 전달 가능하다)

	// 람다의 제약 조건
	// => 인터페이스에 오직 한개의 함수만 존재해야 한다.

	// 다른 컨텍스트의 변수를 암묵적으로 전달받는 기술
	// => 클로져(Closure)
	// int age = 22;
	// users = Users.filter(users, user -> user.getAge() == age);
	// users = Users.filter(users, user -> user.getName().equals("이영준"));


	// users = Users.filter(users, 22);
	// users = Users.filter(users, "이영준");

	for (User e : users)
	System.out.println(e); // e.toString()

}

/*
public static void main(String[] args) {

List<User> users = User.data();

	// users = Users.filter(users, new NamePredicate("이영준"));
	users = Users.filter(users, new AgePredicate(22));

	// users = Users.filter(users, 22);
	// users = Users.filter(users, "이영준");

	for (User e : users)
	System.out.println(e); // e.toString()

}
*/
}