JAVA ( 함수형인터페이스 )

 

 

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

 

Runnaber   -->   void run()      --> 매개변수도 O, 반환값도 X.

Supplier <T>   -->   T get()      --> 매개변수는 X, 반환값만 O.

Customer <T> -->  void accept (T t)    -->  매개변수만 O, 반환값은 X.

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

Predicate <T>  -->  boolean test (T t)  --> 조건식 표현하는데 사용, 매개변수는 하나. 반환은 boolean

 

 

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

 

BiConsumer <T,U>  -->  void accept (T t, U u)   --> 두개의 매개변수만 O, 반환값이 X

BiPredicate <T,U>  -->  boolean test (T t, U u)   --> 조건식표현하는데 사용, 매개변수는 둘. 반환은 boolaen

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

 

 

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

 

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

-단항연산자

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

-이항연산자

 

 

import java.util.ArrayList;
import java.util.List;
import java.util.function.*;

public class Example3 {
	public static void main(String[] args) {

		Supplier<Integer> s = () -> (int)(Math.random()*100)+1;    // 1~100  난수
		Consumer<Integer> c = i -> System.out.print( i + ", ");   // 출력문
		Predicate<Integer> p = i -> i % 2 ==0;               // 짝수인지 검사
		Function<Integer, Integer> f = i -> i/10*10;    // i의 일이자리를 없앰
		
		List<Integer> list = new ArrayList<>();
		makeRandomList( s, list );      // list를 랜덤값으로 채움
		System.out.println(list);
		printEvenNum( p, c, list);      // 짝수 출력
		
		List<Integer> newList = doSomething( f, list);  // 10의자리 골라내는 list만들기
		System.out.println(newList);
	}
	
//	Function<Integer, Integer> f = i -> i/10*10;    // i의 일이자리를 없앰
	static <T> List<T> doSomething( Function< T,T > f, List<T> list ) {
		List<T> newList = new ArrayList<T>(list.size());    //list와 같은사이즈 newList 만들기
		
		for( T i : list ) {
			newList.add( f.apply(i) );    // 일의자리를 없애서 newList에 저장.
		}
		return newList;
	}
	
//	Consumer<Integer> c = i -> System.out.print( i + ", ");   // 출력문
//	Predicate<Integer> p = i -> i % 2 ==0;               // 짝수인지 검사  <--이 두개를 매개로.
	static <T> void printEvenNum(Predicate<T> p, Consumer<T> c, List<T> list) {
		System.out.print("[");
		for( T i : list ) {       // list모든요소를 꺼내서
			if( p.test(i)) {      // 짝수인지 검사.
				c.accept(i);      // true 라면  화면에 출력.
			}
		}
		System.out.println("]");
	}
	
	static <T> void makeRandomList(Supplier<T> s, List<T> list) {
		for( int i=0; i < 10 ; i++ ) {
			list.add(s.get());       // Supplier로부터 1~100 난수 받아서 list 추가
		}
	}
}

 

 

*** Predicate  의 결합.

 

--and ()  on ()  negate()  으로 두 Predicate를 하나로 결합 

 

Predicate<Integer> p =     i   ->   i <100 ;

Predicate<Integer> q =     i   ->   i <200 ;

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

Predicate<Integer> notP  =  p.negate() ;          ::  i >= 100 

Predicate<Integer>  all     = notP. and(q). or(r)     :: 100 <= i  &&  i < 200  ||  i%2 ==0 

Predicate<Integer> all2    = notP. and( q.or(r) )    ::  100 <= i  &&  ( i < 200 || i%2 ==0 ) 

 

import java.util.function.Function;
import java.util.function.Predicate;

public class Example4 {

	public static void main(String[] args) {
       //        입력값 , 출력값 
		Function<String, Integer>  f  = (s) -> Integer.parseInt( s, 16 );
		Function<Integer, String>  g  = (i) -> Integer.toBinaryString(i);
	   //         입력 , 출력 	
		Function<String, String>   h  =  f.andThen(g);   //function의 연결
		Function<Integer, Integer> h2 =  f.compose(g);   //==g.andthen(f) 
		
		System.out.println(h.apply("FF"));  // FF -> 16진수 255 --> 2진수 1111111
		System.out.println(h2.apply(2));    //  2 ->  "10"  --> 16
		
		Function<String, String> f2 = x -> x ;  //항동함수. x=x
		System.out.println(f2.apply("AAA"));
		
		Predicate<Integer> p = i ->  i < 100;
		Predicate<Integer> q = i ->  i < 200;
		Predicate<Integer> r = i ->  i % 2 == 0;
		Predicate<Integer> notP = p.negate();    //  i >= 100
		Predicate<Integer> all = notP.and(q.or(r));
		System.out.println(all.test(150));
		
		
		String str1 = "abc";
		String str2 = "abc";
		
		Predicate<String> p2 = Predicate.isEqual(str1);   //  abc 를 
		boolean result = p2.test(str2);          //  abc 로 비교
		System.out.println(result);    //  true 
	}
}

 

 

 

• 컬렉션 프레임워크와 함수형 인터페이스

ex))

list.forEach ( i -> System.out.print ( i + " , " )) ;   ::  list 모든 요소를 출력

list.removeIf ( x -> x%2==0  ||  x%3==0 ) ;        ::  2또는 3의 배수 제거

list.replaceAll ( i -> i * 10 )  ;          ::  모든 요소에 10을 곱한다.

 

map.forEach ( ( k , v ) -> System.out.print (" { " + k + ", " + " v " + " }," ) ); 

                                       ::  map 의 모든 요소를 { k , v } 형식으로 출력. 

 

import java.util.*;

public class Example5 {
	public static void main(String[] args) {

		ArrayList<Integer> list = new ArrayList<>();
		for( int i=0 ; i < 10 ; i++) {
			list.add(i);
		}
		list.forEach( i -> System.out.print( i+ ","));   // list 모든요소 출력
		System.out.println();
		
//		Iterator it = list.iterator();
//		while(it.hasNext()) {                    람다식이 없을때 Iterator 사용 (list)
//			System.out.println(it.next());
//		}
			
		list.removeIf( x-> x%2==0 || x%3==0 );     // list의 2,3의 배수 삭제
		System.out.println(list);
		
		list.replaceAll( i -> i*10);      // list의 각 요소에 10을 곱함
		System.out.println(list);
		
		Map<String, String> map = new HashMap<>();
		map.put("1", "1");
		map.put("2", "2");
		map.put("3", "3");
		map.put("4", "4");
		
		map.forEach( (k,v) -> System.out.print("{"+k+","+v+"},"));
		                   // 맵 모든요소 출력.
		
//		Iterator it2 = map.entrySet().iterator();
//		while(it2.hasNext()) {                    람다식이 없을때 Iterator 사용 (map)
//			System.out.println(it2.next());
//		}
	}
}