JAVA chapter14. 람다식. 14.5 표준 API의 함수적 인터페이스 (1)

JAVA/CONCEPT 2017. 12. 1. 19:03 |

chapter14. 람다식. 


14.5 표준 API의 함수적 인터페이스

- 한 개의 추상 메소드를 가지는 인터페이스들은 모두 람다식 사용 가능

ex) Runnable 메소드



 함수적 인터페이스와 람다식

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package sec05.exam01_runnable;
 
public class RunnableExample { 
    public static void main(String[] args) {
        /*Runnable runnable = () -> {
            for(int i=0; i<10; i++) {
                System.out.println(i);
            }
        };
        
        Thread thread = new Thread(runnable);
        thread.start();*/
        // 간략히 줄여서
        Thread thread = new Thread(() -> {
            for(int i=0; i<10; i++) {
                System.out.println(i);
            }
        });
        thread.start();
    }
}
cs

 


* 자바 8부터 표준 API로 제공되는 함수적 인터페이스

- java.util.function 패키지에 포함되어 있다.

- 매개타입으로 사용되어 람다식을 메소드 또는 생성자의 매개값으로 대입할 수 있도록 해준다.


- 종류



14.5.1 Consumer 함수적 인터페이스

- Consumer 함수적 인터페이스의 특징은 리턴값이 없는 accept() 메소드를 가지고 있다.

accept() 메소드는 단지 매개값을 소비하는 역할만 한다.

여기서 소비한다는 말은 사용만 할 뿐 리턴값이 없다는 뜻이다.




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package sec05.exam02_consumer;
 
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.ObjIntConsumer;
 
public class ConsumerExample {
    public static void main(String[] args) {
        Consumer<String> consumer = t -> System.out.println(t + "8"); // java8
        consumer.accept("java");
        
        BiConsumer<String, String> bigConsumer = (t, u) -> System.out.println(t + u); // java8
        bigConsumer.accept("Java", "8");
        
        DoubleConsumer doubleConsumer = d -> System.out.println("Java" + d); // java8.0
        doubleConsumer.accept(8.0);
        
        ObjIntConsumer<String> objIntConsumer = (t, i) -> System.out.println(t + i); // java8
        objIntConsumer.accept("Java", 8);
    }
}
cs



14.5.2 Supplier 함수적 인터페이스

- Supplier 함수적 인터페이스의 특징은 매개변수가 없고, 리턴값이 있는 getXXX() 메소드를 가지고 있다.

이들 메소드는 실행 후 호출한 곳으로 데이터를 리턴(공급)하는 역할을 한다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package sec05.exam03_supplier;
 
import java.util.function.IntSupplier;
 
public class SupplierExample {
    public static void main(String[] args) {
        IntSupplier intSupplier = () -> {
            int num = (int) (Math.random() * 6) + 1;
            return num;
        }; // 매개변수가 없으므로 람다식으로 가능
        
        int num = intSupplier.getAsInt();
        System.out.println("눈의 수: " + num);
    }
}
cs



14.5.3 Function 함수적 인터페이스

- Function 함수적 인터페이스의 특징은 매개변수와 리턴값이 있는 applyXXX() 메소드를 가지고 있다.

이들 메소드는 매개값을 리턴값으로 매핑(타입변환)하는 역할을 한다



Student 클래스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package sec05.exam04_function;
 
public class Student {
    private String name;
    private int englishScore;
    private int mathScore;
    
    public Student(String name, int englishScore, int mathScore) {
        this.name = name;
        this.englishScore = englishScore;
        this.mathScore = mathScore;
    }
 
    public String getName() { return name; }
    public int getEnglishScore() { return englishScore; }
    public int getMathScore() { return mathScore; }
}
cs



 Function1 함수적 인터페이스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package sec05.exam04_function;
 
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.function.ToIntFunction;
 
public class FunctionExample1 {
    private static List<Student> list = Arrays.asList(
        new Student("홍길동", 90, 96),
        new Student("신용권", 95, 93)
    );
    
    public static void printString(Function<Student, String> function) {
        for(Student student : list) { // 문자열 출력
            System.out.print(function.apply(student) + " ");
        }
        System.out.println();
    }
    
    public static void printInt(ToIntFunction<Student> function) {
        for(Student student : list) { // 정수 출력
            System.out.print(function.applyAsInt(student) + " ");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        System.out.println("[학생 이름]");
        printString( t -> t.getName() );
        
        System.out.println("[영어 점수]");
        printInt( t -> t.getEnglishScore() );
        
        System.out.println("[수학 점수]");
        printInt( t -> t.getMathScore() );
    }
}
 
cs

