개인용 복습공간

[Java] 람다식과 함수형 인터페이스 - 2 본문

Java

[Java] 람다식과 함수형 인터페이스 - 2

taehwanis 2021. 5. 12. 23:55

 

 

 

함수형 인터페이스에 대해 자세히 알아보려 한다.

 

 

 

 

함수형 인터페이스 응용

 

Predicate 인터페이스

Predicate 인터페이스 유형

Predicate

  • Bi, Double, Int, Long을 접두어로 붙인 변종이 있다.
  • Predicate 유형은 다음과 같이 정의한다.
    Predicate <T> p = t -> { T 타입 t 객체를 조사하여 논릿값으로 변환하는 실행문; };
  • Predicate 인터페이스 실습하기
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.function.IntPredicate;
import java.util.function.Predicate;
 
public class PredicateEx {
 
    public static void main(String[] args) {
        Predicate <String> p = Predicate.isEqual("Java Lambda");
        System.out.println(p.test("Java Lambda")); //true
        System.out.println(p.test("JavaLambda")); //false
 
        IntPredicate even = x -> x % 2 == 0;
        System.out.println(even.test(3) ? "짝수" : "홀수"); //false 홀수
        
        IntPredicate one = x -> x == 1;
        IntPredicate oneOrEven = one.or(even);
        System.out.println(oneOrEven.test(1) ? "1혹은 짝수" : "1이아닌 홀수"); //true 1혹은 짝수
    }
 
}
 
cs

결과 화면

 

 

 

Consumer 인터페이스

Consumer 인터페이스 유형

Consumer

  • Bi, Double, Int, Long, ObjDouble, ObjInt, ObjLong를 접두어로 붙인 변종이 있다.
  • Consumer 유형은 다음과 같이 정의한다.
    Consumer <T> c = t -> { T 타입 t 객체를 사용한 후 void를 반환하는 실행문; };
  • Consumer 인터페이스 실습하기
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
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.IntConsumer;
import java.util.function.ObjIntConsumer;
 
public class ConsumerEx {
 
    public static void main(String[] args) {
        Consumer<String> c1 = x -> System.out.println(x.toLowerCase());
        c1.accept("Java Functional Interface!!");
        
        BiConsumer<StringString> c2 = (x,y) -> System.out.println(x +" : " + y);
        c2.accept("Java""Lambda");
        
        ObjIntConsumer<String> c3 = (s,x) -> {
            int a = Integer.parseInt(s) + x;
            System.out.println(a);
        };
        c3.accept("99"1);
        
        IntConsumer c4 = x -> System.out.printf("%d + %d\n", x, x, x*x);
        IntConsumer c5 = c4.andThen(x -> System.out.printf("%d + 10 = %d", x, x+10));
        c5.accept(10);
 
    }
 
}
 
cs

결과 화면

 

 

 

Supplier 인터페이스

Supplier 인터페이스 유형

Supplier

  • Double, Int 등을 접두어로 붙인 변종이 있다.
  • Supplier 유형은 다음과 같이 정의한다.
    Supplier <T> s = ( ) -> { T 타입 t 객체를 반환하는 실행문; };
  • Supplier 인터페이스 실습하기
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
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.function.DoubleSupplier;
import java.util.function.IntSupplier;
import java.util.function.Supplier;
 
public class SupplierEx {
 
    public static void main(String[] args) {
        Supplier<String> s1 = () -> "Java Functional Interface!!";
        System.out.println(s1.get());
        
        int[] x = {0};
        
        IntSupplier s2 = () -> x[0]++;
        for(int i=0; i<3; i++) {
            System.out.println(s2.getAsInt());
        } //1,2,3
        
        DoubleSupplier s3 = () -> Math.random() * 10;
        System.out.println(s3.getAsDouble()); //난수*10
        
        SimpleDateFormat fm = new SimpleDateFormat("MM월 dd일(E요일) a hh:mm:ss");
        Supplier<String> s4 = () -> fm.format(new Date());
        System.out.println(s4.get());
    }
 
}
 
cs

결과 화면

 

 

 

Function 인터페이스

Function 인터페이스 유형

Function

  • Bi, Double, IntToDouble, ToDoubleBi 등을 접두어로 붙인 변종이다
  • Function 유형은 다음과 같이 정의한다.
    Function <T, R> f = t -> { T 타입 t 객체를 사용하여 R 타입 객체를 반환하는 실행문; };
  • Function 인터페이스 실습하기 (1)
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
import java.util.function.Function;
import java.util.function.IntToDoubleFunction;
import java.util.function.ToDoubleBiFunction;
 
public class Function1Ex {
 
    public static void main(String[] args) {
        Function<Integer, Integer> add2 = x -> x+2;
        Function<Integer, Integer> mul2 = x -> x*2;
        
        System.out.println(add2.apply(3));
        System.out.println(mul2.apply(3));
        
        System.out.println(add2.andThen(mul2).apply(3));// (3+2)*2 차례대로
        System.out.println(add2.compose(mul2).apply(3));// 2+(3*2) 역순으로
        
        IntToDoubleFunction half = x -> x/2.0;
        System.out.println(half.applyAsDouble(5)); // 5/2.0
        
        ToDoubleBiFunction<String, Integer> circleArea = (s, r) -> Double.parseDouble(s) * r * r ;
        double area = circleArea.applyAsDouble("3.14"5); // 3.14 * 5 * 5
        System.out.println(area);
    }
 
}
 
cs

 

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
import java.util.List;
import java.util.function.Function;
import java.util.function.ToIntFunction;
 
import lect10.Car;
 
public class Function2Ex {
 
