์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 |
- ๋ฐ์ดํฐ ์ ์ก
- IEEE 802
- ํ๋ ์ ๊ตฌ์กฐ
- til
- ์ค๋ ๋
- ์ค๋ฅ์ ์ด
- ์ฃผ๊ธฐ์ ํธ
- git merge
- ๊ฐ๋ฐ์์ทจ์
- ์ค๋ธ์
- ํญํด99
- ์ค๋ฅ๊ฒ์ถ
- ์๋น์ค ํ๋ฆฌ๋ฏธํฐ๋ธ
- reducible
- mariadb
- well known ํฌํธ
- tcp ์ธ๊ทธ๋จผํธ
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- ํ ํฐ ๋ฒ์ค
- 99ํด๋ฝ
- leetcode
- ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ
- ๋น์ฃผ๊ธฐ์ ํธ
- ์ฝ๋ฉํ ์คํธ์ค๋น
- ์ฐ๋ถํฌdb
- ์์๋ฒํธ
- xv6
- tcp ํ๋กํ ์ฝ
- i-type
- ํ๋ก์ด๋์์
- Today
- Total
Unfazedโ๏ธ๐ฏ
Java Stream API - map() & flatMap() ๋ณธ๋ฌธ
Java 8์์ ๋์ ๋ Stream API๋ ์ปฌ๋ ์ ์ ์ฒ๋ฆฌํ๋ ํจ๊ณผ์ ์ธ ๋ฐฉ๋ฒ์ ์ ๊ณตํ๋ค. ๊ทธ ์ค์์๋ map()๊ณผ flatMap() ๋ฉ์๋๋ ๋ฐ์ดํฐ ๋ณํ๊ณผ ์ฒ๋ฆฌ์ ์์ด ํต์ฌ์ ์ธ ์ญํ ์ ํ๋ค.
1. map()
<R> Stream<R> map(
Function<? super T, // T : ์
๋ ฅ ํ์
(์๋ณธ ์คํธ๋ฆผ์ ์์ ํ์
)
? extends R> mapper // R : ์ถ๋ ฅ ํ์
(์๋ก์ด ์คํธ๋ฆผ์ ์์ ํ์
)
)
map() ๋ฉ์๋๋ ์คํธ๋ฆผ์ ๊ฐ ์์๋ฅผ ๋ค๋ฅธ ์์๋ก ๋ณํํ๋ 1:1 ๋งคํ์ ์ํํ๋ค. ์ ๋ ฅ ์์ ํ๋๋น ์ ํํ ํ๋์ ์ถ๋ ฅ ์์๊ฐ ์์ฑ๋๋ค.
์ฃผ์ ํน์ง
- ๊ฐ ์์๋ฅผ ๋ ๋ฆฝ์ ์ผ๋ก ๋ณํ
- ์คํธ๋ฆผ์ ์์ ๊ฐ์ ์ ์ง (one-to-one)
- ์๋ณธ ๋ฐ์ดํฐ ๊ตฌ์กฐ ๋ณด์กด
- ๋ฐํ ํ์ : Stream<R> (R์ ๋ณํ๋ ํ์ )
์์ ์ฝ๋
// ๋ฌธ์์ด ๊ธธ์ด ๋ณํ
List<String> words = Arrays.asList("Java", "Stream", "API");
List<Integer> wordLengths = words.stream()
.map(String::length)
.collect(Collectors.toList());
// ๊ฒฐ๊ณผ: [4, 6, 3]
// ๊ฐ์ฒด ๋ณํ
List<User> users = getUserList();
List<String> userNames = users.stream()
.map(User::getName)
.collect(Collectors.toList());
2. flatMap()
<R> Stream<R> flatMap(
Function<? super T, // T : ์
๋ ฅ ํ์
(์๋ณธ ์คํธ๋ฆผ์ ์์ ํ์
)
? extends Stream<? extends R>> mapper // R : ์ถ๋ ฅ ํ์
(์๋ก์ด ์คํธ๋ฆผ์ ์์ ํ์
)
)
flatMap()์ ์ค์ฒฉ๋ ์คํธ๋ฆผ ๊ตฌ์กฐ๋ฅผ ๋จ์ผ ๋ ๋ฒจ๋ก ํ๋ฉดํํ๋ฉด์ ๋ณํํ๋ ์์ ์ ์ํํ๋ค. ๊ฐ ์์๋ฅผ ์คํธ๋ฆผ์ผ๋ก ๋ณํํ ํ, ํ๋์ ์คํธ๋ฆผ์ผ๋ก ๋ณํฉํ๋ค.
์ฃผ์ ํน์ง
- ์ค์ฒฉ ๊ตฌ์กฐ๋ฅผ ๋จ์ผ ๋ ๋ฒจ๋ก ํ๋ฉดํ
- ์์๋ฅผ 0๊ฐ ์ด์์ ์์๋ก ๋ณํ ๊ฐ๋ฅ (one-to-many)
- ์ปฌ๋ ์ ์ ๊ณ์ธต ๊ตฌ์กฐ ์ ๊ฑฐ
- ๋ฐํ ํ์ : Stream<R> (์ค์ฒฉ๋ ์คํธ๋ฆผ์ ๋จ์ผ ์คํธ๋ฆผ์ผ๋ก ๋ณํ)
- ๊ฐ ์์ฑ ๋ฐฉ๋ฒ
- 0๊ฐ ๊ฐ ๋ฐํ: Stream.empty()
- ์ฌ๋ฌ ๊ฐ ๋ฐํ: Stream.of(a, b, c)