 Function1 함수적 인터페이스2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package sec05.exam04_function;
 
import java.util.Arrays;
import java.util.List;
import java.util.function.ToIntFunction;
 
public class FunctionExample2 {
    private static List<Student> list = Arrays.asList(
        new Student("홍길동", 90, 96),
        new Student("신용권", 95, 93)
    );
    
    public static double avg(ToIntFunction<Student> function) {
        int sum = 0;
        for(Student student : list) {
            sum += function.applyAsInt(student);
        }
        double avg = (double) sum / list.size();
        return avg;
    }
    
    public static void main(String[] args) {
        double englishAvg = avg( s -> s.getEnglishScore() );
        System.out.println("영어 평균 점수: " + englishAvg);
        
        double mathAvg = avg( s -> s.getMathScore() );
        System.out.println("수학 평균 점수: " + mathAvg);
    }
}
cs




14.5.4 Operator 함수적 인터페이스

- Operator 함수적 인터페이스의 특징은 Function과 동일하게 매개변수와 리턴값이 있는 applyXXX() 메소드를 가지고 있다. 하지만 이들의 메소드는 매개값을 리턴값으로 매핑(타입변환)하는 역할보다는 매개값을 이용해서 연산을 수행한 후 동일한 타입으로 리턴값을 제공하는 역할을 한다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package sec05.exam05_operator;
 
import java.util.function.IntBinaryOperator;
 
public class OperatorExample {
    private static int[] scores = { 92, 95, 87 };
    
    public static int maxOrMin(IntBinaryOperator operator) {
        int result = scores[0];
        for(int score : scores) {
            result = operator.applyAsInt(result, score);
        }
        return result;
    }
    
    public static void main(String[] args) {
        //최대값 얻기
        int max = maxOrMin(
            (a, b) -> {
                if(a>=b) return a;
                else return b;
            }
        );
        System.out.println("최대값: " + max);
        
        //최소값 얻기
        int min = maxOrMin(
            (a, b) -> {
                if(a<=b) return a;
                else return b;
            }
        );
        System.out.println("최소값: " + min);
    }
}
cs



14.5.5 Predicate 함수적 인터페이스



 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package sec05.exam06_predicate;
 
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
 
public class PredicateExample {
    private static List<Student> list = Arrays.asList(
            new Student("홍길동", "남자", 90),
            new Student("김순희", "여자", 90),
            new Student("감자바", "남자",  95),
            new Student("박한나", "여자", 92)
    );
        
    public static double avg(Predicate<Student> predicate) {
        int count = 0, sum = 0;
        for(Student student : list) {
            if(predicate.test(student)) {
                count++;
                sum += student.getScore();
            }
        }
        return (double) sum / count;
    }
        
    public static void main(String[] args) {
        double maleAvg = avg( t ->  t.getSex().equals("남자") );
        System.out.println("남자 평균 점수: " + maleAvg);
            
        double femaleAvg = avg( t ->  t.getSex().equals("여자") );
        System.out.println("여자 평균 점수: " + femaleAvg);
    }
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package sec05.exam06_predicate;
 
public class Student {
    private String name;
    private String sex;
    private int score;
    
    public Student(String name, String sex, int score) {
        this.name = name;
        this.sex = sex;
        this.score = score;
    }
 
    public String getSex() { return sex; }
    public int getScore() { return score; }
}
cs








저작자표시 비영리 동일조건

'JAVA > CONCEPT' 카테고리의 다른 글

JAVA chapter14. 람다식. 14.6 메소드 참조 // 추가하기  (0) 2017.12.02
JAVA chapter14. 람다식. 14.5 표준 API의 함수적 인터페이스 (2)  (0) 2017.12.01
JAVA chapter14. 람다식. 14.4 클래스 멤버와 로컬 변수 사용  (0) 2017.12.01
JAVA chapter14. 람다식. 14.1 람다식이란?. 14.2 람다식 기본 문법. 14.3 타겟 타입과 함수적 인터페이스  (0) 2017.11.30
JAVA chapter13. 제네릭. 13.5 제한된 타입 파라미터(<T extends 최상위타입>)  (0) 2017.11.30
Posted by 너래쟁이
:

티스토리툴바