    public static void main(String[] args) {
        Function<Car, String> f1 = c -> c.getModel();
        ToIntFunction<Car> f2 = c -> c.getAge();
        
        for(Car car : Car.cars)
            System.out.print("(" + f1.apply(car) + ", " + f2.applyAsInt(car) + ") ");
        System.out.println();
        
        double averageAge = average(Car.cars, c -> c.getAge());
        double averageMileage = average(Car.cars, c -> c.getMileage());
        
        System.out.println("평균 연식 = " + averageAge);
        System.out.println("평균 주행거리 = " + averageMileage);
 
    }
 
    private static double average(List<Car> cars, ToIntFunction<Car> f) {
        double sum = 0.0;
        for(Car car : cars)
            sum += f.applyAsInt(car);
        return sum / cars.size();
    }
 
}
 
cs

좌측(1), 우측(2) 결과 화면

 

 

 

Operator 인터페이스

Operator 인터페이스 유형

Operator

  • Operator라는 인터페이스는 없고
    Binary, Unary, Double, Int, Long을 접두어로 붙인 변종만 있다.
  • BinaryOperator 인터페이스는 다음과 같이 정의한다.
    BinaryOperator <T> o = (x, y) -> { T 타입 x와 y 객체를 사용하여 T 타입을 반환하는 실행문; };
  • Operator 인터페이스 실습하기 (1)
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
import java.util.ArrayList;
import java.util.List;
import java.util.function.IntBinaryOperator;
import java.util.function.IntUnaryOperator;
import java.util.function.UnaryOperator;
 
public class Operator1Ex {
 
    public static void main(String[] args) {
        IntUnaryOperator add2 = x -> x+2;
        System.out.println(add2.applyAsInt(3));
        
        UnaryOperator<Integer> add2again = x -> x+2;
        System.out.println(add2again.apply(3));
        
        IntUnaryOperator mul2 = x -> x*2;
        IntUnaryOperator add2mul2 = add2.andThen(mul2);
        System.out.printf("(3 + 2) * 2 = ");
        System.out.println(add2mul2.applyAsInt(3));
        
        IntBinaryOperator add = (x, y) -> x + y;
        System.out.println(add.applyAsInt(12));
        
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(6);
        list.add(7);
        list.replaceAll(e -> e + 10);
        System.out.println(list);
 
    }
 
}
 
cs

 

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
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.BinaryOperator;
import java.util.function.UnaryOperator;
 
import lect10.Car;
 
public class Operator2Ex {
 
    public static void main(String[] args) {
        Comparator<Integer> comparator = (a, b) -> a - b;
        
        BinaryOperator<Integer> o1 = BinaryOperator.maxBy(comparator);
        System.out.println(o1.apply(105));
        System.out.println(o1.apply(2025));
        
        BinaryOperator<Integer> o2 = BinaryOperator.minBy(comparator);
        System.out.println(o2.apply(105));
        System.out.println(o2.apply(2025));
        
        List<Car> newCars = remodeling(Car.cars, c -> new Car("뉴" +
                c.getModel(), c.isGasoline(), c.getAge(), c.getMileage()));
        System.out.println(newCars);
    }
 
    private static List<Car> remodeling(List<Car> cars, UnaryOperator<Car> o) {
        List<Car> result = new ArrayList<>();
        for(Car car : Car.cars)
            result.add(o.apply(car));
        return result;
    }
 
}
 
cs

좌측(1), 우측(2) 결과 화면

 

 

 

Comparator 인터페이스

Comparator 인터페이스 유형

  • 객체의 순서를 정하기 위하여 사용되는 함수형 인터페이스이다.
  • compare()라는 추상 메서드 외에도 유용한 정적 메서드와 디폴드 메서드를 제공하며, 메서드의
    반환 타입은 모두 Comparator <T> 타입이다.

Comparator 인터페이스의 메서드 종류

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
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
 
import lect10.Car;
 
public class Comparator1Ex {
 
    public static void main(String[] args) {
        List<Car> list = Car.cars.subList(03);
        Car[] cars = list.toArray(new Car[3]);
        
        Comparator<Car> modelComparator
            =Comparator.comparing(Car::getModel);
        
        System.out.println(Arrays.toString(cars));
        Arrays.sort(cars, modelComparator);
        System.out.println(Arrays.toString(cars));
        
        Arrays.sort(cars, modelComparator.reversed());
        System.out.println(Arrays.toString(cars));
        
        Arrays.sort(cars, Comparator.comparingInt(Car::getMileage));
        System.out.println(Arrays.toString(cars));
        
        Arrays.sort(cars, Comparator.comparing(Car::getMileage, (a, b) -> b - a));
        System.out.println(Arrays.toString(cars));
 
    }
 
}
 
cs

 

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
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
 
import lect10.Car;
 
public class Comparator2Ex {
 
    public static void main(String[] args) {
        List<Car> list = Car.cars.subList(03);
        Car[] cars = list.toArray(new Car[4]);
        
        Comparator<Car> modelComparator
            =Comparator.comparing(Car::getModel);
        
        System.out.println(Arrays.toString(cars));
        Comparator<Car> modelComparatorNullsFirst
            = Comparator.nullsFirst(modelComparator);
        Arrays.sort(cars, modelComparatorNullsFirst);
        System.out.println(Arrays.toString(cars));
        
        list.set(2new Car("코란도"false10220000));
        cars = list.toArray(new Car[3]);
        System.out.println(Arrays.toString(cars));
        Comparator<Car> modelNAgeComparator
            = modelComparator.thenComparing(Car::getAge);    
        Arrays.sort(cars, modelNAgeComparator);
        System.out.println(Arrays.toString(cars));
 
    }
 
}
 
cs

좌측(1), 우측(2) 결과 화면

 

Comments