Stream<List<Integer>> ํ์ ์ numbers.stream()์ flatMap์ ์ฌ์ฉํด Stream<Integer>๋ก ๋ณํ ํ ๋ฆฌ์คํธ๋ก ๋ฐํ.

flatMap์ ๊ฐ ์ ๋ ฅ๊ฐ์ ๋ฐ๋ผ ๋ค๋ฅธ ๊ฐ์๋ฅผ ๋ฐํํ๋ ์ ์ฐํ ์ฒ๋ฆฌ๋ ๊ฐ๋ฅํ๋ค.
class User {
private String name;
private List<String> emails;
// getters, setters...
}
List<String> allEmails = users.stream()
.flatMap(user -> user.getEmails().stream())
.collect(Collectors.toList());
์ ์ฝ๋์์๋ ๋ชจ๋ email ์ถ๋ ฅ์ ์ํด ๊ฐ User๋ณ email์ด ๊ฐ์์ ๋ฆฌ์คํธ๋ก ๊ตฌ๋ณ๋์ด email์ด ์ถ๋ ฅ๋์ง ์๊ณ ๋ชจ๋ email์ ํ๋์ ๋ฆฌ์คํธ๋ก ์ฒ๋ฆฌํ๊ธฐ ์ํด flatMap์ ์ฌ์ฉํ์๋ค.
3. ์ค์ ํ์ฉ ์ฌ๋ก
class Order {
private List<Product> products;
// getters, setters...
}
class Product {
private String name;
private double price;
// getters, setters...
}
// ๋ชจ๋ ์ฃผ๋ฌธ์ ์ด ๊ธ์ก ๊ณ์ฐ
double totalValue = orders.stream()
.flatMap(order -> order.getProducts().stream())
.mapToDouble(Product::getPrice)
.sum();
// ๋ชจ๋ ์ ํ ์ด๋ฆ ์ถ์ถ
List<String> productNames = orders.stream()
.flatMap(order -> order.getProducts().stream())
.map(Product::getName)
.distinct()
.collect(Collectors.toList());
์ด๋ ๊ฒ ๊ฐ ์ฃผ๋ฌธ์ด๋ ์ ํ ๋ณ์ด ์๋ ์ ์ฒด์ ์ธ ํต๊ณ๋ ํ๋ชฉ์ ์ถ์ถํ๊ณ ์ถ์ ๊ฒฝ์ฐ flatMap์ด ๊ฐ๋ ฅํ ๋๊ตฌ๊ฐ ๋๋ค.
'Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์ค๋ ๋์ ๊ธฐ๋ฅ๊ณผ ๋๋ฒ๊น (0) | 2025.02.06 |
---|---|
HashSet/HashMap์ ๋ด๋ถ ๊ตฌ์กฐ ๋ฐ ์ค๋ณต ์ ๊ฑฐ ๋ฉ์ปค๋์ฆ (0) | 2025.01.22 |
command line์ ํ์ฉํ JAR ํ์ผ ์์ฑํ๊ธฐ (0) | 2024.12.21 |
interface Map<K,V> - merge ๋ฉ์๋ (๋์ ๋ฐ ํ์ฉ) (0) | 2024.12.12 |
์๋ฐ์ ๋ฐฐ์ด ์ด๊ธฐํ ์ดํดํ๊ธฐ: ๊ธฐ๋ณธํ(Primitive Type)๊ณผ ์ฐธ์กฐํ(Reference Type)์ ์ฐจ์ด (0) | 2024.11.03 |