람다식이란?
- 함수형 프로그램이 구현방식
- 클래스를 생성하지 않고 함수의 호출만으로 기능 수행
- 함수형 인터페이스를 선언함
함수형 프로그래밍이란?
- 순수 함수(pure function)를 구현하고 호출
- 매개변수만을 사용하도록 만든 함수로 외부 자료에 부수적인 영향을 발생하지 않도록함
- 입력 받은 자료를 기반으로 수행되고 외부에 영향을 미치지않아 병렬처리가 가능함
- @FunctionalInterFace 를 사용하면 메서드 한개만 선언할 수 있다.
java.util.function 에서 제공하는 함수적 인터페이스는 Consumer, Supplier, Function, Operator, Predicate로 구분된다.
ConSumer 함수적 인터페이스
리턴값이 없는 accept()메서드를 가지고 잇다.
import java.lang.reflect.Member;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
Consumer<Member> consumer = t -> System.out.println(t.name + "은 " + t.company+ " 의 멤버다");
consumer.accept(new Member("Enzo", "Maxst", 1));
BiConsumer<Member, String> biConsumer = (t,u) ->{
t.name = u;
System.out.println("biConsumer 예제 : " +t.name);
};
biConsumer.accept(new Member(), "Mark");
}
static class Member{
String name;
String company;
Integer id;
public Member(String name, String company, int id){
this.name = name;
this.company = company;
this.id = id;
}
public Member(){};
}
}
Supplier 함수적 인터페이스
매개변수가 없고 리턴값이 있는 getXXX()메서드를 가지고 있으며 실행후 호출한 곳으로 데이터 리턴역할
import java.util.ArrayList;
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
Supplier<ArrayList<Integer>> s = () -> {
ArrayList<Integer> list = new ArrayList<>();
for(int i=0; i<5; i++){
list.add(i);
}
return list;
};
ArrayList<Integer> result = s.get();
for(Integer tmp : result){
System.out.println(tmp);
}
}
}
Function 함수적 인터페이스
매개값과 리턴값이 있는 applyXXX()메서드를 가지고 있다. 매개값을 리턴값으로 매핑하는 역할
import java.util.function.BiFunction;
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
Function<Integer, Boolean> function = t -> {
if(t==1)return true;
return false;
};
System.out.println(function.apply(1));
System.out.println(function.apply(2));
Member test1 = new Member("Enzo", "Maxst");
Member test2 = new Member("Finn", "Maxst");
BiFunction<Member, Member, Integer> biFunction = (t,u) ->{
// t = test1;
// u = test2;
if(t.name == u.name)return 200;
return (t.company == u.company)? 300:400;
};
//biFunction.apply(test1,test2);
System.out.println(biFunction.apply(test1,test2));
}
static class Member {
String name ;
String company;
public Member(){};
public Member(String name, String company){
this.name = name;
this.company = company;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
}
Operator 함수적 인터페이스
function과 동일하게 매개변수와 리턴값을 가지고 있는데 매개값을 리턴값으로 매핑하는 역할이 아니라 매개값을 이요해 연산을 수행 후 동일한 타입으로 리턴값을 제공한다.
Predicate 함수적 인터페이스
매개변수와 boolean 리턴값이 있는 testXXX()메서드를 가지고 있으며 매개값을 조사해 boolean을 리턴한다
표준 함수형 인터페이스는 대부분 기본타입만 지원하지만 기본함수형 인터페이스에 박싱된 기본타입을 넣어 사용하지말자 → 이유는? 계산량이 많을때는 성능이 처참해진…댜..
표준 함수형 인터페이스가 아니라 커스텀해야 하는 경우가 발생한다면?
- 자주 쓰이며, 이름 자체가 용도를 명확히 설명해야한다
- 반드시 따라야 하는 규약이 있다.
- 유용한 디폴트 메서드를 제공할 수 있다
이 세가지 중 하나 이상을 만족한다면 구현부를 작성해서 적용 가능
직접 만든 함수형 인터페이스를 사용하려면 @FunctionalInterface 를 사용해야한다. 그 이유는
- 인터페이스가 람다용으로 설계된것을 알려줄때
- 추상 메서드 한개만 가지고 있어야 컴파일 가능
- 메서드를 추가하지 못하도록 막아줌
결론
입력값과 반환값에 함수형 인터페이스 타입을 활용하자 java.util.function패키지의 표준 함수형 인터페이스를 사용하는것이 best이지만 직접 새로운 함수형 인터페이스를 만들어 쓰는 편이 나을 수 있다.
람다식이란?
- 함수형 프로그램이 구현방식
- 클래스를 생성하지 않고 함수의 호출만으로 기능 수행
- 함수형 인터페이스를 선언함
함수형 프로그래밍이란?
- 순수 함수(pure function)를 구현하고 호출
- 매개변수만을 사용하도록 만든 함수로 외부 자료에 부수적인 영향을 발생하지 않도록함
- 입력 받은 자료를 기반으로 수행되고 외부에 영향을 미치지않아 병렬처리가 가능함
- @FunctionalInterFace 를 사용하면 메서드 한개만 선언할 수 있다.
java.util.function 에서 제공하는 함수적 인터페이스는 Consumer, Supplier, Function, Operator, Predicate로 구분된다.
ConSumer 함수적 인터페이스
리턴값이 없는 accept()메서드를 가지고 잇다.
import java.lang.reflect.Member;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
Consumer<Member> consumer = t -> System.out.println(t.name + "은 " + t.company+ " 의 멤버다");
consumer.accept(new Member("Enzo", "Maxst", 1));
BiConsumer<Member, String> biConsumer = (t,u) ->{
t.name = u;
System.out.println("biConsumer 예제 : " +t.name);
};
biConsumer.accept(new Member(), "Mark");
}
static class Member{
String name;
String company;
Integer id;
public Member(String name, String company, int id){
this.name = name;
this.company = company;
this.id = id;
}
public Member(){};
}
}
Supplier 함수적 인터페이스
매개변수가 없고 리턴값이 있는 getXXX()메서드를 가지고 있으며 실행후 호출한 곳으로 데이터 리턴역할
import java.util.ArrayList;
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
Supplier<ArrayList<Integer>> s = () -> {
ArrayList<Integer> list = new ArrayList<>();
for(int i=0; i<5; i++){
list.add(i);
}
return list;
};
ArrayList<Integer> result = s.get();
for(Integer tmp : result){
System.out.println(tmp);
}
}
}
Function 함수적 인터페이스
매개값과 리턴값이 있는 applyXXX()메서드를 가지고 있다. 매개값을 리턴값으로 매핑하는 역할
import java.util.function.BiFunction;
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
Function<Integer, Boolean> function = t -> {
if(t==1)return true;
return false;
};
System.out.println(function.apply(1));
System.out.println(function.apply(2));
Member test1 = new Member("Enzo", "Maxst");
Member test2 = new Member("Finn", "Maxst");
BiFunction<Member, Member, Integer> biFunction = (t,u) ->{
// t = test1;
// u = test2;
if(t.name == u.name)return 200;
return (t.company == u.company)? 300:400;
};
//biFunction.apply(test1,test2);
System.out.println(biFunction.apply(test1,test2));
}
static class Member {
String name ;
String company;
public Member(){};
public Member(String name, String company){
this.name = name;
this.company = company;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
}
Operator 함수적 인터페이스
function과 동일하게 매개변수와 리턴값을 가지고 있는데 매개값을 리턴값으로 매핑하는 역할이 아니라 매개값을 이요해 연산을 수행 후 동일한 타입으로 리턴값을 제공한다.
Predicate 함수적 인터페이스
매개변수와 boolean 리턴값이 있는 testXXX()메서드를 가지고 있으며 매개값을 조사해 boolean을 리턴한다
표준 함수형 인터페이스는 대부분 기본타입만 지원하지만 기본함수형 인터페이스에 박싱된 기본타입을 넣어 사용하지말자 → 이유는? 계산량이 많을때는 성능이 처참해진…댜..
표준 함수형 인터페이스가 아니라 커스텀해야 하는 경우가 발생한다면?
- 자주 쓰이며, 이름 자체가 용도를 명확히 설명해야한다
- 반드시 따라야 하는 규약이 있다.
- 유용한 디폴트 메서드를 제공할 수 있다
이 세가지 중 하나 이상을 만족한다면 구현부를 작성해서 적용 가능
직접 만든 함수형 인터페이스를 사용하려면 @FunctionalInterface 를 사용해야한다. 그 이유는
- 인터페이스가 람다용으로 설계된것을 알려줄때
- 추상 메서드 한개만 가지고 있어야 컴파일 가능
- 메서드를 추가하지 못하도록 막아줌
결론
입력값과 반환값에 함수형 인터페이스 타입을 활용하자 java.util.function패키지의 표준 함수형 인터페이스를 사용하는것이 best이지만 직접 새로운 함수형 인터페이스를 만들어 쓰는 편이 나을 수 있다.
람다식이란?
- 함수형 프로그램이 구현방식
- 클래스를 생성하지 않고 함수의 호출만으로 기능 수행
- 함수형 인터페이스를 선언함
함수형 프로그래밍이란?
- 순수 함수(pure function)를 구현하고 호출
- 매개변수만을 사용하도록 만든 함수로 외부 자료에 부수적인 영향을 발생하지 않도록함
- 입력 받은 자료를 기반으로 수행되고 외부에 영향을 미치지않아 병렬처리가 가능함
- @FunctionalInterFace 를 사용하면 메서드 한개만 선언할 수 있다.
java.util.function 에서 제공하는 함수적 인터페이스는 Consumer, Supplier, Function, Operator, Predicate로 구분된다.
ConSumer 함수적 인터페이스
리턴값이 없는 accept()메서드를 가지고 잇다.
import java.lang.reflect.Member;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
Consumer<Member> consumer = t -> System.out.println(t.name + "은 " + t.company+ " 의 멤버다");
consumer.accept(new Member("Enzo", "Maxst", 1));
BiConsumer<Member, String> biConsumer = (t,u) ->{
t.name = u;
System.out.println("biConsumer 예제 : " +t.name);
};
biConsumer.accept(new Member(), "Mark");
}
static class Member{
String name;
String company;
Integer id;
public Member(String name, String company, int id){
this.name = name;
this.company = company;
this.id = id;
}
public Member(){};
}
}
Supplier 함수적 인터페이스
매개변수가 없고 리턴값이 있는 getXXX()메서드를 가지고 있으며 실행후 호출한 곳으로 데이터 리턴역할
import java.util.ArrayList;
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
Supplier<ArrayList<Integer>> s = () -> {
ArrayList<Integer> list = new ArrayList<>();
for(int i=0; i<5; i++){
list.add(i);
}
return list;
};
ArrayList<Integer> result = s.get();
for(Integer tmp : result){
System.out.println(tmp);
}
}
}
Function 함수적 인터페이스
매개값과 리턴값이 있는 applyXXX()메서드를 가지고 있다. 매개값을 리턴값으로 매핑하는 역할
import java.util.function.BiFunction;
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
Function<Integer, Boolean> function = t -> {
if(t==1)return true;
return false;
};
System.out.println(function.apply(1));
System.out.println(function.apply(2));
Member test1 = new Member("Enzo", "Maxst");
Member test2 = new Member("Finn", "Maxst");
BiFunction<Member, Member, Integer> biFunction = (t,u) ->{
// t = test1;
// u = test2;
if(t.name == u.name)return 200;
return (t.company == u.company)? 300:400;
};
//biFunction.apply(test1,test2);
System.out.println(biFunction.apply(test1,test2));
}
static class Member {
String name ;
String company;
public Member(){};
public Member(String name, String company){
this.name = name;
this.company = company;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
}
Operator 함수적 인터페이스
function과 동일하게 매개변수와 리턴값을 가지고 있는데 매개값을 리턴값으로 매핑하는 역할이 아니라 매개값을 이요해 연산을 수행 후 동일한 타입으로 리턴값을 제공한다.
Predicate 함수적 인터페이스
매개변수와 boolean 리턴값이 있는 testXXX()메서드를 가지고 있으며 매개값을 조사해 boolean을 리턴한다
표준 함수형 인터페이스는 대부분 기본타입만 지원하지만 기본함수형 인터페이스에 박싱된 기본타입을 넣어 사용하지말자 → 이유는? 계산량이 많을때는 성능이 처참해진…댜..
표준 함수형 인터페이스가 아니라 커스텀해야 하는 경우가 발생한다면?
- 자주 쓰이며, 이름 자체가 용도를 명확히 설명해야한다
- 반드시 따라야 하는 규약이 있다.
- 유용한 디폴트 메서드를 제공할 수 있다
이 세가지 중 하나 이상을 만족한다면 구현부를 작성해서 적용 가능
직접 만든 함수형 인터페이스를 사용하려면 @FunctionalInterface 를 사용해야한다. 그 이유는
- 인터페이스가 람다용으로 설계된것을 알려줄때
- 추상 메서드 한개만 가지고 있어야 컴파일 가능
- 메서드를 추가하지 못하도록 막아줌
결론
입력값과 반환값에 함수형 인터페이스 타입을 활용하자 java.util.function패키지의 표준 함수형 인터페이스를 사용하는것이 best이지만 직접 새로운 함수형 인터페이스를 만들어 쓰는 편이 나을 수 있다.
람다식이란?
- 함수형 프로그램이 구현방식
- 클래스를 생성하지 않고 함수의 호출만으로 기능 수행
- 함수형 인터페이스를 선언함
함수형 프로그래밍이란?
- 순수 함수(pure function)를 구현하고 호출
- 매개변수만을 사용하도록 만든 함수로 외부 자료에 부수적인 영향을 발생하지 않도록함
- 입력 받은 자료를 기반으로 수행되고 외부에 영향을 미치지않아 병렬처리가 가능함
- @FunctionalInterFace 를 사용하면 메서드 한개만 선언할 수 있다.
java.util.function 에서 제공하는 함수적 인터페이스는 Consumer, Supplier, Function, Operator, Predicate로 구분된다.
ConSumer 함수적 인터페이스
리턴값이 없는 accept()메서드를 가지고 잇다.
import java.lang.reflect.Member;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
Consumer<Member> consumer = t -> System.out.println(t.name + "은 " + t.company+ " 의 멤버다");
consumer.accept(new Member("Enzo", "Maxst", 1));
BiConsumer<Member, String> biConsumer = (t,u) ->{
t.name = u;
System.out.println("biConsumer 예제 : " +t.name);
};
biConsumer.accept(new Member(), "Mark");
}
static class Member{
String name;
String company;
Integer id;
public Member(String name, String company, int id){
this.name = name;
this.company = company;
this.id = id;
}
public Member(){};
}
}
Supplier 함수적 인터페이스
매개변수가 없고 리턴값이 있는 getXXX()메서드를 가지고 있으며 실행후 호출한 곳으로 데이터 리턴역할
import java.util.ArrayList;
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
Supplier<ArrayList<Integer>> s = () -> {
ArrayList<Integer> list = new ArrayList<>();
for(int i=0; i<5; i++){
list.add(i);
}
return list;
};
ArrayList<Integer> result = s.get();
for(Integer tmp : result){
System.out.println(tmp);
}
}
}
Function 함수적 인터페이스
매개값과 리턴값이 있는 applyXXX()메서드를 가지고 있다. 매개값을 리턴값으로 매핑하는 역할
import java.util.function.BiFunction;
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
Function<Integer, Boolean> function = t -> {
if(t==1)return true;
return false;
};
System.out.println(function.apply(1));
System.out.println(function.apply(2));
Member test1 = new Member("Enzo", "Maxst");
Member test2 = new Member("Finn", "Maxst");
BiFunction<Member, Member, Integer> biFunction = (t,u) ->{
// t = test1;
// u = test2;
if(t.name == u.name)return 200;
return (t.company == u.company)? 300:400;
};
//biFunction.apply(test1,test2);
System.out.println(biFunction.apply(test1,test2));
}
static class Member {
String name ;
String company;
public Member(){};
public Member(String name, String company){
this.name = name;
this.company = company;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
}
Operator 함수적 인터페이스
function과 동일하게 매개변수와 리턴값을 가지고 있는데 매개값을 리턴값으로 매핑하는 역할이 아니라 매개값을 이요해 연산을 수행 후 동일한 타입으로 리턴값을 제공한다.
Predicate 함수적 인터페이스
매개변수와 boolean 리턴값이 있는 testXXX()메서드를 가지고 있으며 매개값을 조사해 boolean을 리턴한다
표준 함수형 인터페이스는 대부분 기본타입만 지원하지만 기본함수형 인터페이스에 박싱된 기본타입을 넣어 사용하지말자 → 이유는? 계산량이 많을때는 성능이 처참해진…댜..
표준 함수형 인터페이스가 아니라 커스텀해야 하는 경우가 발생한다면?
- 자주 쓰이며, 이름 자체가 용도를 명확히 설명해야한다
- 반드시 따라야 하는 규약이 있다.
- 유용한 디폴트 메서드를 제공할 수 있다
이 세가지 중 하나 이상을 만족한다면 구현부를 작성해서 적용 가능
직접 만든 함수형 인터페이스를 사용하려면 @FunctionalInterface 를 사용해야한다. 그 이유는
- 인터페이스가 람다용으로 설계된것을 알려줄때
- 추상 메서드 한개만 가지고 있어야 컴파일 가능
- 메서드를 추가하지 못하도록 막아줌
결론
입력값과 반환값에 함수형 인터페이스 타입을 활용하자 java.util.function패키지의 표준 함수형 인터페이스를 사용하는것이 best이지만 직접 새로운 함수형 인터페이스를 만들어 쓰는 편이 나을 수 있다.
람다식이란?
- 함수형 프로그램이 구현방식
- 클래스를 생성하지 않고 함수의 호출만으로 기능 수행
- 함수형 인터페이스를 선언함
함수형 프로그래밍이란?
- 순수 함수(pure function)를 구현하고 호출
- 매개변수만을 사용하도록 만든 함수로 외부 자료에 부수적인 영향을 발생하지 않도록함
- 입력 받은 자료를 기반으로 수행되고 외부에 영향을 미치지않아 병렬처리가 가능함
- @FunctionalInterFace 를 사용하면 메서드 한개만 선언할 수 있다.
java.util.function 에서 제공하는 함수적 인터페이스는 Consumer, Supplier, Function, Operator, Predicate로 구분된다.
ConSumer 함수적 인터페이스
리턴값이 없는 accept()메서드를 가지고 잇다.
import java.lang.reflect.Member;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
Consumer<Member> consumer = t -> System.out.println(t.name + "은 " + t.company+ " 의 멤버다");
consumer.accept(new Member("Enzo", "Maxst", 1));
BiConsumer<Member, String> biConsumer = (t,u) ->{
t.name = u;
System.out.println("biConsumer 예제 : " +t.name);
};
biConsumer.accept(new Member(), "Mark");
}
static class Member{
String name;
String company;
Integer id;
public Member(String name, String company, int id){
this.name = name;
this.company = company;
this.id = id;
}
public Member(){};
}
}
Supplier 함수적 인터페이스
매개변수가 없고 리턴값이 있는 getXXX()메서드를 가지고 있으며 실행후 호출한 곳으로 데이터 리턴역할
import java.util.ArrayList;
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
Supplier<ArrayList<Integer>> s = () -> {
ArrayList<Integer> list = new ArrayList<>();
for(int i=0; i<5; i++){
list.add(i);
}
return list;
};
ArrayList<Integer> result = s.get();
for(Integer tmp : result){
System.out.println(tmp);
}
}
}
Function 함수적 인터페이스
매개값과 리턴값이 있는 applyXXX()메서드를 가지고 있다. 매개값을 리턴값으로 매핑하는 역할
import java.util.function.BiFunction;
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
Function<Integer, Boolean> function = t -> {
if(t==1)return true;
return false;
};
System.out.println(function.apply(1));
System.out.println(function.apply(2));
Member test1 = new Member("Enzo", "Maxst");
Member test2 = new Member("Finn", "Maxst");
BiFunction<Member, Member, Integer> biFunction = (t,u) ->{
// t = test1;
// u = test2;
if(t.name == u.name)return 200;
return (t.company == u.company)? 300:400;
};
//biFunction.apply(test1,test2);
System.out.println(biFunction.apply(test1,test2));
}
static class Member {
String name ;
String company;
public Member(){};
public Member(String name, String company){
this.name = name;
this.company = company;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
}
Operator 함수적 인터페이스
function과 동일하게 매개변수와 리턴값을 가지고 있는데 매개값을 리턴값으로 매핑하는 역할이 아니라 매개값을 이요해 연산을 수행 후 동일한 타입으로 리턴값을 제공한다.
Predicate 함수적 인터페이스
매개변수와 boolean 리턴값이 있는 testXXX()메서드를 가지고 있으며 매개값을 조사해 boolean을 리턴한다
표준 함수형 인터페이스는 대부분 기본타입만 지원하지만 기본함수형 인터페이스에 박싱된 기본타입을 넣어 사용하지말자 → 이유는? 계산량이 많을때는 성능이 처참해진…댜..
표준 함수형 인터페이스가 아니라 커스텀해야 하는 경우가 발생한다면?
- 자주 쓰이며, 이름 자체가 용도를 명확히 설명해야한다
- 반드시 따라야 하는 규약이 있다.
- 유용한 디폴트 메서드를 제공할 수 있다
이 세가지 중 하나 이상을 만족한다면 구현부를 작성해서 적용 가능
직접 만든 함수형 인터페이스를 사용하려면 @FunctionalInterface 를 사용해야한다. 그 이유는
- 인터페이스가 람다용으로 설계된것을 알려줄때
- 추상 메서드 한개만 가지고 있어야 컴파일 가능
- 메서드를 추가하지 못하도록 막아줌
결론
입력값과 반환값에 함수형 인터페이스 타입을 활용하자 java.util.function패키지의 표준 함수형 인터페이스를 사용하는것이 best이지만 직접 새로운 함수형 인터페이스를 만들어 쓰는 편이 나을 수 있다.
람다식이란?
- 함수형 프로그램이 구현방식
- 클래스를 생성하지 않고 함수의 호출만으로 기능 수행
- 함수형 인터페이스를 선언함
함수형 프로그래밍이란?
- 순수 함수(pure function)를 구현하고 호출
- 매개변수만을 사용하도록 만든 함수로 외부 자료에 부수적인 영향을 발생하지 않도록함
- 입력 받은 자료를 기반으로 수행되고 외부에 영향을 미치지않아 병렬처리가 가능함
- @FunctionalInterFace 를 사용하면 메서드 한개만 선언할 수 있다.
java.util.function 에서 제공하는 함수적 인터페이스는 Consumer, Supplier, Function, Operator, Predicate로 구분된다.
ConSumer 함수적 인터페이스
리턴값이 없는 accept()메서드를 가지고 잇다.
import java.lang.reflect.Member;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
Consumer<Member> consumer = t -> System.out.println(t.name + "은 " + t.company+ " 의 멤버다");
consumer.accept(new Member("Enzo", "Maxst", 1));
BiConsumer<Member, String> biConsumer = (t,u) ->{
t.name = u;
System.out.println("biConsumer 예제 : " +t.name);
};
biConsumer.accept(new Member(), "Mark");
}
static class Member{
String name;
String company;
Integer id;
public Member(String name, String company, int id){
this.name = name;
this.company = company;
this.id = id;
}
public Member(){};
}
}
Supplier 함수적 인터페이스
매개변수가 없고 리턴값이 있는 getXXX()메서드를 가지고 있으며 실행후 호출한 곳으로 데이터 리턴역할
import java.util.ArrayList;
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
Supplier<ArrayList<Integer>> s = () -> {
ArrayList<Integer> list = new ArrayList<>();
for(int i=0; i<5; i++){
list.add(i);
}
return list;
};
ArrayList<Integer> result = s.get();
for(Integer tmp : result){
System.out.println(tmp);
}
}
}
Function 함수적 인터페이스
매개값과 리턴값이 있는 applyXXX()메서드를 가지고 있다. 매개값을 리턴값으로 매핑하는 역할
import java.util.function.BiFunction;
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
Function<Integer, Boolean> function = t -> {
if(t==1)return true;
return false;
};
System.out.println(function.apply(1));
System.out.println(function.apply(2));
Member test1 = new Member("Enzo", "Maxst");
Member test2 = new Member("Finn", "Maxst");
BiFunction<Member, Member, Integer> biFunction = (t,u) ->{
// t = test1;
// u = test2;
if(t.name == u.name)return 200;
return (t.company == u.company)? 300:400;
};
//biFunction.apply(test1,test2);
System.out.println(biFunction.apply(test1,test2));
}
static class Member {
String name ;
String company;
public Member(){};
public Member(String name, String company){
this.name = name;
this.company = company;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
}
Operator 함수적 인터페이스
function과 동일하게 매개변수와 리턴값을 가지고 있는데 매개값을 리턴값으로 매핑하는 역할이 아니라 매개값을 이요해 연산을 수행 후 동일한 타입으로 리턴값을 제공한다.
Predicate 함수적 인터페이스
매개변수와 boolean 리턴값이 있는 testXXX()메서드를 가지고 있으며 매개값을 조사해 boolean을 리턴한다
표준 함수형 인터페이스는 대부분 기본타입만 지원하지만 기본함수형 인터페이스에 박싱된 기본타입을 넣어 사용하지말자 → 이유는? 계산량이 많을때는 성능이 처참해진…댜..
표준 함수형 인터페이스가 아니라 커스텀해야 하는 경우가 발생한다면?
- 자주 쓰이며, 이름 자체가 용도를 명확히 설명해야한다
- 반드시 따라야 하는 규약이 있다.
- 유용한 디폴트 메서드를 제공할 수 있다
이 세가지 중 하나 이상을 만족한다면 구현부를 작성해서 적용 가능
직접 만든 함수형 인터페이스를 사용하려면 @FunctionalInterface 를 사용해야한다. 그 이유는
- 인터페이스가 람다용으로 설계된것을 알려줄때
- 추상 메서드 한개만 가지고 있어야 컴파일 가능
- 메서드를 추가하지 못하도록 막아줌
결론
입력값과 반환값에 함수형 인터페이스 타입을 활용하자 java.util.function패키지의 표준 함수형 인터페이스를 사용하는것이 best이지만 직접 새로운 함수형 인터페이스를 만들어 쓰는 편이 나을 수 있다.
Java8부터 람다를 지원하면서 API를 작성하는 사례가 바뀌었다. 함수형 인터페이스를 들어가기전에 람다부터 설명하고 시작하겠다.
람다식이란?
- 함수형 프로그램이 구현방식
- 클래스를 생성하지 않고 함수의 호출만으로 기능 수행
- 함수형 인터페이스를 선언함
함수형 프로그래밍이란?
- 순수 함수(pure function)를 구현하고 호출
- 매개변수만을 사용하도록 만든 함수로 외부 자료에 부수적인 영향을 발생하지 않도록함
- 입력 받은 자료를 기반으로 수행되고 외부에 영향을 미치지않아 병렬처리가 가능함
- @FunctionalInterFace 를 사용하면 메서드 한개만 선언할 수 있다.
java.util.function 에서 제공하는 함수적 인터페이스는 Consumer, Supplier, Function, Operator, Predicate로 구분된다.
ConSumer 함수적 인터페이스
리턴값이 없는 accept()메서드를 가지고 잇다.
import java.lang.reflect.Member;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
Consumer<Member> consumer = t -> System.out.println(t.name + "은 " + t.company+ " 의 멤버다");
consumer.accept(new Member("Enzo", "Maxst", 1));
BiConsumer<Member, String> biConsumer = (t,u) ->{
t.name = u;
System.out.println("biConsumer 예제 : " +t.name);
};
biConsumer.accept(new Member(), "Mark");
}
static class Member{
String name;
String company;
Integer id;
public Member(String name, String company, int id){
this.name = name;
this.company = company;
this.id = id;
}
public Member(){};
}
}
Supplier 함수적 인터페이스
매개변수가 없고 리턴값이 있는 getXXX()메서드를 가지고 있으며 실행후 호출한 곳으로 데이터 리턴역할
import java.util.ArrayList;
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
Supplier<ArrayList<Integer>> s = () -> {
ArrayList<Integer> list = new ArrayList<>();
for(int i=0; i<5; i++){
list.add(i);
}
return list;
};
ArrayList<Integer> result = s.get();
for(Integer tmp : result){
System.out.println(tmp);
}
}
}
Function 함수적 인터페이스
매개값과 리턴값이 있는 applyXXX()메서드를 가지고 있다. 매개값을 리턴값으로 매핑하는 역할
import java.util.function.BiFunction;
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
Function<Integer, Boolean> function = t -> {
if(t==1)return true;
return false;
};
System.out.println(function.apply(1));
System.out.println(function.apply(2));
Member test1 = new Member("Enzo", "Maxst");
Member test2 = new Member("Finn", "Maxst");
BiFunction<Member, Member, Integer> biFunction = (t,u) ->{
// t = test1;
// u = test2;
if(t.name == u.name)return 200;
return (t.company == u.company)? 300:400;
};
//biFunction.apply(test1,test2);
System.out.println(biFunction.apply(test1,test2));
}
static class Member {
String name ;
String company;
public Member(){};
public Member(String name, String company){
this.name = name;
this.company = company;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
}
Operator 함수적 인터페이스
function과 동일하게 매개변수와 리턴값을 가지고 있는데 매개값을 리턴값으로 매핑하는 역할이 아니라 매개값을 이요해 연산을 수행 후 동일한 타입으로 리턴값을 제공한다.
Predicate 함수적 인터페이스
매개변수와 boolean 리턴값이 있는 testXXX()메서드를 가지고 있으며 매개값을 조사해 boolean을 리턴한다
표준 함수형 인터페이스는 대부분 기본타입만 지원하지만 기본함수형 인터페이스에 박싱된 기본타입을 넣어 사용하지말자 → 이유는? 계산량이 많을때는 성능이 처참해진…댜..
표준 함수형 인터페이스가 아니라 커스텀해야 하는 경우가 발생한다면?
- 자주 쓰이며, 이름 자체가 용도를 명확히 설명해야한다
- 반드시 따라야 하는 규약이 있다.
- 유용한 디폴트 메서드를 제공할 수 있다
이 세가지 중 하나 이상을 만족한다면 구현부를 작성해서 적용 가능
직접 만든 함수형 인터페이스를 사용하려면 @FunctionalInterface 를 사용해야한다. 그 이유는
- 인터페이스가 람다용으로 설계된것을 알려줄때
- 추상 메서드 한개만 가지고 있어야 컴파일 가능
- 메서드를 추가하지 못하도록 막아줌
결론
입력값과 반환값에 함수형 인터페이스 타입을 활용하자 java.util.function패키지의 표준 함수형 인터페이스를 사용하는것이 best이지만 직접 새로운 함수형 인터페이스를 만들어 쓰는 편이 나을 수 있다.
'What i learn.' 카테고리의 다른 글
| [Hexagonal] 레이어 분리 헥사고날 아키텍처 번역글 (1) | 2022.10.19 |
|---|---|
| [Effective Java] Item69-77 Exception (0) | 2022.08.04 |
| [book-review]effective java item37 enum (0) | 2022.06.08 |
| [What I Learn] Builder 패턴을 쓰는이유 (0) | 2022.05.04 |
| [What I Learn] TDD (0) | 2022.04.28 |