π μμ© 5μ₯ λλ€μκ³Ό ν¨μ, μ€νΈλ¦Ό
1κΈ κ°μ²΄
π‘
1κΈ κ°μ²΄λ, λ³μμ λμ
κ°λ₯ν κ°μ²΄λ₯Ό 1κΈ κ°μ²΄ (first class object) λΌκ³ νλ€.
λνμ 1κΈ κ°μ²΄ : κ°
, μΈμ€ν΄μ€
, λ°°μ΄
ν¨μ (function)
π‘
Java8μ μΆκ°λ κ°λ
: ν¨μλ 1κΈ κ°μ²΄λ‘ μ·¨κΈ λλ€.
ν¨μλ, μ λ ₯μ λν΄ μ²λ¦¬ ν μΆλ ₯νλ κ²
y = 2x + 3
λ©μλλ₯Ό λ³μμ λμ νμ¬ μ¬μ©νλ μ
import java.util.function.IntBinaryOperator;
public class Main {
public static int add(int x, int y) {
return x + y;
}
public static void main(String[] args) {
// 미리 μ μλ μΈν°νμ΄μ€
// μμ μ μν add() λ©μλλ₯Ό func μΈν°νμ΄μ€ λ³μμ λμ
νλ€.
IntBinaryOperator func = Main::add;
int result = func.applyAsInt(5, 3);
System.out.println("5 + 3 = " + result);
}
}

π‘
μ
μΆλ ₯ νμ
λ§ κ°λ€λ©΄, λ©μλλ₯Ό λ³μμ λμ
νλ κ²μ΄ κ°λ₯νλ€.
μ μ½λμμλ 미리 μ μλ
IntBinaryOperator
μΈν°νμ΄μ€ λ³μμ μμλ‘ μ μν add()
ν¨μλ₯Ό λμ
νλ€.
:: (Method Reference)
π‘
::
λ λ©μλ λ νΌλ°μ€(Method Reference)λ₯Ό λνλ΄λ μ°μ°μμ΄λ€.
λ©μλ λ νΌλ°μ€λ λ©μλλ₯Ό μ°Έμ‘°νλ κ°μ²΄λ₯Ό μμ±νλ ν¨μν μΈν°νμ΄μ€μ μΈμ€ν΄μ€λ₯Ό μμ±ν λ μ¬μ©λλ€. λ©μλ λ νΌλ°μ€λ₯Ό μ¬μ©νλ©΄ λΆνμν λλ€ ννμμ μ κ±°νμ¬ κ°λ
μ±μ ν₯μμν€κ³ , μ½λμκΈΈμ΄λ₯Ό μ€μΌ μ μλ€.
μλ₯Ό λ€μ΄, Math ν΄λμ€μ abs λ©μλλ₯Ό λλ€ ννμμΌλ‘ λνλ΄λ©΄ λ€μκ³Ό κ°λ€.
Function<Integer, Integer> absFunc = (x) -> Math.abs(x);
λ©μλ λ νΌλ°μ€λ₯Ό μ¬μ©νλ©΄ μ΄ μ½λλ₯Ό λ€μκ³Ό κ°μ΄ κ°λ¨νκ² λνλΌ μ μλ€.
Function<Integer, Integer> absFunc = Math::abs;
::
μ°μ°μλ λ©μλ λ νΌλ°μ€λ₯Ό μ°Έμ‘°νλ κ°μ²΄λ₯Ό μμ±νλ ν¨μν μΈν°νμ΄μ€μ μΈμ€ν΄μ€
λ₯Ό μμ±ν λ μ¬μ©λλ€. λ©μλ λ νΌλ°μ€λ λ€μν ννλ‘ μ¬μ©λ μ μμΌλ©°, λ©μλ μ΄λ¦κ³Ό
ν΄λμ€ μ΄λ¦, μμ±μ μ΄λ¦ λ±μ ν¨κ» μ¬μ©νμ¬ ννλλ€.
λ©μλμ ν¨μμ μ°¨μ΄
π‘
- λ©μλλ ν΄λμ€μ μνκ³ ν΄λμ€λ₯Ό μ‘°μνκΈ° μν μΌμ’
μ ν¨μμ΄λ€.
- λ©μλλ μ΄λ¦μ΄ μμ§λ§, ν¨μμκ² μ΄λ¦μ μ€μνμ§ μλ€.
public static int add(int x, int y) {
return x + y;
}
public static int λνκΈ°(int a, int b) {
return a + b;
}
π‘
ν¨μλ μ΄λ¦μ λ€λ₯΄μ§λ§ inputκ³Ό outputμ΄ κ°μΌλ―λ‘, λμΌν ν¨μλΌ λ³Ό μ μλ€.
ν¨μ μ μ₯μ© μΈν°νμ΄μ€ μ μΈ
π‘
μΆμ λ©μλκ° 1κ°μΈ(SAM : Single Abstract Method) μΈν°νμ΄μ€λ ν¨μ μ μ₯ μ©λλ‘ μ¬μ© κ°λ₯νλ€
ν¨μ μ μ₯μ© λ²μ© API
π‘
Javaμμ μμ£Ό μ¬μ©ν κ² κ°μ ν¨μ μ μ₯μ© λ²μ© API μ 곡
β μ§μ SAM μΈν°νμ΄μ€
λ₯Ό μ μν μλ μμ§λ§, 미리 μ 곡λ SAM μΈν°νμ΄μ€ APIλ₯Ό νμ©ν΄λ³΄μ.

