distinct() :์คํธ๋ฆผ์์ ์ค๋ณต๋ ์์๋ฅผ ์ ๊ฑฐํฉ๋๋ค. ์ด ๋ฉ์๋๋ ์คํธ๋ฆผ์ ์์์ ๋ํด equals() ๋ฉ์๋๊ฐ true๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ๋ฅผ ์ค๋ณต์ผ๋ก ๊ฐ์ฃผํ๊ณ ํ๋์ ์์๋ง ์ ์งํฉ๋๋ค.
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List<Integer> distinctNumbers = numbers.stream()
.distinct()
.collect(Collectors.toList());
// ๊ฒฐ๊ณผ: [1, 2, 3, 4, 5]
collect() :์คํธ๋ฆผ์ ์์๋ฅผ ์ปฌ๋ ์ ์ผ๋ก ์์งํฉ๋๋ค. Collectors ํด๋์ค์ ๋ค์ํ ์ ์ ํฉํ ๋ฆฌ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ปฌ๋ ์ ์ ์ข ๋ฅ๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค.
List<String> words = Arrays.asList("apple", "banana", "cherry");
List<String> collectedWords = words.stream()
.collect(Collectors.toList());
// ๊ฒฐ๊ณผ: ["apple", "banana", "cherry"]
compare() : ๋น๊ต ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก Comparator ์ธํฐํ์ด์ค์ compare ๋ฉ์๋์์ ์ฌ์ฉ๋๋ฉฐ, ๋ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ์ฌ ์ ๋ ฌ ์์๋ฅผ ๊ฒฐ์ ํฉ๋๋ค.
Comparator<String> byLength = (s1, s2) -> Integer.compare(s1.length(), s2.length());
List<String> words = Arrays.asList("apple", "banana", "cherry");
words.sort(byLength);
// ๊ฒฐ๊ณผ: ["apple", "cherry", "banana"]
isPresent() : Optional ํด๋์ค์ ๋ฉ์๋ ์ค ํ๋๋ก, Optional ๊ฐ์ฒด์ ๊ฐ์ด ์กด์ฌํ๋์ง ์ฌ๋ถ๋ฅผ ํ์ธํฉ๋๋ค. ๊ฐ์ด ์กด์ฌํ๋ฉด true๋ฅผ ๋ฐํํ๊ณ , ๊ฐ์ด ์์ผ๋ฉด false๋ฅผ ๋ฐํํฉ๋๋ค.
Optional<String> maybeValue = Optional.ofNullable(someValue);
if (maybeValue.isPresent()) {
// ๊ฐ์ด ์กด์ฌํ๋ ๊ฒฝ์ฐ ์ฒ๋ฆฌ
} else {
// ๊ฐ์ด ์๋ ๊ฒฝ์ฐ ์ฒ๋ฆฌ
}
orElse() :Optional ํด๋์ค์ ๋ฉ์๋ ์ค ํ๋๋ก, ๊ฐ์ด ์กด์ฌํ์ง ์์ ๋ ๊ธฐ๋ณธ๊ฐ์ ์ ๊ณตํฉ๋๋ค. ๊ฐ์ด ์กด์ฌํ๋ฉด ํด๋น ๊ฐ์ ๋ฐํํ๊ณ , ๊ฐ์ด ์์ผ๋ฉด ์ง์ ๋ ๊ธฐ๋ณธ๊ฐ์ ๋ฐํํฉ๋๋ค.
Optional<String> maybeValue = Optional.ofNullable(someValue);
String result = maybeValue.orElse("Default");
// ๋ง์ฝ ๊ฐ์ด ์กด์ฌํ์ง ์์ผ๋ฉด "Default" ๋ฐํ
๋ค ์ฒ์๋ณด๋ ๋ฉ์๋๋ก ํ๋ฒ ์ ๋ฆฌํด๋ณด์๋ค..๐ต๐ซ
Thread
์ฐ๋ ๋๋ ํ๋ก์ธ์ค๋ฅผ ๊ตฌ์ฑํ๋ ์ธ๋ถ ์คํ๋จ์(Unit)๋ฅผ ๋งํฉ๋๋ค.
์๋ฐ๋ JVM์ ํตํด ๋ฉํฐ ์ฐ๋ ๋๋ฅผ ๊ตฌ์ฑํ์ฌ concurrent ํ๊ฒ ๋์ํ์ฌ ๋์์ ์ฌ๋ฌ ์์ ์ ์ํํ ์ ์์ง๋ง ๋์์ ์ํ๋๋ ์ฐ๋ ๋์ ์ํ์์๋ ๋ณด์ฅ๋์ด ์์ง ์์ต๋๋ค.
โจ Main Thread
JVM์ main() ๋ฉ์๋๋ฅผ ์ฐพ์ Main Thread๋ฅผ ๋์์ํต๋๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก Main Thread๋ ์ฒ์์ ์ํ๋๋ ์ฐ๋ ๋์ด๊ณ , ๋ฉ์ธ ์ฐ๋ ๋๊ฐ ์ข ๋ฃ๋์ด๋ ๋ค๋ฅธ ๋ชจ๋ ์ฐ๋ ๋๊ฐ ์ข ๋ฃ๋์ด์ผ JVM์ ๋์์ด ๋ฉ์ถฅ๋๋ค.
์์ฑ์
Thread ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ Runnable ๊ฐ์ฒด, ์ฐ๋ ๋ ๋ช , ์ฐ๋ ๋ ๊ทธ๋ฃน ๋ฑ์ ๋ฐ์ ๊ฐ์ฒด๋ฅผ ์์ฑํฉ๋๋ค.
1) Thread ํด๋์ค๋ฅผ ์์
class MyThread extends Thread {
public void run() {
// ์ค๋ ๋์์ ์คํํ ์ฝ๋ ์์ฑ
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Value " + i);
}
}
}
public class Main {
public static void main(String args[]) {
MyThread t1 = new MyThread();
t1.start(); // ์ค๋ ๋ ์คํ
}
}
2) Runnable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํ
class MyRunnable implements Runnable {
public void run() {
// ์ค๋ ๋์์ ์คํํ ์ฝ๋ ์์ฑ
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Value " + i);
}
}
}
public class Main {
public static void main(String args[]) {
Thread t1 = new Thread(new MyRunnable());
t1.start(); // ์ค๋ ๋ ์คํ
}
}
์๋ฐ๊ฐ ๋จ์ผ ์์๋ง ํ์ฉํ๊ธฐ ๋๋ฌธ์, Runnable์ ๊ตฌํํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ผ๋ก ๋ ์ ํธ๋๋ค๊ณ ํ๋ค. (Runnable์ ๊ตฌํํ๋ฉด ๋ค๋ฅธ ํด๋์ค๋ฅผ ์์๋ฐ์ ์ ์๋ค)
๐๐ป์ค๋ ๋๋ฅผ ์์ฑํ ํ์๋ start() ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ์ค๋ ๋๋ฅผ ์คํ์์ผ์ผ ํฉ๋๋ค.
โ๏ธ run() ๋ฉ์๋๋ฅผ ์ง์ ํธ์ถํ๋ฉด ์๋ก์ด ์ค๋ ๋๊ฐ ์์ฑ๋์ง ์๊ณ ํ์ฌ ์ค๋ ๋์์ ์ผ๋ฐ์ ์ธ ๋ฉ์๋ ํธ์ถ๋ก ์ฒ๋ฆฌ๋ฉ๋๋ค.
Thread์ ์ํ
- NEW (์์ฑ๋จ):
- ์ค๋ ๋ ๊ฐ์ฒด๊ฐ ์์ฑ๋์์ง๋ง start() ๋ฉ์๋๊ฐ ํธ์ถ๋์ง ์์ ์ํ์ ๋๋ค. ์๋ก์ด ์ค๋ ๋๊ฐ ์์ง ์คํ๋์ง ์์ ๊ฒ์ ๋ํ๋ ๋๋ค.
- RUNNABLE (์คํ ๋๊ธฐ):
- ์ค๋ ๋๊ฐ ์คํ๋๊ธฐ ์ํด ๋๊ธฐ ์ค์ธ ์ํ์ ๋๋ค. start() ๋ฉ์๋๊ฐ ํธ์ถ๋๊ณ , ์ค์ผ์ค๋ฌ์ ์ํด ์คํ์ ๊ธฐ๋ค๋ฆฌ๊ณ ์๋ ์ํ์ ๋๋ค.
- BLOCKED (์ฐจ๋จ๋จ):
- ์ค๋ ๋๊ฐ ๋ค๋ฅธ ์ค๋ ๋์ ์ํด ๋๊ธฐํ ๋ธ๋ก์์ ์ฐจ๋จ๋ ์ํ์ ๋๋ค. ์๋ฅผ ๋ค์ด, ๋ค๋ฅธ ์ค๋ ๋๊ฐ ์ด๋ฏธ ๋ฝ์ ์์ ํ๊ณ ์์ด์ ํ์ฌ ์ค๋ ๋๊ฐ ํด๋น ๋ฝ์ ์ป์ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๋ ์ํ์ ๋๋ค.
- WAITING (๋๊ธฐ):
- ์ค๋ ๋๊ฐ ํน์ ์กฐ๊ฑด์ ๋ํด ๋ฌดํ์ ๊ธฐ๋ค๋ฆฌ๋ ์ํ์ ๋๋ค. Object.wait(), Thread.join(), LockSupport.park() ๋ฑ์ด ํธ์ถ๋ ๋ ๋ฐ์ํ ์ ์์ต๋๋ค.
- TIMED_WAITING (์ ํ๋ ๋๊ธฐ):
- Thread.sleep(), Object.wait(timeout), Thread.join(timeout), LockSupport.parkNanos() ๋ฑ๊ณผ ๊ฐ์ด ์ผ์ ์๊ฐ๋์ ๊ธฐ๋ค๋ฆฌ๋ ์ํ์ ๋๋ค.
- TERMINATED (์ข
๋ฃ๋จ):
- ์ค๋ ๋์ ์คํ์ด ์๋ฃ๋์ด ์ข ๋ฃ๋ ์ํ์ ๋๋ค. ์ค๋ ๋๊ฐ ์ข ๋ฃ๋๋ฉด ํด๋น ์ํ๋ก ์ ํ๋ฉ๋๋ค.