์ผ๋ฐ์ ์ผ๋ก ์ ์ด๋ ๊ฐ์ด ์ฐธ์ธ์ง ๊ฑฐ์ง์ธ์ง๋ฅผ ๊ฒฐ์ ํ๋ ์ง์ ์ ์๋ฏธํฉ๋๋ค. ํ๋ก๊ทธ๋๋ฐ ์ ์ด๋ ๋ถ์ธ ๊ฐ์ ๋ฐํํ๋ ํ๋์ ์ธ์๊ฐ ์๋ ํจ์๋ฅผ ์๋ฏธํฉ๋๋ค. Functional Interface Predicate๋ Java 8์์ ์คํ๋์์ต๋๋ค. "Functional"์ ํ๋์ ์ถ์ ๋ฉ์๋๋ง ํฌํจํ๋ค๋ ์๋ฏธ์
๋๋ค. ์ธ์๋ฅผ ์๋ฝํ๊ณ ๋ถ์ธ์ ๋ฐํํฉ๋๋ค. Java์์ ๊ธฐ๋ฅ ์ธํฐํ์ด์ค๋ Lambda ํํ์, ์์ฑ์ ๋ฐ ๋ฉ์๋ ์ฐธ์กฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก Java 8 ์ ์ด๋ ์ค๋ธ์ ํธ ์ฝ๋ ์
์ ๋ํ ํํฐ๋ฅผ ์ ์ฉํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ฃผ์ ์์ฉ ํ๋ก๊ทธ๋จ๊ณผ ๋๋ฆฌ ์ฌ์ฉ๋๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ณ ์ผ๋ถ ์ฐ์ต ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด ๋ด
์๋ค.
๊ฐ๋ฐ์๊ฐ ์ ์ด๋ฅผ ์ฌ์ฉํ๋ ์ด์
๊ธฐ๋ณธ์ ์ผ๋ก ๊ฐ๋ฐ์๋ ๋ฏธ๋ฆฌ ์ ์๋ ๊ธฐ์ค์ ๋ฐ๋ผ ํญ๋ชฉ์ ํ๊ฐํ๊ณ ๋ถ์ธ ๊ฐ์ ๋ฐํํ๋ ๋ชจ๋ ์์ ์ ์กฐ๊ฑด์๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๋ค์์ ์ ์ด๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ๋ฐ์๊ฐ ์ฒ๋ฆฌํ๋ ๊ฐ๋จํ ์์ ์ ์์ ๋๋ค.- ์ ์ ์งํฉ ํํฐ๋ง.
- ๋ฐ์ดํฐ๊ฐ ์ฌ์ ์ ์๋ ์ฌ๋ฌ ์กฐ๊ฑด์ ์ค์ํ๋์ง ํ์ธํ์ฌ ๋ชฉ๋ก ์ ๋ ฌ(์: ๊ฐ๊ฒฉ ๋ฐ ์ค๋ ์กฐ๊ฑด์ ์ค์ ํ์ฌ ํ๋ชฉ ๋ฒ์ ๊ตฌ์ฑ).
- ๋์ ํ๋ก๊ทธ๋๋ฐ์์ ์ ํธ๋ฆฌํฐ ํจํค์ง ์ฌ์ฉ.
Java์ ์ ์ด ๊ตฌ๋ฌธ
java.util.function.Predicate๋ Lambda์์ ํ๊ฐ ๋ ธ์ถ์ ์ฒ๋ฆฌํ๋ ๋์ฒด ๋ฐฉ๋ฒ์ผ๋ก Java 8์์ ๋์ ๋์์ต๋๋ค. ์ธํฐํ์ด์ค์ ํ์ค ๋ณด๊ธฐ๋ Predicate<T> ์ ๋๋ค . ์ฌ๊ธฐ์ T๋ ๋ถ์ธ ๊ฐ์ ๋ฐํํ๋ ๋จ์ผ ์ธ์์ ๋๋ค. Java ์ ์ด์๋ ์ฃผ์ด์ง ๊ฐ์ฒด์์ ์ด ์ ์ด๋ฅผ ํ๊ฐํ๋ ๊ธฐ๋ฅ์ (์ถ์) ๋ฉ์๋ test(Object)๊ฐ ์์ต๋๋ค.
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
๋ค์์ "๋ณด๋ค ํผ", "๋ณด๋ค ์์" ์กฐ๊ฑด์ ๋ฐ๋ผ ์ ์๋ฅผ ํํฐ๋งํ๋ ๊ฐ๋จํ ์กฐ๊ฑด์๋ฅผ ์์ฑํ๋ ์์
๋๋ค.
// An example of a simple Java predicate
import java.util.function.Predicate;
public class PredicateExample {
public static void main(String[] args)
{
// Creating predicate
Predicate<Integer> lesserThan = i -> (i < 18);
// Calling Predicate method
System.out.println(lesserThan.test(10));
}
}
์ถ๋ ฅ์ 10 < 18์ด๊ธฐ ๋๋ฌธ์ ์ฐธ์ด ๋ฉ๋๋ค . filter() ์ ์ ์ด๊ฐ ์๋ ๋ ๋ค๋ฅธ ์์
๋๋ค . ์ ์ด๋ ์ฐ๋ น ๋ชฉ๋ก์์ ๋ชจ๋ ์ฑ์ธ์ ํํฐ๋งํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค.
import java.util.List;
import java.util.function.Predicate;
public class PredicateExample {
public static void main(String[] args) {
List<Integer> ages = List.of(17, 18, 19, 28, 18, 28, 46, 7, 8, 9, 21, 12);
NotLessThan18<Integer> isAdult = new NotLessThan18<>();
ages.stream().filter(isAdult).forEach(System.out::println);
}
}
class NotLessThan18<E> implements Predicate<Integer> {
@Override
public boolean test(Integer v) {
Integer ADULT = 18;
return v >= ADULT;
}
}
์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
18 19 28 18 28 46 21
Java 8 ์กฐ๊ฑด์ ๋ฉ์๋
์ ์ด ์ธํฐํ์ด์ค์๋ ๋ช ๊ฐ์ง ๋ฉ์๋๊ฐ ์์ต๋๋ค.- boolean test(T t)๋ ์ฃผ์ด์ง ์ธ์์ ๋ํ ์ ์ด๋ฅผ ํ๊ฐํฉ๋๋ค.
- default Predicate<T> and(Predicate<? super T> other)๋ ์ด ์ ์ด์ ๋ค๋ฅธ ์ ์ด์ ๋จ๋ฝ ๋ ผ๋ฆฌ์ AND๋ฅผ ๋ํ๋ด๋ ์ ์ด๋ฅผ ๋ฐํํฉ๋๋ค.
- default Predicate<T> ๋๋ ์ด ์ ์ด์ ๋ค๋ฅธ ์ ์ด์ ๋จ๋ฝ ๋ ผ๋ฆฌ์ OR์ ๋ํ๋ด๋ ๊ตฌ์ฑ๋ ์ ์ด๋ฅผ ๋ฐํํฉ๋๋ค.
- default Predicate<T> negate()๋ ์ด ์ ์ด์ ๋ ผ๋ฆฌ์ ์ผ๋ก ๋ฐ๋๋๋ ์ ์ด๋ฅผ ๋ฐํํฉ๋๋ค.
- default Predicate<T> isEqual(Object targetRef) ๋ Objects.equals(Object, Object) ์ ๋ฐ๋ผ ๋ ์ธ์๊ฐ ๊ฐ์์ง ํ ์คํธํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํฉ๋๋ค .
๋ถ๋ฆฌ์ธ ํ ์คํธ(T t)
์ด๊ฒ์ ์ฃผ์ด์ง ์ธ์๊ฐ ์ ์ด์ ์กฐ๊ฑด์ ๋ง์กฑํ๋์ง ์ฌ๋ถ๋ฅผ ํ๊ฐํ๋ Java ์ ์ด์ ๋ํ ๊ธฐ๋ฅ์ ๋ฐฉ๋ฒ์ ๋๋ค. ์: ์ฌ๊ธฐ์๋ 18์ธ ์ด์์ ๋ชจ๋ ์ฌ๋์ ์ํ ์ ์ด adult๋ฅผ ๋ง๋ญ๋๋ค. test() ๋ฉ์๋๋ ์ ์ ๊ฐ์ ๊ฐ์ ธ์์ ํ์ธํฉ๋๋ค.
import java.util.function.Predicate;
public class PredicateTestTest {
public static void main(String[] args) {
Predicate<Integer> adult = i -> i >= 18;
System.out.println(adult.test(12));
System.out.println(adult.test(19));
System.out.println(adult.test(21));
}
}
์ ์ฝ๋์ ์ถ๋ ฅ์ ์ด๋ป๊ฒ ๋ ๊น์? ์ฒซ ๋ฒ์งธ ๊ฒฝ์ฐ์๋ 12๊ฐ 18๋ณด๋ค ์์ผ๋ฏ๋ก false๊ฐ ๋ฉ๋๋ค. ๋ ๋ฒ์งธ์ ์ธ ๋ฒ์งธ ์๋๋ฆฌ์ค๋ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋์ด ๋ฐํ์ด true๊ฐ ๋ฉ๋๋ค.
๊ฑฐ์ง ์ฐธ ์ฐธ
๊ธฐ๋ณธ Predicate.and()
์ด ๋ฉ์๋๋ "and" ์ฐ์ฐ์๋ฅผ ๋ํ๋ ๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ฃผ์ด์ง ์ ์ด ์ค ํ๋๊ฐ ์ค์ ๋ ์กฐ๊ฑด์ ์ค์ํ์ง ์์ผ๋ฉด ๋ค๋ฅธ ์ ์ด๋ ํ๊ฐ๋ฅผ ๋ฐ์ง ์์ต๋๋ค. ์: and() ๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฏธ ์ฑ์ธ์ด์ง๋ง 65์ธ ๋ฏธ๋ง์ธ ๋ชจ๋ ์ฌ๋์ ํํฐ๋งํ๋ ์ ์ด๋ฅผ Java๋ก ์์ฑํด ๋ณด๊ฒ ์ต๋๋ค . predicate.add()๋ฅผ ์ฌ์ฉ ํ๊ณ ์ด๋ฌํ ์กฐ๊ฑด์ ๋ํด ๋๋ค๋ก Java ์กฐ๊ฑด์๋ฅผ ์์ฑํด ๋ณด๊ฒ ์ต๋๋ค. ์กฐ๊ฑด์ด ์ฐธ์ด๋ฉด ์ฑ์ ๋ค์ ๋ฌธ์ ๋ฐํํฉ๋๋ค.
import java.util.function.Predicate;
public class PredicateDemo {
public static void main(String[] args) {
Predicate<Integer> adultYet = i -> i >= 18;
Predicate<Integer> adultStill = i -> i < 65;
System.out.println(adultYet.and(adultStill).test(5));
System.out.println(adultYet.and(adultStill).test(38));
System.out.println(adultYet.and(adultStill).test(90));
}
}
์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๊ฑฐ์ง ์ฐธ ๊ฑฐ์ง
๊ธฐ๋ณธ Predicate.or()
Predicate.or() ๋ฉ์๋๋ "OR" ์ฐ์ฐ์๋ฅผ ๋ํ๋ ๋๋ค. ์ด๊ฒ์ ๋ ์ ์ด ์ค ํ๋๊ฐ ์ฐธ์ด๊ณ ๋ค๋ฅธ ํ๋๊ฐ ๊ฑฐ์ง์ด๋๋ผ๋ ์กฐ๊ฑด์ด ์ฐธ์ผ๋ก ์ ์ง๋จ์ ์๋ฏธํฉ๋๋ค. ์: ์ด์ ๋ฌธ์์ด์ ํ๊ฐํด ๋ณด๊ฒ ์ต๋๋ค. ํ์ ๋ฌธ์์ด "my" ๋๋ "crayon"์ด ํฌํจ๋ ๋ชจ๋ ๊ตฌ๋ฌธ์ ์ ๋ ฌํ๋ ค๋ฉด OR ๋ฐฉ๋ฒ์ ์ฌ์ฉํด ๋ณด์ญ์์ค.
import java.util.function.Predicate;
public class PredicateDemo2 {
public static void main(String[] args) {
Predicate<String> containsA = t -> t.contains("crayon");
Predicate<String> containsB = t -> t.contains("my");
System.out.println(containsA.or(containsB).test("here is my crayon"));
System.out.println(containsA.or(containsB).test("here is my pencil"));
System.out.println(containsA.or(containsB).test("here is John's crayon"));
System.out.println(containsA.or(containsB).test("here is John's pencil"));
}
}
์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ฐธ ์ฐธ ์ฐธ ๊ฑฐ์ง
๊ธฐ๋ณธ ์ ์ด ๋ถ์ ()
๋ถ์ () ๋ฉ์๋๋ ์ฌ์ ์ ์๋ ๊ธฐ์ค์ ์ค์ํ์ง ์๋ ๋ชจ๋ ๊ฐ์ ์์งํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์: "Tomatoes" ํด๋์ค๋ฅผ ํตํด ์ ๋ ฌํ๊ณ "Red"๊ฐ ์๋ ๋ชจ๋ ํญ๋ชฉ์ ์ฐพ์ผ๋ ค๋ฉด ์ ์ด๋ฅผ ์์ฑํ๊ณ ์ ์ฒด ์ํ์ค๋ฅผ ๋น ๋ฅด๊ฒ ์ค์บํ ์ ์์ต๋๋ค. ์ด ์ฝ๋๋ฅผ ์ง์ ์์ฑํ๊ณ ์๋ฃ๋๋ฉด ์๋ฃจ์ ๊ณผ ๋น๊ตํ์ฌ ํ์ธํ์ญ์์ค.
import java.util.function.Predicate;
public class PredicateDemo3 {
public static void main(String[] args) {
Predicate<Integer> adult = i -> i >= 18;
System.out.println(adult.negate().test(7)); System.out.println(adult.negate().test(19))
}
}
์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
ํ์ ์ฌ์ค
์ ์ ์ ์ด isEqual(Object targetRef)
์ด ๋ฉ์๋๋ ๋ ๊ฐ์ฒด๊ฐ Objects.equals()์ ๋งค๊ฐ ๋ณ์๋ก ์ ์๋ ๊ฐ๊ณผ ๊ฐ์์ง ํ์ธํ๋ ค๋ ๊ฒฝ์ฐ ๋งค์ฐ ์ ์ฉํฉ๋๋ค. ์ด ๋ฐฉ๋ฒ์ ์ ์ฌํ ํ ์คํธ ๊ฒฐ๊ณผ๋ฅผ ๋น๊ตํด์ผ ํ๋ ๊ฒฝ์ฐ์ ํนํ ์ ์ฉํฉ๋๋ค. ์: ๋ ๊ฐ์ ๋ฐฐ ๋ง์ฐจ๋ฅผ ๋น๊ตํ๊ณ ๋ ๋ง์ฐจ์ ํ์ค ๋ฌด๊ฒ์ ์์์ ๊ณผ์ผ์ด ์๋์ง ํ์ธํ๋ ค๊ณ ํ๋ค๊ณ ๊ฐ์ ํด ๋ด ์๋ค. ์ด ๊ฒฝ์ฐ ์ ์ ์ ์ด isEqual(Object targetRef)๊ฐ ์ ํํ ํ์ํ ๋ฉ์๋์ ๋๋ค. isEqual์ด ๋ ๋ฌธ์์ด์ ๋๋ฑ์ฑ์ ํ์ธํ๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค .
import java.util.function.Predicate;
public class PredicateDemo2 {
public static void main(String[] args) {
Predicate<String> i = Predicate.isEqual("here is my crayon");
System.out.println(i.test("here is my pencil"));
System.out.println(i.test("here is my crayon"));
}
}
๋ถ์ ์ค์ธ ๊ฐ์ฒด๊ฐ ํ์ค ์กฐ๊ฑด์ ์ค์ํ๋ ๊ฒฝ์ฐ ํจ์๋ true๋ฅผ ๋ฐํํฉ๋๋ค. ์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๊ฑฐ์ง ์ฐธ
์๋ฐ IntPredicate
Java IntPredicate๋ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค์ด๋ฏ๋ก ์ด๋ฅผ ๋๋ค ์ ๋๋ ๋ฉ์๋ ์ฐธ์กฐ์ ๋ํ ํ ๋น ๋์์ผ๋ก ์ฌ์ฉํ ์ ์์ต๋๋ค. IntPredicate๋ ์ ์์์ ์๋ํ๋ฉฐ ์กฐ๊ฑด์ ๋ฐ๋ผ ์กฐ๊ฑด์ ๊ฐ์ ๋ฐํํฉ๋๋ค. ์ ์ด ์ธํฐํ์ด์ค์ ๊ฐ์ด IntPredicate์๋ test() , and() , negate() ๋๋ () ๋ฉ์๋๊ฐ ์์ต๋๋ค. ๋ค์์ IntPredicate์ ์์ ๋๋ค. ๋ํ ์ด๋ ์ด์์ ๋ชจ๋ ์ฑ์ธ(18์ธ ์ด์)์ ํํฐ๋งํฉ๋๋ค.
import java.util.Arrays;
import java.util.function.IntPredicate;
public class IntPredicateExample {
public static void main(String[] args) {
int[] ages = { 18, 28, 18, 46, 90, 45, 2, 3, 1, 5, 7, 21, 12 };
IntPredicate p = n -> n >= 18;
Arrays.stream(ages).filter(p).forEach(System.out::println);
}
}
์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
18 28 18 46 90 45 21
Java์์ ๊นจ๋ํ ์กฐ๊ฑด์ ์์ฑ
Java ์ ์ด๋ ๊ธฐ๋ฅ์ด ๋ฐ์ด๋๊ณ ์์ ํ๊ธฐ์ ์ฌ๋ฏธ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์์ฑํ๋ ๋๋ค ํํ์์ด ์ฝ๋์ ๋ฏธ์น๋ ์ํฅ์ ์ผ๋์ ๋์ง ์์ผ๋ฉด ์ง์ ๋ถํ ์กฐ๊ฑด์๋ก ์ฝ๋ ์ ์ง ๊ด๋ฆฌ ๊ฐ๋ฅ์ฑ์ด ๊ฐ์ํ ์ํ์ด ์์ต๋๋ค. ๋ค์์ ๊ธฐ๋ฅ ์ธํฐํ์ด์ค๋ฅผ ์ฝ๊ฒ ๊ด๋ฆฌํ๊ณ ์ฝ์ ์ ์๋๋ก ๋์์ฃผ๋ ๋ช ๊ฐ์ง ๊ฐ๋จํ ๋ฐฉ๋ฒ์ ๋๋ค.- Don't Repeat Yourself โ ๋ ๋ฒ ์ด์ ๋ฐ๋ณต๋๋ ๊ฐ, ๋ฉ์๋ ๋ฐ ์กฐ๊ฑด์ ์ฌ์ฉํ์ฌ Java๋ก ์ ์ด๋ฅผ ๊ตฌ์ฑํ์ง ๋ง์ญ์์ค. ์ด๋ฐ ์์ผ๋ก ์์ฐ์ ์ธ ์๊ฐ์ ๋ญ๋นํ๊ณ ์ฝ๋๋ฅผ ์ง์ ๋ถํ๊ฒ ๋ง๋ญ๋๋ค.
- ํ ์คํธ ๊ฐ๋ฅ์ฑ์ ๋ณด์ฅํ๊ธฐ ์ํด ์ฑ ์ฝ๋์์ ์กฐ๊ฑด์๋ฅผ ๋ถ๋ฆฌํฉ๋๋ค. ๊ทธ ์ธ์๋ ์ ์ด ๋จ์ ํ ์คํธ ์ผ์ ์ ๋ง๋ค๊ณ ์ด๋ฅผ ๊ณ ์ํ์ญ์์ค.
- ๊ฐ์ ธ์ค๊ธฐ ๋ฐ ์ปดํฌ์ง์ ํจํด์ ์ฌ์ฉํ์ฌ ํด๋์ค๊ฐ ๋ถํ์ด ์ค๋ฅด์ง ์๊ณ ์ฝ๊ฒ ๊ด๋ฆฌํ ์ ์๋๋ก ํฉ๋๋ค.
- Java ์ ์ด๋ฅผ Helper ํด๋์ค๋ก ์ด๋ํ๋ ๊ฒ์ ๊ณ ๋ คํ์ญ์์ค. ์ด๋ ๊ฒ ํ๋ฉด ์ฝ๋์ ์ฌ์ฌ์ฉ์ฑ์ด ํฅ์๋๊ณ ์ ์ง ๊ด๋ฆฌ๊ฐ ์ฉ์ดํด์ง๋๋ค.
- ๊ฐ๋ ์ฑ - ๊ฐ๋ฅํ๋ฉด ๋ณต์กํ ์ ์ด๋ณด๋ค ํ ์ค ๋ฌธ์ฅ์ ์ ํธํฉ๋๋ค. ๋ณต์กํ ๊ธฐ๋ฅ ์ธํฐํ์ด์ค์ ๋ํ ์ดํด๋ฅผ ๊ณผ์ํ๊ณ ์ถ์ ์๋ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ ์ง ๊ด๋ฆฌ์ ์์ด์๋ ์ ์์๋ก ์ข์ต๋๋ค.
GO TO FULL VERSION