[JAVA] 문법정리 - 2

1. 예외처리
throw : 의도적인 예외
ex) throw new IllegalArgumentException("메세지");
RuntimeException : 체크되지않는 예외 - nullpoint
Exception : 체크되는 예외 - io
* 체크되는 기준은 컴파일러가 해주냐 아니냐의 차이
예외는 발생하면 처리될 때까지 전파된다
결국 main까지 전파되면 프로그램이 종료된다
try{
시도
}catch(Exception e){
예외발생
}finally{
성공하든 예외발생하든 실행
}
class MyClass throws Exception{}
이 클래스에서 발생한 예외는 상위클래스에서 처리한다고 명시하는 것

2. Optional - null (람다식 가능)
공식 문서 : https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html
Optional : 값이 있을 수도 있고 없을 수도 있는 객체
메서드
Optional op;
Optional.ofNullable(객체);
op.isPresent(); // 데이터가 null이면 false 아니면 true 
op.get(); // 데이터 반환

3. 람다식
익명클래스 : 별도의 클래스를 만들지 않고 일회성으로 사용하기위해 임의로 구현한 클래스
인터페이스를 활용한 익명클래스
Calculator calculator1 = new Calculator() {
        @Override
        public int sum(int a, int b) {
            return a + b;
        }
    };
calculator1.sum(1,2)
하지만 코드가 너무 길다

람다는 이런 코드를 최소화 해주는 기능을한다
* 함수형 인터페이스를 통해서 구현하는 것을 권장
위의 코드를 바꿔보면
Calculator calculator1 = (a, b) -> a+b;
이렇게 작성하면 컴파일러에서 직접 익명메서드를 만들어준다

함수형 인터페이스
@FunctionalInterface를 사용해야한다
그럼 그 인터페이스는 한개의 메서드밖에 만들지 못한다

@FunctionalInterface // ✅ 함수형 인터페이스 선언
public interface Calculator {

int sum(int a, int b); // ✅ 오직 하나의 추상 메서드만 선언해야합니다.
}

Calculator calculator2 = (a, b) -> a + b;
    int ret2 = calculator2.sum(2, 2);
    System.out.println("ret2 = " + ret2);


4. 스트림
- 데이터를 효율적으로 처리할 수 있는 흐름
- 과정 : 데이터 준비 -> 중간연산 -> 최종연산
- 보통 컬렉션과 같이 많이 사용한다
- map, filter를 주로 사용
ex) map 사용
List<Integer> nums = new ArrayList<>(List.of(1,2,3,4,5));
    List<Integer> nums2 = nums.stream().map(num -> num*10).collect(Collectors.toList());

a) 데이터 준비 : stream(), parallelStream()
b) 중간연산 등록 : map(), filter(), sorted()
c) 최종연산 : collect(), forEach(), count()

ex) filter사용(조건식)
List<Integer> nums = new ArrayList<>(List.of(1,2,3,4,5));
    List<Integer> nums2 = nums.stream().filter(num -> num % 2 == 0).map(num -> num*10).collect(Collectors.toList());

5. 쓰레드
- 프로그램에서 독립되어 실행되는 하나의 작업단위
싱글 쓰레드
- 처음 시작하는 main은 최초의 쓰레드이기에 싱글 쓰레드이다
Thread.currentThread().getName();를 사용해 현재 쓰레드의 이름을 가져올 수 있다
멀티 쓰레드
- Thread를 상속해서 클래스를 구현
- MyThread thread = new MyThread(); thread.start();로 실행
- thread.join(); trycatch를 통해 진행하기 해당 스레드가 끝날 때까지 대기
Thread.sleep(밀리초단위정수); 스레드가 시간만큼 쉬었다 진행

Runnable을 활용하면 실행 로직을 구현체로 분리할 수 있다

public class MyRunnable implements Runnable {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
for (int i = 0; i < 10; i++) {
System.out.println("현재 쓰레드: " + threadName + " - " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

MyRunnable task = new MyRunnable();
Thread thread = new Thread(task);
thread.start();

해당 과정을 진행할 수 있다