โถ ์คํธ๋ฆผ
โ
*์คํธ๋ฆผ์ด๋?
์ฌ๋ฌ ์๋ฃ์ ์ฒ๋ฆฌ์ ๋ํ ๊ธฐ๋ฅ์ ๊ตฌํํด ๋์ ํด๋์ค๊ฐ ์คํธ๋ฆผ(stream)์ด๋ค.
์คํธ๋ฆผ์ ํ์ฉํ๋ฉด ๋ฐฐ์ด, ์ปฌ๋ ์ ๋ฑ์ ์๋ฃ๋ฅผ ์ผ๊ด์ฑ ์๊ฒ ์ฒ๋ฆฌํ ์ ์๋ค. ์๋ฃ์ ๋ฐ๋ผ ๊ธฐ๋ฅ์ ๊ฐ๊ฐ ์๋ก ๊ตฌํํ๋ ๊ฒ์ด ์๋๋ผ ์ฒ๋ฆฌํด์ผ ํ๋ ์๋ฃ๊ฐ ๋ฌด์์ธ์ง์ ์๊ด์์ด ๊ฐ์ ๋ฐฉ์์ผ๋ก ๋ฉ์๋๋ฅผ ํธ์ถํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
โ
-๋ฐฐ์ด ์ถ๋ ฅ๋ฌธ
int[] arr = {1, 2, 3, 4, 5};
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
-์คํธ๋ฆผ ์ถ๋ ฅ๋ฌธ
int[] arr = {1, 2, 3, 4, 5};
Arrays.stream(arr).forEach(n -> System.out.println(n));
์คํธ๋ฆผ์ ์์ฑํ๊ณ ๋ฏธ๋ฆฌ ๊ตฌํ๋์ด ์๋ forEach( ) ๋ฉ์๋(์ต์ข ์ฐ์ฐ)๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ์์๋ฅผ ํ๋์ฉ ๊บผ๋ด์ด ์ถ๋ ฅํ ์ ์๋ค.
โ
โ
โ
*์คํธ๋ฆผ ์ฐ์ฐ
์คํธ๋ฆผ ์ฐ์ฐ์ ์ข ๋ฅ์๋ ํฌ๊ฒ ์ค๊ฐ ์ฐ์ฐ๊ณผ ์ต์ข ์ฐ์ฐ ๋ ๊ฐ์ง๊ฐ ์๋ค. ์ค๊ฐ ์ฐ์ฐ์ ์๋ฃ๋ฅผ ๊ฑฐ๋ฅด๊ฑฐ๋ ๋ณ๊ฒฝํ์ฌ ๋ ๋ค๋ฅธ ์๋ฃ๋ฅผ ๋ด๋ถ์ ์ผ๋ก ์์ฑํ๋ค. ์ต์ข ์ฐ์ฐ์ ์์ฑ๋ ๋ด๋ถ ์๋ฃ๋ฅผ ์๋ชจํด ๊ฐ๋ฉด์ ์ฐ์ฐ์ ์ํํ๋ค. ๋ฐ๋ผ์ ์ต์ข ์ฐ์ฐ์ ๋ง์ง๋ง์ ํ ๋ฒ๋ง ํธ์ถ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ต์ข ์ฐ์ฐ์ด ํธ์ถ๋์ด์ผ ์ค๊ฐ ์ฐ์ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋ง๋ค์ด์ง๋ค.
โ
โ
-์ค๊ฐ ์ฐ์ฐ - filter( ), map( )
filter( )๋ ์กฐ๊ฑด์ ๋ฃ๊ณ ๊ทธ ์กฐ๊ฑด์ ๋ง๋ ์ฐธ์ธ ๊ฒฝ์ฐ๋ง ์ถ์ถํ๋ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ค.
map( )์ ํด๋์ค๊ฐ ๊ฐ์ง ์๋ฃ ์ค ์ด๋ฆ๋ง ์ถ๋ ฅํ๋ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ค. map( )์ ์์๋ค์ ์ํํ์ฌ ๋ค๋ฅธ ํ์์ผ๋ก ๋ณํํ๊ธฐ๋ ํ๋ค.
filter( )์ map( ) ๋ ๋ค ํจ์๋ฅผ ์ํํ๋ฉด์ ํด๋น ์กฐ๊ฑด์ด๋ ํจ์์ ๋ง๋ ๊ฒฐ๊ณผ๋ฅผ ์ถ์ถํด ๋ด๋ ์ค๊ฐ ์ญํ ์ ํ๋ค.
โ
-์ต์ข ์ฐ์ฐ - forEach( ), count( ), sum( ), reduce( )
์ต์ข ์ฐ์ฐ์ ์คํธ๋ฆผ์ ์๋ฃ๋ฅผ ์๋ชจํ๋ฉด์ ์ฐ์ฐ์ ์ํํ๊ธฐ ๋๋ฌธ์ ์ต์ข ์ฐ์ฐ์ด ์ํ๋๊ณ ๋๋ฉด ํด๋น ์คํธ๋ฆผ์ ๋ ์ด์ ์ฌ์ฉํ ์ ์๋ค. ์ต์ข ์ฐ์ฐ์ ๊ฒฐ๊ณผ๋ฅผ ๋ง๋๋๋ฐ ์ฃผ๋ก ์ฌ์ฉํ๋ค.
forEach( )๋ ์์๋ฅผ ํ๋์ฉ ๊บผ๋ด๋ ๊ธฐ๋ฅ์ ํ๋ค.
ํต๊ณ์ฉ์ผ๋ก ์ฌ์ฉ๋๋ sum( ), count( )๋ ๋ฐฐ์ด ์์์ ํฉ๊ณ๋ฅผ ๊ตฌํ๋ค๋ ๊ฐ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ ๋ฑ์ ์ฐ์ฐ์ ์ํํ๋ค.
โ
โ
โ
*์ ์ ๋ฐฐ์ด์ ์คํธ๋ฆผ ์์ฑํ๊ณ ์ฌ์ฉํ๊ธฐ
โโ
IntArrayTest.java
package stream;
import java.util.Arrays;
public class IntArrayTest {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
int sumVal = Arrays.stream(arr).sum(); // sum() ์ฐ์ฐ์ผ๋ก arr ๋ฐฐ์ด์ ์ ์ฅ๋ ๊ฐ์ ๋ชจ๋ ๋ํจ
int count = (int) Arrays.stream(arr).count(); // count() ์ฐ์ฐ์ผ๋ก arr ๋ฐฐ์ด์ ์์ ๊ฐ์๋ฅผ ๋ฐํํจ
System.out.println(sumVal);
System.out.println(count);
}
}
โ<์คํ ๊ฒฐ๊ณผ>
โ
โ
โ
*Collection์์ ์คํธ๋ฆผ ์์ฑํ๊ณ ์ฌ์ฉํ๊ธฐ
โ
ArrayListStreamTest.java
package stream;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
public class ArrayListStreamTest {
public static void main(String[] args) {
List<String> sList = new ArrayList<String>();
sList.add("Tomas");
sList.add("Edward");
sList.add("Jack");
Stream<String> stream = sList.stream(); // ์คํธ๋ฆผ ์์ฑ
stream.forEach(s -> System.out.print(s + " ")); // ๋ฐฐ์ด์ ์์๋ฅผ ํ๋์ฉ ์ถ๋ ฅ
System.out.println();
sList.stream().sorted().forEach(s -> System.out.print(s + " ")); // ์คํธ๋ฆผ ์๋ก ์์ฑ / ์ ๋ ฌ / ์์๋ฅผ ํ๋์ฉ ๊บผ๋ด์ด ์ถ๋ ฅ
}
}
<์คํ ๊ฒฐ๊ณผ>
-18์ค์ forEach( ) ๊ดํธ ์์ ๊ตฌํ๋๋ ๋๋ค์์ ์๋ฏธ
: forEach( ) ๋ฉ์๋๊ฐ ์ํ๋๋ฉด ์์๊ฐ ํ๋์ฉ ์ฐจ๋ก๋ก ๋ณ์ s์ ๋์ ๋๊ณ ์ด๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ์ถ๋ ฅ๋ฌธ์ด ํธ์ถ๋๋ค.
-forEach( ) ๋ฉ์๋๊ฐ ์ํ๋๋ฉด ์๋ฃ๊ฐ ์๋ชจ๋๊ธฐ๋๋ฌธ์ ์คํธ๋ฆผ์ ์๋ก ์์ฑํด์ผํ๋ค.
-18์ค์์๋ ์ค๊ฐ ์ฐ์ฐ์ผ๋ก ์ ๋ ฌ์ ์ํ sorted( ) ๋ฉ์๋๊ฐ ํธ์ถ๋์๋ค. sorted( ) ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด
โ
โ
โ
*์คํธ๋ฆผ์ ํน์ง
โ
1. ์๋ฃ์ ๋์๊ณผ ๊ด๊ณ์์ด ๋์ผํ ์ฐ์ฐ์ ์ํํ๋ค.
์คํธ๋ฆผ์ ์ปฌ๋ ์ ์ ์ฌ๋ฌ ์๋ฃ ๊ตฌ์กฐ์ ๋ํด ์ด๋ฌํ ์์ ์ ์ผ๊ด์ฑ ์๊ฒ ์ฒ๋ฆฌํ ์ ์๋ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค.
โ
2. ํ ๋ฒ ์์ฑํ๊ณ ์ฌ์ฉํ ์คํธ๋ฆผ์ ์ฌ์ฌ์ฉ ํ ์ ์๋ค.
์ด๋ค ์๋ฃ์ ๋ํ ์คํธ๋ฆผ์ ์์ฑํ๊ณ ์ด ์คํธ๋ฆผ์ ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ์ฐ์ฐ์ ์ํํ๋ค๋ฉด ํด๋น ์คํธ๋ฆผ์ ๋ค์ ๋ค๋ฅธ ์ฐ์ฐ์ ์ฌ์ฉํ ์ ์๋ค. ์๋ฅผ ๋ค์ด ์คํธ๋ฆผ์ ์์ฑํ์ฌ ๋ฐฐ์ด์ ์๋ ์์๋ฅผ ์ถ๋ ฅํ๊ธฐ ์ํด ๊ฐ ์์๋ค์ ํ๋์ฉ ์ํํ๋ฉด์ ์ถ๋ ฅ์ ์ฌ์ฉํ๋๋ฐ, ์ด๋ ์์๋ค์ด '์๋ชจ๋๋ค'๊ณ ์ด์ผ๊ธฐํ๋ค. ๋ง์ฝ ๋ค๋ฅธ ๊ธฐ๋ฅ์ ํธ์ถํ๋ ค๋ฉด ์คํธ๋ฆผ์ ์๋ก ์์ฑํด์ผ ํ๋ค.
โ
3. ์คํธ๋ฆผ์ ์ฐ์ฐ์ ๊ธฐ์กด ์๋ฃ๋ฅผ ๋ณ๊ฒฝํ์ง ์๋๋ค.
์คํธ๋ฆผ ์ฐ์ฐ์ ์ํด ์ฌ์ฉํ๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋ณ๋๋ก ์กด์ฌํ๋ฏ๋ก, ์คํธ๋ฆผ์ ์ฌ๋ฌ ๋ฉ์๋๋ฅผ ํธ์ถํ๋๋ผ๋ ๊ธฐ์กด ์๋ฃ์๋ ์ํฅ์ ๋ฏธ์น์ง ์๋๋ค.
โ
4. ์คํธ๋ฆผ์ ์ฐ์ฐ์ ์ค๊ฐ ์ฐ์ฐ๊ณผ ์ต์ข ์ฐ์ฐ์ด ์๋ค.
์คํธ๋ฆผ์ ์ค๊ฐ ์ฐ์ฐ์ ์ฌ๋ฌ ๊ฐ๊ฐ ์ ์ฉ๋ ์ ์๊ณ , ์ต์ข ์ฐ์ฐ์ ๋งจ ๋ง์ง๋ง์ ํ ๋ฒ ์ ์ฉ๋๋ค. ๋ง์ฝ ์ค๊ฐ ์ฐ์ฐ์ด ์ฌ๋ฌ ๊ฐ ํธ์ถ๋์๋๋ผ๋ ์ต์ข ์ฐ์ฐ์ด ํธ์ถ๋์ด์ผ ์คํธ๋ฆผ์ ์ค๊ฐ ์ฐ์ฐ์ด ๋ชจ๋ ์ ์ฉ๋๋ค.
์๋ฅผ ๋ค์ด ์๋ฃ๋ฅผ ์ ๋ ฌํ๊ฑฐ๋ ๊ฒ์ํ๋ ์ค๊ฐ ์ฐ์ฐ์ด ํธ์ถ๋์ด๋ ์ต์ข ์ฐ์ฐ์ด ํธ์ถ๋์ง ์์ผ๋ฉด ์ ๋ ฌ์ด๋ ๊ฒ์ํ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์ฌ ์ ์๋ค. ์ด๋ฅผ '์ง์ฐ ์ฐ์ฐ'์ด๋ผ๊ณ ํ๋ค.
โ
โ
โ
*ํ๋ก๊ทธ๋๋จธ๊ฐ ๊ธฐ๋ฅ์ ์ง์ ํ๋ reduce( ) ์ฐ์ฐ
reduce( ) ์ฐ์ฐ์ ๋ด๋ถ์ ์ผ๋ก ์คํธ๋ฆผ์ ์์๋ฅผ ํ๋์ฉ ์๋ชจํ๋ฉด์ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ง์ ์ง์ ํ ๊ธฐ๋ฅ์ ์ํํ๋ค.
โ
ReduceTest.java
package stream;
import java.util.Arrays;
import java.util.function.BinaryOperator;
// BinaryOperator๋ฅผ ๊ตฌํํ ํด๋์ค ์ ์
class CompareString implements BinaryOperator<String> {
@Override
public String apply(String s1, String s2) { // reduce() ๋ฉ์๋๊ฐ ํธ์ถ๋ ๋ ๋ถ๋ฆฌ๋ ๋ฉ์๋. ๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๋น๊ต
if (s1.getBytes().length >= s2.getBytes().length)
return s1;
else
return s2;
}
}
public class ReduceTest {
public static void main(String[] args) {
String[] greetings = { "์๋
ํ์ธ์~~~", "hello", "Good morning", "๋ฐ๊ฐ์ต๋๋ค^^" };
System.out.println(Arrays.stream(greetings).reduce("", (s1, s2) -> { // ๋๋ค์์ ์ง์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ
if (s1.getBytes().length >= s2.getBytes().length)
return s1;
else
return s2;
}));
String str = Arrays.stream(greetings).reduce(new CompareString()).get(); // BinaryOperator๋ฅผ ๊ตฌํํ ํด๋์ค ์ฌ์ฉ
System.out.println(str);
}
}
<์คํ ๊ฒฐ๊ณผ>
-์ดํด๊ฐ ์ ์๊ฐ. ๋ด์ฉ๋ ์์ง ๋์ฑ์. ๋์ค์ ๋ค์ ๊ณต๋ถํ์.
โ
โ
โ
*์คํธ๋ฆผ์ ํ์ฉํ์ฌ ์ฌํ๊ฐ์ ์ฌํ ๋น์ฉ ๊ณ์ฐํ๊ธฐ
โ
TravelCustomer.java
package stream;
public class TravelCustomer {
private String name; // ๊ณ ๊ฐ์ด๋ฆ
private int age; // ๋์ด
private int price; // ๊ฐ๊ฒฉ
public TravelCustomer(String name, int age, int price) {
this.name = name;
this.age = age;
this.price = price;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int getPrice() {
return price;
}
public String toString() {
return "name : " + name + "age : " + age + "price : " + price;
}
}
TravelTest.java
package stream;
import java.util.ArrayList;
import java.util.List;
public class TravelTest {
public static void main(String[] args) {
TravelCustomer customerLee = new TravelCustomer("์ด์์ ", 40, 100);
TravelCustomer customerKim = new TravelCustomer("๊น์ ์ ", 20, 100);
TravelCustomer customerHong = new TravelCustomer("ํ๊ธธ๋", 13, 50);
List<TravelCustomer> customerList = new ArrayList<>();
customerList.add(customerLee);
customerList.add(customerKim);
customerList.add(customerHong);
System.out.println("== ๊ณ ๊ฐ ๋ช
๋จ ์ถ๊ฐ๋ ์์๋๋ก ์ถ๋ ฅ ==");
customerList.stream().map(c -> c.getName()).forEach(s -> System.out.println(s));
int total = customerList.stream().mapToInt(c -> c.getPrice()).sum();
System.out.println("์ด ์ฌํ ๋น์ฉ์ : " + total + "์
๋๋ค.");
System.out.println("== 20์ธ ์ด์ ๊ณ ๊ฐ ๋ช
๋จ ์ ๋ ฌํ์ฌ ์ถ๋ ฅ ==");
customerList.stream().filter(c -> c.getAge() >= 20).map(c -> c.getName()).sorted()
.forEach(s -> System.out.println(s));
}
}
<์คํ ๊ฒฐ๊ณผ>
์ด์ฒ๋ผ ์คํธ๋ฆผ์ ๋ง์ ๋ฐ์ดํฐ ์์์ ์ฐ๋ฆฌ๊ฐ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ถ์ถํ๊ณ ์ ์ฉํ๊ณ ๊ณ์ฐํ๊ณ ์ถ๋ ฅํ๋ ๋ฑ์ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค.
โ
โ
โ
โ์ฐ์ต๋ฌธ์ Q5) ๋ค์๊ณผ ๊ฐ์ด ๋ ์ ์๋ฅผ ๋งค๊ฐ๋ณ์๋ก ํ๋ ๋ฉ์๋๊ฐ ์ธํฐํ์ด์ค์ ์ ์๋์ด ์๋ค. ๋ ์ ์์ ํฉ์ ๋ฐํํ๋ ๋๋ค์์ ๊ตฌํํ๊ณ ํธ์ถํด ๋ณด๋ผ.
โ
๋ฐ์ Calc ์ธํฐํ์ด์ค๋ฅผ ํ ๋๋ก ์์ฑํ๊ธฐ.
package test;
public interface Calc {
public int add(int num1, int num2);
}
CalcTest.java
package test;
public class CalcTest {
public static void main(String[] args) {
Calc add = (x, y) -> x + y;
System.out.println(add.add(10, 20));
}
}
โ<์คํ ๊ฒฐ๊ณผ>
โ
'Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java-๊ธฐ์ด] ์ปดํ์ผ๋ฌ์ ์ํด ์์ธ๊ฐ ์ฒดํฌ๋๋ ๊ฒฝ์ฐ (0) | 2021.02.22 |
---|---|
[Java-๊ธฐ์ด] ์์ธ ํด๋์ค (0) | 2021.02.22 |
[Java-๊ธฐ์ด] ๋๋ค์ (0) | 2021.02.22 |
[Java-๊ธฐ์ด] ๋ด๋ถ ํด๋์ค (0) | 2021.02.22 |
[Java-๊ธฐ์ด] Map ์ธํฐํ์ด์ค (0) | 2021.02.22 |
๋๊ธ