java.util.function 패키지

java.util.function 패키지

- 자주 사용되는 다양한 함수형 인터페이스를 제공

1) java.lang.Runnable // java.util.function 패키지는 아님 

void run() : 매개변수도 없고, 반환값도 없음

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("This is running in a thread.");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();  // This will invoke the run() method of MyRunnable in a new thread.
    }
}

public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        System.out.println("running in a thread");
    });
    thread.start(); //run()호
}

2) Supplier<T> (공급자)

T get() : 매개변수는 없고, 반환 값만 있음

Gets a result.

Returns: a result

3) Consumer<T> (소비자)

void accept(T t) : Supplier와 반대로 매개변수만 있고, 반환값이 없음

Performs this operation on the given argument.

Parameters:

t - the input argument

 

4) Function<T, R> (함수)

R apply(T t) : 일반적인 함수, 하나의 매개변수를 받아서 결과를 반환

Applies this function to the given argument.

Parameters:

t - the function argument

Returns:

the function result

 

5) Predicate<T> (조건식)

boolean test(T t) : 조건식을 표현하는데 사용됨. 매개변수는 하나, 반환 타입은 boolean

**원래는 Function<T,R>처럼 Predicate<Integer, Boolean> 이라고 써야 하지만 반환타입이 항상 Boolean이기 때문에 표시하지 않는다.

Evaluates this predicate on the given argument.

Parameters:

t - the input argument

Returns: true if the input argument matches the predicate, otherwise false

ex)

Predicate<String> isEmptyStr = s->s.length() == 0; (반환 타입 boolean)

String s = "";

 

if(isEmptyStr.test(s)) // if(s.length()==0)

      System.out.println("This is an empty String.");

 

Supplier<Integer> f = () -> (int) (Math.random()*100)+1; //매개변수 없음. 난수 반환. (주기만 하는 공급자)

Consumer<Integer>  f = i -> System.out.println(i+", "); //매개 변수 있고, 반환 값(x) (받기만 하는 소비자)

Predicate<Integer> f = i -> i%2==0; // (조건식)

Function<Integer, Integer> f = i -> i/10*10; //매개 변수 있음. 결과를 반환.

 

매개변수가 2개인 함수형 인터페이스

1) BiConsumer<T,U>

void accept(T t , U u) : 두개의 매개변수만 있고, 반환값이 없음

Performs this operation on the given arguments.

Type Parameters:
T - the type of the first argument to the operation
U - the type of the second argument to the operation

 

BiConsumer<Integer, Integer> printSum = (a, b) -> System.out.println("Sum: " + (a + b));
BiConsumer<Integer, Integer> printProduct = (a, b) -> System.out.println("Product: " + (a * b));

BiConsumer<Integer, Integer> combinedConsumer = printSum.andThen(printProduct);

combinedConsumer.accept(5, 3);

output:

Sum: 8
Product: 15

 

2) BiPredicate<T, U>

boolean test(T t, U u) : 조건식을 표현하는데 사용됨, 매개변수는 둘, 반환값은 boolean

Evaluates this predicate on the given arguments.

Parameters:

t - the first input argument

u - the second input argument

Returns: true if the input arguments match the predicate, otherwise false

 

BiPredicate<Integer, Integer> biPredicate = (num1, num2) -> num1 > 10 && num2 < 5;
boolean result = biPredicate.test(15, 3);  // return true

 

3) BiFunction<T, U, R>

R apply(T t, U u) : 두 개의 매개변수를 받아서 하나의 결과를 반환

Applies this function to the given arguments.

Parameters:

t - the first function argument

u - the second function argument

Returns:the function result

BiFunction<Integer, Integer, String> biFunction = (num1, num2) -> "Result: " + (num1 + num2);

 

BiSupplier x 

 

3개 이상 (직접 구현)

interface Tri Function<T,U,V,R> {

    R apply (T t, U u, V v);

}

TriFunction<Integer, Integer, Integer, Integer> addThreeNumbers = (a, b, c) -> a + b + c;
int result = addThreeNumbers.apply(1, 2, 3);  // 6

 

 

매개변수의 타입과 반환타입이 일치하는 함수형 인터페이스

1) UnaryOperator<T> 단항연산자

T apply(T t) : Fuction의 자손, Function과 달리 매개변수와 결과의 타입이 같다.

 

public interface Function<T, R>{

        R apply (T t);

        ...

}

public interface UnaryOperator<T> extends Function<T, T>{  //Function을 상속받음

      static <T> UnaryOperator<T> identity{ //항등함수

           return t->t;

      }

}

 

2) BinaryOperator<T> 이항연산자

T apply(T t, T t) : BiFunction의 자손, BiFunction과 달리 매개변수와 결과의 타입이 같다.

 

public interface BiFunction<T, U, R> {
    R apply(T t, U u);
    // ... 
}

public interface BinaryOperator<T> extends BiFunction<T, T, T> {
    // ...
}

BinaryOperator<Integer> add = (a, b) -> a + b;
BinaryOperator<Integer> subtract = (a, b) -> a - b;
BinaryOperator<Integer> multiply = (a, b) -> a * b;

 

public static void main(String[] args) {
    BinaryOperator<Integer> add = (a, b) -> a + b;
    BinaryOperator<Integer> subtract = (a, b) -> a - b;
    BinaryOperator<Integer> multiply = (a, b) -> a * b;

    System.out.println(add.apply(5, 3));        // Outputs: 8
    System.out.println(subtract.apply(5, 3));   // Outputs: 2
    System.out.println(multiply.apply(5, 3));   // Outputs: 15
}

 

public static void main(String[] args) {

Supplier<Integer> s = ()->(int)(Math.random()*100)+1;

Consumer<Integer> c = i->System.out.print(i+ ", ");

Predicate<Integer> p = i -> i%2==0;

Function<Integer, Integer> f = i -> i/10*10; //일의 자리 제거

 

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

makeRandomList(s, list);

System.out.println(list);

printEvenNum(p, c, list);

List<Integer> newList = doSometing(f,list);

System.out.println(newList);

}

 

//Function<Integer, Integer> f = i -> i/10*10; //일의 자리 제거

static <T> List<T> doSometing(Function<T, T> f, List<T> list) {

List<T> newList = new ArrayList<T>(list.size());

 

for(T i : list) {

newList.add(f.apply(i));

}

return newList;

}

 

//Predicate<Integer> p = i -> i%2==0;

//Consumer<Integer> c = i->System.out.print(i+ ", ");

static <T> void printEvenNum(Predicate<T> p, Consumer<T> c, List<T> list) {

System.out.print("[");

for(T e: list) {

if(p.test(e)) { //짝수인지 검사

c.accept(e);

}

}

System.out.print("]");

}

static <T> void makeRandomList(Supplier<T> s, List<T> list) {

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

list.add(s.get());

}

}

 

output :

[24, 7, 47, 19, 80, 43, 2, 89, 73, 53]

[24, 80, 2, ][20, 0, 40, 10, 80, 40, 0, 80, 70, 50]

참고 : https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

java.util.function (Java Platform SE 8 )