μ€λͺ
Predicate<T>
: <T>μ κ°μ inputμΌλ‘ λ°κ³ , 쑰건μ λ°λΌ boolean κ°μ μΆλ ₯νλ ν¨μλ₯Ό μ μ₯ν λ ν΄λΉ μΈν°νμ΄μ€λ₯Ό μ¬μ©ν μ μλ€.
λλ€μ (Lambda Expression)
π‘
Lambda μ
νμ©νμ¬ ν¨μ λ΄μ©μ λ°λ‘λ°λ‘ μ μν΄μ μ¬μ©ν μ μλ€.interface MyFuction {
int call(int a, int b);
}
public class Main {
public static void main(String[] args) {
// Lambda μμ νμ©ν ν¨μ μ μ λ° μΈν°νμ΄μ€ κ°μ²΄ λμ
MyFuction func = (int a, int b) -> {
return a + b;
};
int result = func.call(5, 3);
System.out.println("5 + 3 = " + result);
}
}
λλ€μμ νκΈ°λ²
μ μμ μΈ Lambda expression νκΈ°
IntToDoubleFunction func = (int a) -> {
return a * 3.14;
};
μ λ ₯ νμ μλ΅ κ°λ₯
IntToDoubleFunction func = (a) -> {
return a * 3.14;
};
π‘
μ΄μ°¨νΌ
interface
μ μ§μ λμ΄ μκΈ° λλ¬Έμ μλ΅μ΄ κ°λ₯νλ€!
interface
λ΄ μ§μ λ νμ
μΈμλ κ°μ μ€ μ μλ€.μ λ ₯ κ°μ΄ 1κ°μΌ κ²½μ° μκ΄νΈ μλ΅ κ°λ₯
IntToDoubleFunction func = a -> {
return a * 3.14;
};
ν¨μμ λ΄μ©μ΄ λ¦¬ν΄ λ°μ μμ κ²½μ° μ€κ΄νΈ λ° return ν€μλ μλ΅ κ°λ₯
IntToDoubleFunction func = a -> a * 3.14;
μ€νΈλ¦Ό(Stream)
π‘
μ€νΈλ¦Ό(Stream)μ΄λ?
- Java Streamμ Java Collection Frameworkμ μμλ€μ μ²λ¦¬νλλ° μ¬μ©λλ€.
- ν¨μν νλ‘κ·Έλλ° κ°λ
μ λμ
νμ¬ μ½λμ κ°κ²°μ±κ³Ό κ°λ
μ±μ΄ ν₯μλλ€.
(μ°Έκ³ β) _ λ°μ΄ν° μ
μΆλ ₯μ κ΄λ ¨λ streamκ³Όλ λ³κ°μ΄λ€!!
Streamμ νΉμ§
- μμλ€μ λ³κ²½νμ§ μλλ€. λμ , μμλ€μ μλ³Έ λ°μ΄ν° μμ€λ‘λΆν° μλ‘μ΄ μ€νΈλ¦Όμ μμ±νλ€.
- ν λ²μ νλμ μμλ§ μ²λ¦¬νλ€.
- μ€κ° μ²λ¦¬ λ¨κ³μ μ΅μ’ μ²λ¦¬ λ¨κ³λ‘ λλλ€. μ€κ° μ²λ¦¬ λ¨κ³μμλ νν°λ§, λ§€ν, μ λ ¬ λ±μ μ²λ¦¬λ₯Ό μννκ³ , μ΅μ’ μ²λ¦¬ λ¨κ³μμλ κ²°κ³Όλ₯Ό μμ§νλ€.
- λ³λ ¬ μ²λ¦¬λ₯Ό μ§μνλ€.
π‘
ν¨μλ₯Ό κ°μΌλ‘ μ·¨κΈν λμ μ΄μ
Java 8μ μΆκ°λ ν¨μλ₯Ό λ€λ£¨κΈ° μν λ²μ© API Streamμ μ¬μ©νλ©΄,
μ’ λ ν¨μμ μΈ μ¬κ³ λ₯Ό κ°μ§κ³ κ°λ°ν μ μλ€.
β ν¨μν νλ‘κ·Έλλ°
π‘
Java Streamμ λ©μλ
- filter(): μμλ€μ νν°λ§
- map(): μμλ€μ λ³ν
- sorted(): μμλ€μ μ λ ¬
- distinct(): μ€λ³΅λ μμλ€μ μ κ±°
- limit(): μμλ€μ κ°μλ₯Ό μ ν
- forEach(): μμλ€μ λ°λ³΅ μ²λ¦¬
- collect(): μμλ€μ μμ§
- reduce(): μμλ€μ νλλ‘ ν©μΉκΈ°
Stream μμ μ°μ΅ 1 - ArrayList μμ μ²λ¦¬νκΈ°
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Main2 {
public static void main(String[] args) {
// μ€νΈλ¦Ό μ€μ΅
List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));
// μΌλ°μ μΈ forλ¬Έμ ν΅ν μ§μ μΆλ ₯
for (int i = 0; i < nums.size(); i++) {
if (nums.get(i) % 2 == 0) {
System.out.println(nums.get(i) + 1);
}
}
// μ€νΈλ¦Όμ νμ©ν μΆλ ₯
nums.stream().forEach((num) -> {
System.out.println(num); //μ
λ ₯μ΄ Integerμ΄κ³ , 리ν΄μ΄ void
});
// μ μ½λ μΆμ½
nums.stream().forEach(num -> System.out.println(num));
// νλ² λ μΆμ½
nums.stream().forEach(System.out::println);
// νν° μ¬μ© - μ£Όμ΄μ§ 쑰건μ λ§€μΉλλ κ²λ§ μΆλ ₯νλ λ²
// Mapμ μ¬μ©νλ©΄ Listμ νμ
μ λ³νμν¬ μ μλ€.
nums.stream().filter((Integer num) -> num % 2 == 0) // μ§μλ§ λ¨κ² νκΈ°
.map((num) -> num + "λ²") // λ³νν λ map μ¬μ© (<T>) -> (<R>)
.forEach((num) -> System.out.println(num + 1));
}
}

