Recent Posts
Recent Comments
일 | 월 | 화 | 수 | 목 | 금 | 토 |
---|---|---|---|---|---|---|
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 |
Tags
- 파일 저장
- 프로그래밍
- MySQL
- 셀레니움
- 유튜브
- 프로그래머스
- 파이썬
- 세션
- 모바일
- n^2 배열 자르기
- Python
- 메모장
- Programmers
- js
- 함수형 인터페이스
- 크롤링
- jdbc
- javascript
- java
- 자바스크립트
- 자바
- 입출력
- 개발자
- 개발
- jsp
- 형태소 분석기
- 코딩
- 이진 변환 반복하기
- 데이터베이스
- android
Archives
- Today
- Total
개인용 복습공간
[Java] 람다식과 함수형 인터페이스 - 2 본문
함수형 인터페이스에 대해 자세히 알아보려 한다.
함수형 인터페이스 응용
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 인터페이스 유형
- 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<String, String> 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 인터페이스 유형
- 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 인터페이스 유형
- 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 |
- Function 인터페이스 실습하기 (2) [ [Java] 람다식과 함수형 인터페이스 - 1 에서 했던 Car.java 이용 ]
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 |
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(1, 2));
List<Integer> list = new ArrayList<>();
list.add(5);
list.add(6);
list.add(7);
list.replaceAll(e -> e + 10);
System.out.println(list);
}
}
|
cs |
- Operator 인터페이스 실습하기 (2) [ [Java] 람다식과 함수형 인터페이스 - 1 에서 했던 Car.java 이용 ]
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(10, 5));
System.out.println(o1.apply(20, 25));
BinaryOperator<Integer> o2 = BinaryOperator.minBy(comparator);
System.out.println(o2.apply(10, 5));
System.out.println(o2.apply(20, 25));
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 |
Comparator 인터페이스
Comparator 인터페이스 유형
- 객체의 순서를 정하기 위하여 사용되는 함수형 인터페이스이다.
- compare()라는 추상 메서드 외에도 유용한 정적 메서드와 디폴드 메서드를 제공하며, 메서드의
반환 타입은 모두 Comparator <T> 타입이다.
- Comparator 인터페이스 실습하기 (1) [ [Java] 람다식과 함수형 인터페이스 - 1 에서 했던 Car.java 이용 ]
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(0, 3);
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 |
- Comparator 인터페이스 실습하기 (2) [ [Java] 람다식과 함수형 인터페이스 - 1 에서 했던 Car.java 이용 ]
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(0, 3);
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(2, new Car("코란도", false, 10, 220000));
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 |
'Java' 카테고리의 다른 글
[Java] 파일 채널 ,메모장 만들기 -3 (0) | 2021.05.25 |
---|---|
[Java] 메모장 만들기 - 2 (0) | 2021.05.21 |
[Java] 메모장 만들기 - 1 (0) | 2021.05.19 |
[Java] 스트림과 스트림을 이용한 입출력 (0) | 2021.05.18 |
[Java] 람다식과 함수형 인터페이스 - 1 (1) | 2021.05.08 |
Comments