표준 API 함수적 인터페이스

//표준 API 함수적 인터페이스

 -JDK1.8

 -java.util.function

 -함수적 인터페이스 집합 패키지. 오로지 람다식만을 지원하기 위해 만들어진 인터페이스 모음

 - 람다식 타겟 타입 = 표준 API 함수적 인터페이스 + 사용자 정의 함수적 인터페이스

//표준 API 함수적 인터페이스 종류

 -추상메소드 딱1개

 1.Consumer : 매개변수 O, 반환값 X -> 추상메소드 제공 

 2.Supplier  : 매개변수 x, 반환값 O 

 3.Function  : 매개변수 O, 반환값 O, 주로 매개변수를 반환값 타입으로 반환 후 반환역할

 4.Operator  : 매개변수 O, 반환값 O, 주로 매개변수를 연산 후 결과값 반환 역할

 5.Predicate  : 매개변수 O, 반환값 O, 주로 매개변수를 조사 후 논리값 반환 역할

---------------------------------------------------------------------------------------------------------

//Consumer

- accept() 메소드를 제공하는 함수형 인터페이스

- 매개변수를 받아서 소비하는 일을 구현하는 역할

- 다양한 오버로딩 지원

Consumer<String> c = (String txt) ->{System.out.println("결과 : " + txt);};

c.accept("아무개");

====> 결과 + 아무개

//Consumer 인터페이스 -> 추상메소드 -> 인자값 1개 -> 소비메소드 구현부? 전달된 매개변수를 어떤 식으로 사용하는 지는 제한 없음(구현하는 사람 마음대로~);

Consumer<Integer> c2 = (int count) -> {

for(int i=0;i<count;i++){

System.out.print(i+ "\t");

}

};

c2.accept(10);

===> 1 2 3 4 5 6 7 8 9 

//Consumer의 종류

1.Consumer

2.BioConsumer

3.IntConsumer

4.DoubleConsumer

5.ObjConsumer

---------------------------------------------------------------------------------------------------------

//Supplier

- getXXX() 메소드를 제공하는 함수형 인터페이스

- 데이터를 공급하는 역할을 한다.

Supplier<T>

인자는 받지않으며 리턴타입만 존재하는 메서드를 갖고있다. 순수함수에서 결과를 바꾸는건 오직 인풋(input) 뿐이다. 

그런데 인풋이 없다는건 내부에서 랜덤함수같은것을 쓰는게 아닌이상 항상 같은 것을 리턴하는 메서드라는걸 알 수 있다.

예제)

//User 클래스

class User{

private String name;

private int age;

public User() {};

public User(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return String.format("%s(%s)", this.name,this.age);

}

}

Supplier<Integer> s1 = () -> 100;

System.out.println(s1.get());

Supplier<String> s2 = () -> "문자열";

System.out.println(s2.get());

Supplier<User> s3 = () -> new User("아무개",20);

User u = s3.get();

System.out.println(u); ==>아무개(20)

//public List<User> get() {return 배열;}

Supplier<List<User>>s4 = () ->{

List<User> list = new ArrayList<User>();

list.add(new User("아무개",20));

list.add(new User("홍길동",22));

list.add(new User("테스트",23));

return list;

};

for(User user : s4.get()) {

System.out.println(user);

}

Supplier<Map<String,User>> s5 = () -> {

Map<String,User> map = new HashMap<String,User>();

map.put("반장", new User("홍길동",20));

map.put("부반장", new User("아무개",21));

map.put("체육부장", new User("호호호",22));

return map;

};

//Map 형태

Map<String,User> map = s5.get();

System.out.println(map.get("반장"));

System.out.println(map.get("부반장"));

System.out.println(map.get("체육부장"));

Supplier<List<Map<String,User>>> s6 = () ->{

List<Map<String,User>> list = new ArrayList<Map<String,User>>();

Map<String,User> map1 = new HashMap<String,User>();

map1.put("아빠", new User("홍길동",30));

map1.put("엄마", new User("호호호",30));

list.add(map1);

Map<String,User> map2 = new HashMap<String,User>();

map2.put("아빠", new User("아무개",35));

map2.put("엄마", new User("헤헤헤",32));

map2.put("아이", new User("아아아",8));

list.add(map2);

return list;

};

List<Map<String,User>> list = s6.get();

for(Map<String,User> m : list) {

//각세대별로 루프(m)

Set<String> keys = m.keySet();

Iterator<String> iter = keys.iterator();

while(iter.hasNext()) { //1사람

String key = iter.next();

System.out.println(key + " : " + m.get(key).getName());

}

System.out.println();

}

---------------------------------------------------------------------------------------------------------

//함수형 인터페이스

- 람다식을 저장하는 용도(내부적으로는 람다식으로 만들어진 메소드를 소유한 익명 객체를 생성)

//Function (값 -> 값 반환)

- 매개변수와 반환값이 있는 메소드를 제공한다.

- applyXXX() 메소드를 제공하는 함수형 인터페이스

- 매개값을 반환값으로 매핑(변환)하는 역할

예제)

Function<String, Integer> f1 = (txt) -> txt.length();

System.out.println(f1.apply("홍길동입니다.")); // apply("문자") -> 반환값 = 글자수

Function<Integer, String> f2 = num -> num >0 ? "양수" : "음수" ;

System.out.println(f2.apply(2));

Function<Mouse,Integer> f3 = m -> (int)(m.getPrice()*1.1);

System.out.println(f3.apply(new Mouse("마우스",20000)));

Function<Student,Integer> f4 = s -> s.getKor()+s.getEng()+s.getMath();

System.out.println(f4.apply(new Student("홍길동",100,90,80)));

---------------------------------------------------------------------------------------------------------

//Operator(연산자)

- 매개변수와 반환값이 있는 메소드를 제공한다.

- applyXXX()

- Function의 하위 호환 인터페이스(서브셋)

- 주로 매개값을 연산(****)을 통해 결과값을 만들어내고 그 값을 반환

- Function과 큰 차이는 Operator는 매개값을 반환값의 타입 동일

예제)

BinaryOperator<Integer> b1 = (n1,n2) -> n1+n2; // 반환값,매개값,전부 Integer

System.out.println(b1.apply(10, 20));

BinaryOperator<String> b2 = (firstName,lastName) -> lastName+firstName;

System.out.println(b2.apply("길동", "홍"));

---------------------------------------------------------------------------------------------------------

//Predicate

- 매개변수와 반환값이 있는 메소드를 제공한다.

- testXXX()

- 매개값을 사용해 조사(조건) 후 논리값을 반환한다.

- Function 서브셋

예제)

Predicate<Integer> p1 =n -> n>0;

System.out.println(p1.test(10));

Predicate<String> p2 = s ->s.length()>10;

if(p2.test("홍길동입니다")) {

System.out.println("긴문장");

}else {

System.out.println("짧은 문장");

}

Predicate<Student> p3 = s -> (s.getKor()+s.getEng()+s.getMath())>240;

if(p3.test(new Student("홍길동",100,90,80))) {

System.out.println("합격");

}else {

System.out.println("불합격");

}

BiPredicate<String, String> p4 = (s1,s2) -> s1.length()>s2.length();

if(p4.test("홍길동", "홍민")) {

System.out.println("긴문장");

}else {

System.out.println("짧은 문장");

}

출처: http://multifrontgarden.tistory.com/125 [우리집앞마당]