Stream μμ μ°μ΅ 2 - βλ°βμ¨ κ°μ Έμ€κΈ°
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main2 {
// 'λ°'μ¨ κ°μ Έμ€κΈ° - streamμ νμ©ν lambda μ νν
public static List<String> getParkListStream(List<String> names) {
return names.stream().filter(name -> name.startsWith("λ°")).collect(Collectors.toList());
}
// 'λ°'μ¨ κ°μ Έμ€κΈ° - κΈ°μ‘΄ forλ¬Έμ νμ©ν νν
public static List<String> getParkList(List<String> names) {
List<String> results = new ArrayList<>();
for (String name : names) {
if (name.startsWith("λ°")) {
results.add(name);
}
}
return results;
}
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("λ°1");
names.add("λ°2");
names.add("μ΄1");
names.add("κΉ1");
names.add("λ°3");
List<String> parks = getParkList(names);
List<String> parks2 = getParkListStream(names);
System.out.println(parks);
System.out.println(parks2);
}
}

π‘
Streamμ λͺ¨λ λ¦¬ν΄ νμ
μ΄ stream νμ
μ΄λ€.
κ·Έλ κΈ°μ ν μ€ μ½λ©μΌλ‘ .() ν μ μλ κ²μ΄λ€.
-> λ©μλ 체μ΄λ
forEachλ 맨 λ§μ§λ§μλ§ μ¬ μ μλ€.
π‘
μ§κΈ κΉμ§λ 리μ€νΈμ κ° λ°μ΄ν°λ₯Ό μ κ·Όν΄ μ§μ κ°μ Έμ μ²λ¦¬νλ€.
Streamμ μ¬μ©νλ©΄, κΈ°μ‘΄ forλ¬Έμμ forEachλ‘ λ체νκ³ , 리μ€νΈ κ°μ forEach(λλ€μ)μ ν΅ν΄ κ° λ°μ΄ν°κ° Stream ννλ‘ μ€μ€ν λλ€μ ν¨μλ₯Ό κ±°μ³ μΆλ ₯λλ ννμ΄λ€.
μ΄λ¬ν λ°©μμ ν¨μν νλ‘κ·Έλλ°μ΄λΌ λ³Ό μ μλ€.
for vs stream
π‘
Streamμ 컬λ μ
μ λ€λ£¨λλ° μμ΄μ forλ¬Έλ³΄λ€ ν¨μ¨μ μ΄λ€. Streamμ λ³λ ¬ μ²λ¦¬μ μ 리ν
λ©°, λ°μ΄ν°λ₯Ό νμν λΆλΆλ§ μ²λ¦¬νκΈ° λλ¬Έμ μ±λ₯μ΄ μ’μμ§λ€. λν, Streamμ κ°κ²°ν μ½λ
λ‘ μ»¬λ μ
μ λ€λ£° μ μμ΄μ κ°λ
μ±μ΄ μ’μμ§λ€.
πμ°μ΅ λ¬Έμ
5-1

package com.pkd.Exam;
public class Utils {
public static boolean isOdd(int n) {
return n % 2 == 1;
}
public static String addNamePrefix(boolean male, String name) {
if (male == true) {
return "Mr." + name;
}
return "Ms." + name;
}
}
package com.pkd.Exam;
public interface Func1 {
boolean call(int n);
}
package com.pkd.Exam;
public interface Func2 {
String call(boolean b, String s);
}
5-2

package com.pkd.Exam;
public class Main {
public static void main(String[] args) {
Func1 func1 = num -> num % 2 == 1;
Func2 func2 = (male, name) -> {
if (male == true) {
return "Mr." + name;
}
return "Ms." + name;
};
}
}
π‘
Func1μ μλ΅ : 1) μ
λ ₯ νμ
, 2) μ
λ ₯ κ° 1κ° μΌ λ μκ΄νΈ, 3) μ€κ΄νΈ, 리ν΄
Func2μ μλ΅ : 1) μ
λ ₯ νμ
Uploaded by N2T