<div id="readability-page-1" class="page"><div><div><h2 id="bb0f">Functional Interface ?</h2><div><a rel="noopener" href="/@sindepal?source=post_page-----a9e33ac8725d--------------------------------"><img alt="신상훈" src="https://miro.medium.com/fit/c/56/56/0*IyUJXQViJJEmVWaW.jpg" width="28" height="28"></a></div></div>* Cousumer&lt;T&gt; 리턴하지 않고 인자를 받는 메서드를 갖고 있다. 인자를 받아 소모한다* Function&lt;T, R&gt; 하나의 인자와 리턴타입을 가지며 제네렉으로 지정할수 있다.* Predicatie&lt;T&gt; 하나의 인지와 리턴타입을 갖는다. Function과 비슷해 보이지만 리턴타입을 지정하는 타입 파라미터가 없다. 반환 타입은 boolean 타입으로 고정 되며 Function&lt;T, Boolean&gt; 형태로 보면 된다.* Comparator&lt;T&gt; 객체간 우선순위를 비교할 때 사용하는 인터페이스이며 1회성 구현에 많이 사용한다. 람다의 등장으로 구현이 간결해진다.* Supplier&lt;T&gt; 매개변수를 받지 않고 특정 타입의 결과를 리턴. Consumer 와 반대이며 Consumer가 공급자 이고 Supplier가 공급자라고 구분 할수있다.* Operator&lt;T&gt; 하나의 매개변수를 받고 동일한 타입을 리턴. Function 인터페이스를 상속하고 있으며 매개편수에 따라 두가지 Operator 가 있다. ( UnaryOperator : 매개변수 1개, BinaryOperator : 매개변수 2개)<h2 id="e5fe">Functional interface 01</h2><pre>package stream;import java.util.Arrays; import java.util.List; import java.util.function.BinaryOperator; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate;public class FunctionalInterFaces_01 { public static void main(String[] args) { List&lt;Integer&gt; numbers = Arrays.asList(1,2,3,4,5,6,7); //Simple numbers.stream() .filter( x -&gt; x % 2 == 0 ) .map( x -&gt; x * x ) .forEach( System.out::println ); Predicate&lt;Integer&gt; isEvenPredicate_1 = x -&gt; x % 2 == 0; //custom Predicate Predicate&lt;Integer&gt; isEvenPredicate_2 = new Predicate&lt;Integer&gt;() { <a href="http://twitter.com/Override" rel="noopener nofollow">@Override</a> public boolean test(Integer x) { return x%2 == 0; } }; Function&lt;Integer, Integer&gt; squareFunction_1 = x-&gt; x*x; //custom Function Function&lt;Integer, Integer&gt; squareFunction_2 = new Function&lt;Integer, Integer&gt;() { <a href="http://twitter.com/Override" rel="noopener nofollow">@Override</a> public Integer apply(Integer x) { return x*x; } }; Consumer&lt;Integer&gt; sysoutConsumer_1 = System.out::println;//custom Consumer Consumer&lt;Integer&gt; sysoutConsumer_2 = new Consumer&lt;Integer&gt;() { public void accept(Integer x) { System.out.println(x); } }; numbers.stream() .filter(isEvenPredicate_1) .map(squareFunction_1) .forEach(sysoutConsumer_1); numbers.stream() .filter(isEvenPredicate_2) .map(squareFunction_2) .forEach(sysoutConsumer_2); BinaryOperator&lt;Integer&gt; sumBinaryOperator_0 = (x,y) -&gt; x + y; BinaryOperator&lt;Integer&gt; sumBinaryOperator_1 = Integer::sum; BinaryOperator&lt;Integer&gt; sumBinaryOperator_2 = new BinaryOperator&lt;Integer&gt;() { <a href="http://twitter.com/Override" rel="noopener nofollow">@Override</a> public Integer apply(Integer a , Integer b) { return a + b; } }; numbers.stream() .reduce(0, sumBinaryOperator_2); } }</pre><h2 id="062f">Functional interface 02</h2><pre>package stream;import java.util.Arrays; import java.util.List; import java.util.function.BinaryOperator; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; import java.util.stream.Collectors;public class FunctionInterfaceBehaviorParameterization { public static void main(String[] args) { List&lt;Integer&gt; numbers = Arrays.asList(1,2,3,4,5,6,7); //Simple Predicate&lt;? super Integer&gt; evenPredicate = x -&gt; x % 2 == 0; // Step1 // numbers.stream() // .filter( evenPredicate ) // .forEach( System.out::println ); // Step 2 Create Extrect Method // filterAndPrint(numbers, evenPredicate); filterAndPrint(numbers, x -&gt; x % 2 == 0);//Simple Predicate&lt;? super Integer&gt; oddPredicate = x -&gt; x % 2 != 0; // Step 1 // numbers.stream() // .filter( oddPredicate ) // .forEach( System.out::println ); // Step 2 Create Extrect Method // filterAndPrint(numbers, oddPredicate); filterAndPrint(numbers, x -&gt; x % 2 != 0); Function&lt;Integer, Integer&gt; mappingFuntion = x -&gt; x * x; // mapAndCreateNewList(numbers, mappingFuntion); List&lt;Integer&gt; squaredNumber = mapAndCreateNewList(numbers, x -&gt; x * x); List&lt;Integer&gt; cubedNumber = mapAndCreateNewList(numbers, x -&gt; x * x * x); List&lt;Integer&gt; doubleNumber = mapAndCreateNewList(numbers, x -&gt; x + x); }private static List&lt;Integer&gt; mapAndCreateNewList(List&lt;Integer&gt; numbers, Function&lt;Integer, Integer&gt; mappingFuntion) { return numbers.stream() .map( mappingFuntion ) .collect(Collectors.toList()); } //command + option + m Extrect Method private static void filterAndPrint(List&lt;Integer&gt; numbers, Predicate&lt;? super Integer&gt; oddPredicate) { numbers.stream() .filter( oddPredicate ) .forEach( System.out::println ); } }</pre><h2 id="1e7b">Functional interface 03</h2><pre>package stream;import java.util.Arrays; import java.util.List; import java.util.Random; import java.util.function.BinaryOperator; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; import java.util.function.UnaryOperator;public class FunctionalInterFaces_03 { public static void main(String[] args) { List&lt;Integer&gt; numbers = Arrays.asList(1,2,3,4,5,6,7); Predicate&lt;Integer&gt; isEvenPredicate_1 = x -&gt; x % 2 == 0; Function&lt;Integer, Integer&gt; squareFunction_1 = x-&gt; x*x; Function&lt;Integer, String&gt; stringOutputFunction_1 = x-&gt; x + “ value”; Consumer&lt;Integer&gt; sysoutConsumer_1 = System.out::println; BinaryOperator&lt;Integer&gt; sumBinaryOperator = (x, y) -&gt; x + y; //No input &gt; Return Something Supplier&lt;Integer&gt; integerSupplier = () -&gt; 2; Supplier&lt;Integer&gt; reandomIntegerSupplierFunc = () -&gt; { Random random = new Random(); return random.nextInt(1000); }; System.out.println(integerSupplier.get()); System.out.println(reandomIntegerSupplierFunc.get()); UnaryOperator&lt;Integer&gt; unaryOperator = (x) -&gt; x * 3; System.out.println(unaryOperator.apply(10)); } }</pre></div></div>

Stories by 신상훈 on Medium

Functional Interface ?
* Cousumer<T> 
 리턴하지 않고 인자를 받는 메서드를 갖고 있다. 인자를 받아 소모한다
* Function<T, R>
하나의 인자와 리턴타입을 가지며 제네렉으로 지정할수 있다.
* Predicatie<T> 
하나의 인지와 리턴타입을 갖는다. Function과 비슷해 보이지만 리턴타입을 지정하는 타입 파라미터가 없다. 반환 타입은 boolean 타입으로 고정 되며 Function<T, Boolean> 형태로 보면 된다.
* Comparator<T>
객체간 우선순위를 비교할 때 사용하는 인터페이스이며 1회성 구현에 많이 사용한다. 
람다의 등장으로 구현이 간결해진다.
* Supplier<T>
매개변수를 받지 않고 특정 타입의 결과를 리턴. 
Consumer 와 반대이며 Consumer가 공급자 이고 Supplier가 공급자라고 구분 할수있다.
* Operator<T>
하나의 매개변수를 받고 동일한 타입을 리턴. Function 인터페이스를 상속하고 있으며 매개편수에 따라 두가지 Operator 가 있다. 
 ( UnaryOperator : 매개변수 1개, BinaryOperator : 매개변수 2개)
Functional interface 01
package stream;
import java.util.Arrays;
import java.util.List;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
public class FunctionalInterFaces_01 {
 public static void main(String[] args) {
 List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7);
 //Simple
 numbers.stream()
 .filter( x -> x % 2 == 0 )
 .map( x -> x * x )
 .forEach( System.out::println );
 
 Predicate<Integer> isEvenPredicate_1 = x -> x % 2 == 0; 
 //custom Predicate
 Predicate<Integer> isEvenPredicate_2 = new Predicate<Integer>() {
 @Override
 public boolean test(Integer x) {
 return x%2 == 0;
 }
 };
 Function<Integer, Integer> squareFunction_1 = x-> x*x;
 //custom Function 
 Function<Integer, Integer> squareFunction_2 = new Function<Integer, Integer>() {
 @Override
 public Integer apply(Integer x) {
 return x*x;
 }
 };
 Consumer<Integer> sysoutConsumer_1 = System.out::println;
//custom Consumer
 Consumer<Integer> sysoutConsumer_2 = new Consumer<Integer>() {
 public void accept(Integer x) {
 System.out.println(x);
 }
 };
 
 numbers.stream()
 .filter(isEvenPredicate_1)
 .map(squareFunction_1)
 .forEach(sysoutConsumer_1);
 
 numbers.stream()
 .filter(isEvenPredicate_2)
 .map(squareFunction_2)
 .forEach(sysoutConsumer_2);
 
 BinaryOperator<Integer> sumBinaryOperator_0 = (x,y) -> x + y;
 BinaryOperator<Integer> sumBinaryOperator_1 = Integer::sum;
 BinaryOperator<Integer> sumBinaryOperator_2 = new BinaryOperator<Integer>() {
 @Override
 public Integer apply(Integer a , Integer b) {
 return a + b;
 }
 };
 numbers.stream()
 .reduce(0, sumBinaryOperator_2);
 
 }
}
Functional interface 02
package stream;
import java.util.Arrays;
import java.util.List;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class FunctionInterfaceBehaviorParameterization {
 public static void main(String[] args) {
 List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7);
 //Simple
 Predicate<? super Integer> evenPredicate = x -> x % 2 == 0;
 // Step1 
// numbers.stream()
// .filter( evenPredicate )
// .forEach( System.out::println );
 // Step 2 Create Extrect Method 
// filterAndPrint(numbers, evenPredicate);
 filterAndPrint(numbers, x -> x % 2 == 0);
//Simple
 Predicate<? super Integer> oddPredicate = x -> x % 2 != 0;
 // Step 1
// numbers.stream()
// .filter( oddPredicate )
// .forEach( System.out::println );
 
// Step 2 Create Extrect Method
// filterAndPrint(numbers, oddPredicate);
 filterAndPrint(numbers, x -> x % 2 != 0);
 
 Function<Integer, Integer> mappingFuntion = x -> x * x;
 // mapAndCreateNewList(numbers, mappingFuntion);
 List<Integer> squaredNumber = mapAndCreateNewList(numbers, x -> x * x);
 List<Integer> cubedNumber = mapAndCreateNewList(numbers, x -> x * x * x);
 List<Integer> doubleNumber = mapAndCreateNewList(numbers, x -> x + x);
 
 }
private static List<Integer> mapAndCreateNewList(List<Integer> numbers, Function<Integer, Integer> mappingFuntion) {
 return numbers.stream()
 .map( mappingFuntion )
 .collect(Collectors.toList());
 }
 //command + option + m Extrect Method
 private static void filterAndPrint(List<Integer> numbers, Predicate<? super Integer> oddPredicate) {
 numbers.stream()
 .filter( oddPredicate )
 .forEach( System.out::println );
 }
}
Functional interface 03
package stream;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
public class FunctionalInterFaces_03 {
 public static void main(String[] args) {
 List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7);
 Predicate<Integer> isEvenPredicate_1 = x -> x % 2 == 0; 
 Function<Integer, Integer> squareFunction_1 = x-> x*x;
 Function<Integer, String> stringOutputFunction_1 = x-> x + “ value”;
 Consumer<Integer> sysoutConsumer_1 = System.out::println;
 BinaryOperator<Integer> sumBinaryOperator = (x, y) -> x + y;
 //No input > Return Something
 Supplier<Integer> integerSupplier = () -> 2;
 Supplier<Integer> reandomIntegerSupplierFunc = () -> {
 Random random = new Random();
 return random.nextInt(1000);
 };
 System.out.println(integerSupplier.get());
 System.out.println(reandomIntegerSupplierFunc.get());
 UnaryOperator<Integer> unaryOperator = (x) -> x * 3;
 System.out.println(unaryOperator.apply(10));
 
 }
}

Java Stream-Step 3 Functional Interface

댓글