์๋
ํ์ธ์! Java Syntax Pro ํ์คํธ์์ ์ฐ๋ฆฌ๋ ๋๋ค ํํ์์ ์ฐ๊ตฌํ์ผ๋ฉฐ ์ด๋ ํจ์ํ ์ธํฐํ์ด์ค์์ ํจ์ํ ๋ฉ์๋๋ฅผ ๊ตฌํํ ๊ฒ์ ์ง๋์ง ์๋๋ค๊ณ ๋งํ์ต๋๋ค. ์ฆ, ์ด๋ ์คํ๋์ง ์์ ๋ฉ์๋์ธ ์ผ๋ถ ์ต๋ช
(์ ์ ์์) ํด๋์ค์ ๊ตฌํ์
๋๋ค. ๊ทธ๋ฆฌ๊ณ ๊ณผ์ ์ ๊ฐ์์์ ๋๋ค ํํ์์ ์ฌ์ฉํ ์กฐ์์ ํ๊ตฌํ๋ค๋ฉด ์ด์ ๋ ๋ค๋ฅธ ์ธก๋ฉด, ์ฆ ๋ฐ๋ก ์ด๋ฌํ ์ธํฐํ์ด์ค๋ฅผ ๊ณ ๋ คํ ๊ฒ์
๋๋ค. Java์ 8๋ฒ์งธ ๋ฒ์ ์์๋ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค ๊ฐ๋
์ด ๋์
๋์์ต๋๋ค . ์ด๊ฒ ๋ญ๊ฐ์? ๊ตฌํ๋์ง ์์(์ถ์) ๋ฉ์๋๊ฐ ํ๋ ์๋ ์ธํฐํ์ด์ค๋ ๊ธฐ๋ฅ์ ์ธ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋ฉ๋๋ค. ์์ ๋
ผ์ํ ์ธํฐํ์ด์ค์ ๊ฐ์ ๋ง์ ๊ธฐ๋ณธ ์ธํฐํ์ด์ค๊ฐ ์ด ์ ์์ ์ํฉ๋๋ค . ๋ํ ๋ค์๊ณผ ๊ฐ์ด ์ฐ๋ฆฌ๊ฐ ์ง์ ๋ง๋๋ ์ธํฐํ์ด์ค๋ ์์ต๋๋ค. ์ ๋ถ
์๋น์
๊ณต๊ธ์
๊ธฐ๋ฅ
๋จํญ ์ฐ์ฐ์
Comparator
@FunctionalInterface
public interface Converter<T, N> {
N convert(T t);
}
ํ ์ ํ์ ๊ฐ์ฒด๋ฅผ ๋ค๋ฅธ ์ ํ์ ๊ฐ์ฒด(์ผ์ข
์ ์ด๋ํฐ)๋ก ๋ณํํ๋ ์์
์ ์ํํ๋ ์ธํฐํ์ด์ค๊ฐ ์์ต๋๋ค. ์ฃผ์์ @FunctionalInterface
๋งค์ฐ ๋ณต์กํ๊ฑฐ๋ ์ค์ํ ๊ฒ์ด ์๋๋๋ค. ์ฃผ์์ ๋ชฉ์ ์ ์ด ์ธํฐํ์ด์ค๊ฐ ๊ธฐ๋ฅ์ ์ด๋ฉฐ ํ๋์ ๋ฉ์๋๋ง ํฌํจํด์ผ ํจ์ ์ปดํ์ผ๋ฌ์ ์๋ฆฌ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์
๋๋ค. ์ด ์ฃผ์์ด ์๋ ์ธํฐํ์ด์ค์ ๊ตฌํ๋์ง ์์(์ถ์) ๋ฉ์๋๊ฐ ๋ ๊ฐ ์ด์ ์๋ ๊ฒฝ์ฐ ์ปดํ์ผ๋ฌ๋ ์ด ์ธํฐํ์ด์ค๋ฅผ ์๋ชป๋ ์ฝ๋๋ก ์ธ์ํ๋ฏ๋ก ์ด ์ธํฐํ์ด์ค๋ฅผ ๊ฑด๋๋ฐ์ง ์์ต๋๋ค. ์ด ์ฃผ์์ด ์๋ ์ธํฐํ์ด์ค๋ ๊ธฐ๋ฅ์ ์ด๋ฉฐ ์๋ํ๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋ ์ ์์ง๋ง @FunctionalInterface
์ด๋ ์ถ๊ฐ ๋ณดํ์ ์ง๋์ง ์์ต๋๋ค. ์์
์ผ๋ก ๋์๊ฐ์ Comparator
. ํด๋น ์ฝ๋(๋๋ ๋ฌธ์ ) ๋ฅผ ๋ณด๋ฉด ๋ ๊ฐ์ง ์ด์์ ๋ฉ์๋๊ฐ ์์์ ์ ์ ์์ต๋๋ค. ๊ทธ๋ ๋ค๋ฉด ๋น์ ์ ๋ฌป์ต๋๋ค. ๊ทธ๋ ๋ค๋ฉด ์ด๋ป๊ฒ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค๋ก ๊ฐ์ฃผ๋ ์ ์์ต๋๊น? ์ถ์ ์ธํฐํ์ด์ค์๋ ๋จ์ผ ๋ฉ์๋์ ๋ฒ์ ๋ด์ ์์ง ์์ ๋ฉ์๋๊ฐ ์์ ์ ์์ต๋๋ค.
- ๊ณต์
@FunctionalInterface
public interface Converter<T, N> {
N convert(T t);
static <T> boolean isNotNull(T t){
return t != null;
}
}
์ด ๋ฉ์๋๋ฅผ ์์ ํ ํ ์ปดํ์ผ๋ฌ๋ ๋ถํํ์ง ์์์ต๋๋ค. ์ด๋ ์ธํฐํ์ด์ค๊ฐ ์ฌ์ ํ ์๋ํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
- ๊ธฐ๋ณธ ๋ฐฉ๋ฒ
default
.
@FunctionalInterface
public interface Converter<T, N> {
N convert(T t);
static <T> boolean isNotNull(T t){
return t != null;
}
default void writeToConsole(T t) {
System.out.println("ะขะตะบััะธะน an object - " + t.toString());
}
}
๋ค์ ๋งํ์ง๋ง, ์ฐ๋ฆฌ๋ ์ปดํ์ผ๋ฌ๊ฐ ๋ถํ์ ์์ํ์ง ์์์ผ๋ฉฐ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค์ ํ๊ณ๋ฅผ ๋์ด์์ง ์์์์ ์ ์ ์์ต๋๋ค.
- ๊ฐ์ฒด ํด๋์ค ๋ฉ์๋
Object
. ์ด๋ ์ธํฐํ์ด์ค์๋ ์ ์ฉ๋์ง ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ธํฐํ์ด์ค์ ํด๋์ค์ ์ผ๋ถ ๋ฉ์๋์ ์๋ช
์ด ์ผ์นํ๋ ์ถ์ ๋ฉ์๋๊ฐ ์๋ ๊ฒฝ์ฐ Object
์ด๋ฌํ ๋ฉ์๋(๋๋ ๋ฉ์๋)๋ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค ์ ํ์ ๊นจ์ง ์์ต๋๋ค.
@FunctionalInterface
public interface Converter<T, N> {
N convert(T t);
static <T> boolean isNotNull(T t){
return t != null;
}
default void writeToConsole(T t) {
System.out.println("ะขะตะบััะธะน an object - " + t.toString());
}
boolean equals(Object obj);
}
๊ทธ๋ฆฌ๊ณ ๋ค์ ๋งํ์ง๋ง, ์ฐ๋ฆฌ ์ปดํ์ผ๋ฌ๋ ๋ถํํ์ง ์์ผ๋ฏ๋ก ์ธํฐํ์ด์ค๋ Converter
์ฌ์ ํ ๊ธฐ๋ฅ์ ์ธ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋ฉ๋๋ค. ์ด์ ์ง๋ฌธ์: ์ ์ฐ๋ฆฌ๋ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค์์ ๊ตฌํ๋์ง ์์ ํ๋์ ๋ฉ์๋๋ก ์ ํํด์ผ ํฉ๋๊น? ๊ทธ๋ฐ ๋ค์ ๋๋ค๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ์ด๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค Converter
. ์ด๋ฅผ ์ํด ํด๋์ค๋ฅผ ์์ฑํด ๋ณด๊ฒ ์ต๋๋ค Dog
.
public class Dog {
String name;
int age;
int weight;
public Dog(final String name, final int age, final int weight) {
this.name = name;
this.age = age;
this.weight = weight;
}
}
๊ทธ๋ฆฌ๊ณ ๋น์ทํ ๊ฒ Raccoon
(๋๊ตฌ๋ฆฌ):
public class Raccoon {
String name;
int age;
int weight;
public Raccoon(final String name, final int age, final int weight) {
this.name = name;
this.age = age;
this.weight = weight;
}
}
๊ฐ์ฒด๊ฐ ์๊ณ Dog
ํด๋น ํ๋๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํด์ผ ํ๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค Raccoon
. ์ฆ, Converter
ํ ์ ํ์ ๊ฐ์ฒด๋ฅผ ๋ค๋ฅธ ์ ํ์ผ๋ก ๋ณํํฉ๋๋ค. ์ด๋ป๊ฒ ๋ณด์ผ๊น์?
public static void main(String[] args) {
Dog dog = new Dog("Bobbie", 5, 3);
Converter<Dog, Raccoon> converter = x -> new Raccoon(x.name, x.age, x.weight);
Raccoon raccoon = converter.convert(dog);
System.out.println("Raccoon has parameters: name - " + raccoon.name + ", age - " + raccoon.age + ", weight - " + raccoon.weight);
}
์ด๋ฅผ ์คํํ๋ฉด ์ฝ์์ ๋ค์๊ณผ ๊ฐ์ ์ถ๋ ฅ์ด ํ์๋ฉ๋๋ค.
Raccoon has parameters: name - Bobbbie, age - 5, weight - 3
์ด๋ ์ฐ๋ฆฌ์ ๋ฐฉ๋ฒ์ด ์ฌ๋ฐ๋ฅด๊ฒ ์๋ํ์์ ์๋ฏธํฉ๋๋ค.
๊ธฐ๋ณธ Java 8 ๊ธฐ๋ฅ ์ธํฐํ์ด์ค
์ด์ Java 8์ด ์ ๊ณตํ๊ณ Stream API์ ํจ๊ป ์ ๊ทน์ ์ผ๋ก ์ฌ์ฉ๋๋ ๋ช ๊ฐ์ง ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.์ ๋ถ
Predicate
โ ํน์ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋๋์ง ํ์ธํ๊ธฐ ์ํ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค์
๋๋ค. ์กฐ๊ฑด์ด ์ถฉ์กฑ๋๋ฉด ๋ฅผ ๋ฐํํ๊ณ true
, ๊ทธ๋ ์ง ์์ผ๋ฉด -๋ฅผ ๋ฐํํฉ๋๋ค false
.
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ Predicate
์ฌ๋ฌ ์ ํ์ ํจ๋ฆฌํฐ๋ฅผ ํ์ธํ๋ ๋ฅผ ๋ง๋๋ ๊ฒ์ ๊ณ ๋ คํด ๋ณด์ธ์ Integer
.
public static void main(String[] args) {
Predicate<Integer> isEvenNumber = x -> x % 2==0;
System.out.println(isEvenNumber.test(4));
System.out.println(isEvenNumber.test(3));
}
์ฝ์ ์ถ๋ ฅ:
true
false
์๋น์
Consumer
(์์ด - "consumer") - T ์ ํ์ ๊ฐ์ฒด๋ฅผ ์
๋ ฅ ์ธ์๋ก ์ฌ์ฉํ๊ณ ์ผ๋ถ ์์
์ ์ํํ์ง๋ง ์๋ฌด๊ฒ๋ ๋ฐํํ์ง ์๋ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค์
๋๋ค.
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
์๋ฅผ ๋ค์ด, ์ ๋ฌ๋ ๋ฌธ์์ด ์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฝ์์ ์ธ์ฌ๋ง์ ์ถ๋ ฅํ๋ ์์
์ ์ํํ๋ ๋ฅผ ์๊ฐํด ๋ณด์ธ์. Consumer
public static void main(String[] args) {
Consumer<String> greetings = x -> System.out.println("Hello " + x + " !!!");
greetings.accept("Elena");
}
์ฝ์ ์ถ๋ ฅ:
Hello Elena !!!
๊ณต๊ธ์
Supplier
(์์ด - ๊ณต๊ธ์) - ์ธ์๋ฅผ ์ฌ์ฉํ์ง ์์ง๋ง T ์ ํ์ ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค:
@FunctionalInterface
public interface Supplier<T> {
T get();
}
์๋ฅผ ๋ค์ด Supplier
๋ชฉ๋ก์์ ์์์ ์ด๋ฆ์ ์์ฑํ๋ ์ ๊ณ ๋ คํ์ญ์์ค.
public static void main(String[] args) {
ArrayList<String> nameList = new ArrayList<>();
nameList .add("Elena");
nameList .add("John");
nameList .add("Alex");
nameList .add("Jim");
nameList .add("Sara");
Supplier<String> randomName = () -> {
int value = (int)(Math.random() * nameList.size());
return nameList.get(value);
};
System.out.println(randomName.get());
}
๊ทธ๋ฆฌ๊ณ ์ด๊ฒ์ ์คํํ๋ฉด ์ฝ์์ ์ด๋ฆ ๋ชฉ๋ก์์ ๋ฌด์์ ๊ฒฐ๊ณผ๊ฐ ํ์๋ฉ๋๋ค.
๊ธฐ๋ฅ
Function
โ ์ด ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค๋ ์ธ์ T๋ฅผ ์ทจํด ์ด๋ฅผ R ์ ํ์ ๊ฐ์ฒด๋ก ์บ์คํ
ํ๊ณ ๊ฒฐ๊ณผ๋ก ๋ฐํ๋ฉ๋๋ค.
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
์๋ฅผ ๋ค์ด ์ซ์๋ฅผ ๋ฌธ์์ด ํ์( )์์ ์ซ์ ํ์( ) ์ผ๋ก ๋ณํํ๋ ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.Function
String
Integer
public static void main(String[] args) {
Function<String, Integer> valueConverter = x -> Integer.valueOf(x);
System.out.println(valueConverter.apply("678"));
}
์ด๋ฅผ ์คํํ๋ฉด ์ฝ์์ ๋ค์๊ณผ ๊ฐ์ ์ถ๋ ฅ์ด ํ์๋ฉ๋๋ค.
678
์ถ์ : ์ซ์ ๋ฟ๋ง ์๋๋ผ ๋ค๋ฅธ ๋ฌธ์๋ ๋ฌธ์์ด์ ์ ๋ฌํ๋ฉด ์์ธ๊ฐ ๋ฐ์ํฉ๋๋ค .NumberFormatException
๋จํญ ์ฐ์ฐ์
UnaryOperator
โ T ์ ํ์ ๊ฐ์ฒด๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ทจํ์ฌ ์ด์ ๋ํด ์ผ๋ถ ์์
์ ์ํํ๊ณ ๋์ผํ T ์ ํ์ ๊ฐ์ฒด ํํ๋ก ์์
๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค์
๋๋ค.
@FunctionalInterface
public interface UnaryOperator<T> {
T apply(T t);
}
UnaryOperator
apply
, ์ซ์๋ฅผ ์ ๊ณฑํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํฉ๋๋ค .
public static void main(String[] args) {
UnaryOperator<Integer> squareValue = x -> x * x;
System.out.println(squareValue.apply(9));
}
์ฝ์ ์ถ๋ ฅ:
81
์ฐ๋ฆฌ๋ ๋ค์ฏ ๊ฐ์ง ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค๋ฅผ ์ดํด๋ณด์์ต๋๋ค. ์ด๊ฒ์ด Java 8๋ถํฐ ์ฌ์ฉํ ์ ์๋ ์ ๋ถ๋ ์๋๋๋ค. ์ด๊ฒ์ด ๊ธฐ๋ณธ ์ธํฐํ์ด์ค์
๋๋ค. ์ฌ์ฉ ๊ฐ๋ฅํ ๋๋จธ์ง ๊ฒ๋ค์ ๋ณต์กํ ์ ์ฌํ์
๋๋ค. ์ ์ฒด ๋ชฉ๋ก์ ๊ณต์ Oracle ์ค๋ช
์์์ ํ์ธํ ์ ์์ต๋๋ค .
Stream์ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค
์์์ ์ค๋ช ํ ๊ฒ์ฒ๋ผ ์ด๋ฌํ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค๋ Stream API์ ๊ธด๋ฐํ๊ฒ ๊ฒฐํฉ๋์ด ์์ต๋๋ค. ์ด๋ป๊ฒ ๋ฌผ์ด๋ณด๋์? ๊ทธ๋ฆฌ๊ณ ๋ง์ ๋ฉ์๋๊ฐStream
์ด๋ฌํ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค์ ํน๋ณํ ์๋ํฉ๋๋ค. NET์์ ๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค๋ฅผ ์ด๋ป๊ฒ ์ฌ์ฉํ ์ ์๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค Stream
.
์ ์ด๊ฐ ์๋ ๋ฐฉ๋ฒ
์๋ฅผ ๋ค์ด, ์ธ์๋ก ์ฌ์ฉ ํ๊ณ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์์๋ง ๋ฐํํ๋ ํด๋์ค ๋ฉ์๋๋ฅผ ์ดํดStream
๋ณด๊ฒ ์ต๋๋ค . -a ์ ๋งฅ๋ฝ์์ ์ด๋ ์ธํฐํ์ด์ค ๋ฉ์๋ ์์ ์ฌ์ฉ๋ ๋ ๋ฐํ๋๋ ์์๋ง ํต๊ณผํ๋ค๋ ์๋ฏธ์
๋๋ค . ์ด๊ฒ์ ์ฐ๋ฆฌ์ ์๊ฐ ์ ๋ํ ๋ชจ์ต ์ด์ง๋ง ๋ค์์ ์์ ํํฐ์ ๋ํ ๊ฒ ์
๋๋ค . filter
Predicate
Stream
Predicate
Stream
true
test
Predicate
Predicate
Stream
public static void main(String[] args) {
List<Integer> evenNumbers = Stream.of(1, 2, 3, 4, 5, 6, 7, 8)
.filter(x -> x % 2==0)
.collect(Collectors.toList());
}
๊ฒฐ๊ณผ์ ์ผ๋ก ๋ชฉ๋ก์ evenNumbers
{2, 4, 6, 8} ์์๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ๊ฐ ๊ธฐ์ตํ๋ ๊ฒ์ฒ๋ผ collect
๋ชจ๋ ์์๋ฅผ โโํน์ ์ปฌ๋ ์
์ผ๋ก ์์งํฉ๋๋ค. ์ฐ๋ฆฌ์ ๊ฒฝ์ฐ List
.
์๋น์์์ ๋ฐฉ๋ฒ
Stream
๊ธฐ๋ฅ์ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ ์ ๋ฉ์๋ ์ค ํ๋๋ Consumer
์
๋๋ค peek
. Consumer
in ์ ๋ํ ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค Stream
:
public static void main(String[] args) {
List<String> peopleGreetings = Stream.of("Elena", "John", "Alex", "Jim", "Sara")
.peek(x -> System.out.println("Hello " + x + " !!!"))
.collect(Collectors.toList());
}
์ฝ์ ์ถ๋ ฅ:
Hello Elena !!!
Hello John !!!
Hello Alex !!!
Hello Jim !!!
Hello Sara !!!
๊ทธ๋ฌ๋ ์ด ๋ฉ์๋๋ peek
์ ํจ๊ป ์๋ ํ๋ฏ๋ก Consumer
๋ฌธ์์ด ์์ ์ Stream
๋ฐ์ํ์ง ์์ง๋ง ์๋ ์์์ ๋์ผํ๊ฒ peek
๋ฐํ๋ฉ๋๋ค . Stream
๋ฐ๋ผ์ ๋ชฉ๋ก์ peopleGreetings
"Elena", "John", "Alex", "Jim", "Sara" ์์๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉ๋๋ ๋ฐฉ๋ฒ๋ ์๋๋ฐ foreach
, ์ด ๋ฐฉ๋ฒ๊ณผ ์ ์ฌ peek
ํ์ง๋ง ์ต์ข
-์ข
๋ฃ์ ์ด๋ผ๋ ์ ์ด ๋ค๋ฆ
๋๋ค.
๊ณต๊ธ์์์ ๋ฐฉ๋ฒ
Stream
ํจ์ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ ์ ๋ฉ์๋ ์๋ก ์ ๋ฌ๋ ํจ์ ์ธํฐํ์ด์ค๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ฌดํ ์ํ์ค๋ฅผ ์์ฑํ๋ ๊ฐ Supplier
์์ต๋๋ค . generate
์์ ๋ฅผ ์ฌ์ฉํ์ฌ Supplier
5๊ฐ์ ์์์ ์ด๋ฆ์ ์ฝ์์ ์ธ์ํด ๋ณด๊ฒ ์ต๋๋ค.
public static void main(String[] args) {
ArrayList<String> nameList = new ArrayList<>();
nameList.add("Elena");
nameList.add("John");
nameList.add("Alex");
nameList.add("Jim");
nameList.add("Sara");
Stream.generate(() -> {
int value = (int) (Math.random() * nameList.size());
return nameList.get(value);
}).limit(5).forEach(System.out::println);
}
๊ทธ๋ฆฌ๊ณ ์ด๊ฒ์ ์ฝ์์์ ์ป๋ ์ถ๋ ฅ์
๋๋ค:
John
Elena
Elena
Elena
Jim
limit(5)
์ฌ๊ธฐ์๋ ๋ฉ์๋์ ์ ํ์ ์ค์ ํ๊ธฐ ์ํด ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ต๋๋ค generate
. ๊ทธ๋ ์ง ์์ผ๋ฉด ํ๋ก๊ทธ๋จ์ ์ฝ์์ ์์์ ์ด๋ฆ์ ๋ฌด๊ธฐํ์ผ๋ก ์ธ์ํฉ๋๋ค.
ํจ์๊ฐ ์๋ ๋ฐฉ๋ฒ
Stream
์ธ์๊ฐ ์๋ ๋ฉ์๋์ ์ผ๋ฐ์ ์ธ ์๋ ํ ์ ํ์ ์์๋ฅผ ๊ฐ์ ธ์์ ์ด๋ฅผ ์ฌ์ฉํ์ฌ ์์
์ ์ํํ๊ณ ์ ๋ฌํ๋ Function
๋ฉ์๋์
๋๋ค . ๊ทธ๋ฌ๋ ์ด๋ฌํ ์์๋ ์ด๋ฏธ ๋ค๋ฅธ ์ ํ์ ์์์ผ ์ ์์ต๋๋ค. in์ map
์ฌ์ฉํ ์๋ ๋ค์ ๊ณผ ๊ฐ์ต๋๋ค . Function
Stream
public static void main(String[] args) {
List<Integer> values = Stream.of("32", "43", "74", "54", "3")
.map(x -> Integer.valueOf(x)).collect(Collectors.toList());
}
๊ฒฐ๊ณผ์ ์ผ๋ก ์ฐ๋ฆฌ๋ ์ซ์ ๋ชฉ๋ก์ ์ป์ง๋ง Integer
.
UnaryOperator๋ฅผ ์ฌ์ฉํ๋ ๋ฉ์๋
์ธ์๋ก ์ฌ์ฉํ๋ ๋ฉ์๋๋ก ํด๋์ค ๋ฉ์๋ -UnaryOperator
๋ฅผ ์ฌ์ฉํ๊ฒ ์ต๋๋ค . ์ด ๋ฉ์๋๋ ๋ฉ์๋์ ์ ์ฌํฉ๋๋ค . ๋ํ ๋ฌดํ ์ํ์ค๋ฅผ ์์ฑํ์ง๋ง ๋ ๊ฐ์ ์ธ์๊ฐ ์์ต๋๋ค.Stream
iterate
generate
- ์ฒซ ๋ฒ์งธ๋ ์ํ์ค ์์ฑ์ด ์์๋๋ ์์์ ๋๋ค.
- ๋ ๋ฒ์งธ๋ ์ด๋ฉฐ
UnaryOperator
, ์ด๋ ์ฒซ ๋ฒ์งธ ์์์์ ์ ์์๋ฅผ ์์ฑํ๋ ์๋ฆฌ๋ฅผ ๋ํ๋ ๋๋ค.
UnaryOperator
. ๊ทธ๋ฌ๋ ๋ฉ์๋์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค iterate
.
public static void main(String[] args) {
Stream.iterate(9, x -> x * x)
.limit(4)
.forEach(System.out::println);
}
์ด๋ฅผ ์คํํ๋ฉด ์ฝ์์ ๋ค์๊ณผ ๊ฐ์ ์ถ๋ ฅ์ด ํ์๋ฉ๋๋ค.
9
81
6561
43046721
์ฆ, ๊ฐ ์์๋ ์์ฒด์ ์ผ๋ก ๊ณฑํด์ง๊ณ ์ฒ์ ๋ค ์ซ์์ ๋ํด์๋ ๋ง์ฐฌ๊ฐ์ง์
๋๋ค. ๊ทธ๊ฒ ๋ค์ผ! ์ด ๊ธฐ์ฌ๋ฅผ ์ฝ์ ํ Java์ Stream API๋ฅผ ์ดํดํ๊ณ ๋ง์คํฐํ๋ ๋ฐ ํ ๊ฑธ์ ๋ ๊ฐ๊น์์ง๋ฉด ์ข์ ๊ฒ์
๋๋ค!
GO TO FULL VERSION