[윤성우 열혈자바] 27-2. 정의되어 있는 함수형 인터페이스

미리 정의되어 있는 함수형 인터페이스

default boolean removeIf(Predicate<? super E> filter)

-> Collection<E> 인터페이스에 정의되어 있는 디폴트 메소드

Predicate 인터페이스의 추상 메소드는 다음과 같이 정의해 두었다.

boolean test(T t);

@FunctionalInterface

public interface Predicate<T> {

boolean text(T t);

}

미리 정의해 두었으므로 Predicate라는 이름만으로 통한다!

대표 선수들!!!

Predicate<T>                boolean test(T t)

전달 인자를 근거로 참 또는 거짓을 반환

Supplier<T>                 T get()

메소드 호출 시 무엇인가를 제공함

Consumer<T>                void accept(T t)

무엇인가를 받아 들이기만 함

Function<T, R>             R apply(T t)

입출력 출력이 있음(수학적으로는 함수)

java.util.function 패키지로 묶여 있음!

Predicate<T>

boolean test(T t);

public static int sum(Predicate<Integer> p, List<Integer> lst) {

int s = 0;

for(int n : lst) {

if(p.test(n))

s += n;

}

return s;

}

public static void main(String[] args) {

List<Integer> list = Arrays.asList(1, 5, 7, 9, 11, 12);

int s;

s = sum(n -> n%2 == 0, list);

System.out.println("짝수 합 : " + s);

s = sum(n -> n%2 != 0, list);

System.out.println("홀수 합 : " + s);

}

Predicate<T>를 구체화하고 다양화 한 인터페이스들

IntPredicate                         boolean test(int value)

LongPredicate                      boolean test(long value)

DoublePredicate                   boolean test(double value)

BiPredicate<T, U>                 boolean test(T t, U u)

public static int sum(Predicate<Integer> p, List<Integer> lst) { . . . }

-> 변경 가능!

public static int sum(IntPredicate p, List<Integer> lst) { . . . }

대체 가능! 그리고 박싱, 언박싱 과정이 필요 없어짐!

Supplier<T> - 제공자

T get();

public static List<Integer> makeIntList(Supplier<Integer> s, int n) {

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

for (int i = 0; i < n; i++)

list.add(s.get());            // 난수를 생성해 담는다.

return list;

}

public static void main(String[] args) {

Supplier<Integer> spr = ( ) -> {

Random rand = new Random();

return rand.nextInt(50);            // 0부터 50-1 까지 범위 중 난수

};

List<Integer> list = makeIntList(spr, 5);

System.out.println(list);

list = makeIntList(spr, 10);

System.out.println(list);

}

Supplier<T>를 구체화 한 인터페이스들

IntSupplier                int getAsInt()

LongSupplier             long getAsLong()

DoubleSupplier          double getAsDouble()

BooleanSupplier         boolean getAsBoolean()

public static List<Integer> makeIntList(Supplier<Integer> s, int n) { . . . }

-> 변경

public static List<Integer> makeIntList(IntSupplier s, int n) { . . . }

대체 가능! 그리고 박싱, 언박싱 과정이 필요 없어짐

Consumer<T>

void accept(T t);

class ConsumerDemo {

public static void main(String[] args) {

Consumer<String> c = s -> System.out.println(s);

c.accept("Pineapple");                    // 출력이라는 결과를 보임

c.accept("Strawberry");

}

}

Consumer<T>를 구체화하고 다양화 한 인터페이스들

IntConsumer                        void accept(int value)

ObjIntConsumer<T>              void accept(T t, int value)

LongConsumer                     void accept(long value)

ObjLongConsumer<T>           void accept(T t, long value)

DoubleConsumer                   void accept(double value)

ObjDoubleConsumer<T>         void accept(T t, double value)

BiConsumer<T, U>                 void accept(T t, U u)

Consumer<String> c = s -> System.out.println(s);

ObjIntConsumer<String> c = (s, i) -> System.out.println( i + ". " + s);

Function<T, R>

R apply(T t);

class FunctionDemo {

public static void main(String[] args) {

Function<String, Integer> f = s -> s.length();

System.out.println(f.apply("Robot"));

System.out.println(f.apply("System"));

}

}

추가로!

Function<T, R>                  R apply(T t)

BiFunction<T, U, R>            R apply(T t, U u)

앞서 소개한 인터페이스들

UnaryOperator<T>             T apply(T t)

BinaryOperator<T>            T apply(T t1, T t2)

T와 R을 일치시킨 인터페이스들

removeIf 메소드를 사용해 보자 1

Collection<E> 인터페이스의 디폴트 메소드

default boolean removeIf(Predicate<? super E> filter)

ArrayList<Integer> 인스턴스의 removeIf

public boolean removeIf(Predicate<? super Integer> filter)

removeIf 메소드의 기능

"Removes all of the elements of this collection that satisfy the given predicate"

removeIf 메소드를 사용해 보자 2

public static void main(String[] args) {

List<Integer> ls1 = Arrays.asList(1, -2, 3, -4, 5);

ls1 =  new ArrayList<>(ls1);

List<Double> ls2 = Arrays.asList(-1.1, 2.2, 3.3, -4.4, 5.5);

ls2 = new ArrayList<>(ls2);

Predicate<Number> p = n -> n.doubleValue() < 0.0;                 

// 삭제의 조건 - Integer, Double 모두 만족하기 위해 Number!!

ls1.removeIf(p);                        // List<Integer> 인스턴스에 전달

ls2.removeIf(p);                        // List<Double> 인스턴스에 전달

System.out.println(ls1);

System.out.println(ls2);

}