그래서 예외처리(try-catch)를 통해 프로그램이 안정적으로 실행되게 할 수 있습니다.
의도하지 않은 예외
public class Main {
public static void main(String[] args) {
System.out.println("프로그램 시작");
int result = 10 / 0; // ❌ 예외 발생 (ArithmeticException)
System.out.println("이 문장은 실행되지 않음");
}
}
Exception in thread "main" java.lang.ArithmeticException: / by zero
at chapter3.exception.Main.main(Main.java:8)
Process finished with exit code 1
의도적인 예외 - throw
public class Main {
public static void main(String[] args) {
int age = 10;
if (age < 18) {
// ✅ 의도적으로 예외를 발생시키는 부분
throw new IllegalArgumentException("미성년자는 접근할 수 없습니다!");
}
System.out.println("프로그램 종료");
}
}
📌 즉, Checked Exception은 예상 가능한 외부 오류(파일, 네트워크), Unchecked Exception은 논리적 버그! 🚀
🔹 Checked Exception 예제 (IOException)
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class CheckedExceptionExample {
public static void main(String[] args) {
try {
File file = new File("nonexistent.txt");
Scanner scanner = new Scanner(file); // ✅ 파일이 없으면 FileNotFoundException 발생
} catch (FileNotFoundException e) {
System.out.println("⚠️ 파일을 찾을 수 없습니다: " + e.getMessage());
}
}
}
📌 Checked Exception은 try-catch 없이 사용할 수 없음!
🔹 Unchecked Exception 예제 (NullPointerException)
public class UncheckedExceptionExample {
public static void main(String[] args) {
String str = null;
System.out.println(str.length()); // ❌ NullPointerException 발생
}
}
Exception in thread "main" java.lang.NullPointerException
📌 Unchecked Exception은 try-catch 없이도 실행되지만, 실행 중 오류가 발생할 수 있음!
throws를 사용하여 Checked Exception 처리
✔ Checked Exception은 try-catch 외에도 throws 키워드로 예외를 넘길 수 있음
✔ 즉, 예외 처리를 “이 메서드를 호출하는 쪽”에서 하도록 미룰 수 있음
🔹 throws를 사용한 예제
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class ThrowsExample {
public static void main(String[] args) throws FileNotFoundException {
File file = new File("nonexistent.txt");
Scanner scanner = new Scanner(file); // ✅ `throws` 덕분에 여기서 예외 처리를 강제하지 않음
}
}
✔ 하지만 main()에서 예외 처리를 안 하면 실행 중 오류 발생 가능
📌 즉, throws는 “예외를 넘기는 역할”을 하지만, 결국 어디선가 try-catch 해야 함!
Checked Exception을 Unchecked Exception으로 변환 가능
✔ Checked Exception이지만, RuntimeException으로 감싸서 Unchecked Exception처럼 만들 수도 있음!
🔹 Checked → Unchecked 변환 예제
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class ConvertToUnchecked {
public static void main(String[] args) {
try {
readFile();
} catch (RuntimeException e) {
System.out.println("⚠️ 처리되지 않은 예외 발생: " + e.getMessage());
}
}
public static void readFile() {
try {
File file = new File("nonexistent.txt");
Scanner scanner = new Scanner(file);
} catch (FileNotFoundException e) {
throw new RuntimeException(e); // ✅ Checked Exception을 Unchecked Exception으로 변환
}
}
}
✔ 즉, Checked Exception을 RuntimeException으로 감싸면 Unchecked Exception처럼 동작함! 🚀
✅ Checked Exception vs Unchecked Exception을 코드에서 어떻게 알 수 있을까? 🚀
// Unchecked Exception (개발자가 신경 써야 함)
public class NullPointerException extends RuntimeException { }
✔ RuntimeException을 상속 → Unchecked Exception (필수 처리 X, 런타임 오류 발생 가능)
📌 3. 코딩 중 필수 처리 여부를 확인하는 방법
✔ 실제 코드를 작성할 때 Checked Exception은 “컴파일 오류”가 발생하므로 바로 알 수 있음!
🔹 Checked Exception 예제 (컴파일 오류 발생!)
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class CheckedExceptionExample {
public static void main(String[] args) {
File file = new File("test.txt");
Scanner scanner = new Scanner(file); // ❌ 컴파일 오류 발생 (Unhandled exception: FileNotFoundException)
}
}
📌 즉, try-catch를 쓰지 않으면 컴파일 오류가 나서 “반드시 처리해야 하는 예외”라는 걸 바로 알 수 있음.
🔹 Unchecked Exception 예제 (컴파일 오류 없음)
public class UncheckedExceptionExample {
public static void main(String[] args) {
String str = null;
System.out.println(str.length()); // ❌ 실행 중 NullPointerException 발생
}
}
📌 Unchecked Exception은 컴파일 오류가 발생하지 않아서, 실행(Runtime) 중에 오류가 터질 수 있음!
📌 4. 결국 예외를 필수로 처리해야 하는지 직접 알아야 할까?
✔ ✅ YES → Checked Exception (try-catch 또는 throws 필수)
RuntimeException 을 상속받는 모든 예외를 UncheckedException 이라고 합니다.
try-catch 활용
public class ExceptionPractice {
public void callUncheckedException() {
if (true) {
System.out.println("언체크 예외 발생");
throw new RuntimeException(); // ✅ 예외발생
}
}
}
public class Main {
public static void main(String[] args) {
ExceptionPractice exceptionPractice = new ExceptionPractice();
// ✅ 상위로 전파된 예외처리
try {
exceptionPractice.callUncheckedException();
} catch (RuntimeException e) { // ✅ 예외처리
System.out.println("언체크 예외 처리");
} catch (Exception e) {
System.out.println("체크 예외 처리");
}
System.out.println("프로그램 종료");
}
}
Exception - CheckedException
Exception 클래스를 직접 상속받는 모든 예외를 CheckedException 이라고 합니다.
RuntimeException 을 상속받는 예외는 제외.
컴파일러가 예외 처리를 강제하는 예외입니다.
예외 처리를 하지 않으면 “컴파일 오류가 발생한다(코드에 빨간줄)” 라고 이해하시면 쉽습니다.
반드시 try-catch로 예외를 처리하거나 throws 키워드를 사용해야 합니다. → throws 로 예외 처리의 책임을 호출자에게 전가할 수 있습니다.
try-catch 활용
public class ExceptionPractice {
public void callCheckedException() {
// ✅ try-catch 로 예외 처리
try {
if (true) {
System.out.println("체크예외 발생");
throw new Exception();
}
} catch (Exception e) {
System.out.println("예외 처리");
}
}
}
public class Main {
public static void main(String[] args) {
// 예외 실습 객체 인스턴스화
ExceptionPractice exceptionPractice = new ExceptionPractice();
// ✅ 체크예외 호출
exceptionPractice.callCheckedException();
}
}
throws 활용
throws 키워드를 사용하여 예외를 호출한 곳에서 처리하도록 강제하는 방식입니다. → (책임 전가)
public class ExceptionPractice {
public void callCheckedException() throws Exception { // ✅ throws 예외를 상위로 전파
if (true) {
System.out.println("체크예외 발생");
throw new Exception();
}
}
}
package chapter3.exception;
public class Main {
public static void main(String[] args) {
// 예외 실습 객체 인스턴스화
ExceptionPractice exceptionPractice = new ExceptionPractice();
// 체크 예외 사용
// ✅ 반드시 상위 메서드에서 try-catch 를 활용해 주어야합니다.
try {
exceptionPractice.callCheckedException();
} catch (Exception e) {
System.out.println("예외처리");
}
}
}
Optional 이란?
Optional 객체는 null 을 안전하게 다루게 해주는 객체입니다.
null 이란?
null은 프로그래밍에서 값이 없음 또는 참조하지 않음 을 나타내는 키워드
null 을 직접 다루는 대신 Optional 을 사용하면 NullPoinerException 을 방지할 수 있습니다.
Optional 이 왜 필요한가?
✔ Optional<T>는 “null 가능성”이 있는 값을 감싸는 래퍼 클래스.
✔ 즉, null 반환을 방지하고, NullPointerException(NPE)을 예방하는 데 사용.
학생이 없는 경우 null을 반환하면 NPE(NullPointerException)가 발생합니다.
null인 객체에서 student.getName()을 호출하는 것은 존재하지 않는 객체의 메서드를 실행하려는 것입니다.
public class Student {
// 속성
private String name;
// 생성자
// 기능
public String getName() {
return this.name;
}
}
public class Camp {
// 속성
private Student student;
// 생성자
// 기능: ⚠️ null 을 반환할 수 있는 메서드
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
}
public class Main {
public static void main(String[] args) {
Camp camp = new Camp();
Student student = camp.getStudent(); // ⚠️ student 에는 null 이 담김
// ⚠️ 아래 코드에서 NPE 발생! 컴파일러가 잡아주지 않음
String studentName = student.getName(); // 🔥 NPE 발생 -> 프로그램 종료
System.out.println("studentName = " + studentName);
}
}
NULL 직접 처리의 한계
if문을 활용해서 null 처리를 할 수 있지만 모든 코드에서 null 이 발생할 가능성을 미리 예측하고 처리하는 것은 현실적으로 어렵습니다.
import java.util.Optional;
public class Camp {
// 속성
private Student student;
// 생성자
// 기능
// ✅ null 이 반환될 수 있음을 명확하게 표시
public Optional<Student> getStudent() {
return Optional.ofNullable(student); //null 가능성 대비
}
public void setStudent(Student student) {
this.student = student;
}
}
public class Main {
public static void main(String[] args) {
Camp camp = new Camp();
// isPresent() 활용시 true 를 반환하고 싶을때 활용
// Student newStudent = new Student();
// camp.setStudent(newStudent);
// Optional 객체 반환받음
Optional<Student> studentOptional = camp.getStudent();
// Optional 객체의 기능 활용
boolean flag = studentOptional.isPresent(); // false 반환
if (flag) {
// 존재할 경우
Student student = studentOptional.get(); // ✅ 안전하게 Student 객체 가져오기
String studentName = student.getName();
System.out.println("studentName = " + studentName);
} else {
// null 일 경우
System.out.println("학생이 없습니다.");
}
}
}
Optional 값 가져오기 (orElse, orElseGet, orElseThrow)
메서드
설명
get()
값이 없으면 NoSuchElementException 발생 (주의 필요)
orElse(defaultValue)
값이 있으면 반환, 없으면 defaultValue 반환
orElseGet(supplier)
값이 있으면 반환, 없으면 람다 실행 (defaultValue 대신 동적 처리 가능)
orElseThrow()
값이 없으면 NoSuchElementException 발생
orElseThrow(Supplier)
값이 없으면 커스텀 예외 발생
🔹 orElse와 orElseGet 차이
public class OptionalExample {
public static void main(String[] args) {
Optional<String> optionalValue = Optional.ofNullable(null);
// ✅ 기본값 반환
String value1 = optionalValue.orElse("기본값");
System.out.println(value1); // 기본값
// ✅ 동적 기본값 처리
String value2 = optionalValue.orElseGet(() -> "동적 기본값");
System.out.println(value2); // 동적 기본값
// ✅ 예외 발생
try {
String value3 = optionalValue.orElseThrow(() -> new RuntimeException("값이 없습니다!"));
} catch (RuntimeException e) {
System.out.println(e.getMessage()); // 값이 없습니다!
}
}
}
📌 즉, orElse()는 기본값을 직접 제공하고, orElseGet()은 람다로 동적 처리가 가능
하지만 이 부분은 이후 수업에서 다룰 예정이므로 지금은메서드를 매개변수로 전달한다정도로 이해하셔도 충분합니다
import java.util.Optional;
public class Camp {
// 속성
private Student student;
// 생성자
// 기능
// ✅ null 이 반환될 수 있음을 명확하게 표시
public Optional<Student> getStudent() {
return Optional.ofNullable(student);
}
}
import java.util.Optional;
public class Main {
public static void main(String[] args) {
Camp camp = new Camp();
// ✅ Optional 객체의 기능 활용 (orElseGet 사용)
Student student = camp.getStudent()
.orElseGet(() -> new Student("미등록 학생"));
System.out.println("studentName = " + student.getName());
}
}
Optional을 사용하면 모든 객체에 붙여야 할까?
❌ No! 모든 객체에 Optional을 사용할 필요는 없음.
✔ Optional은 “값이 없을 수도 있는 경우”에만 사용하는 게 좋음.
✔ “항상 값이 존재하는 필드”에는 Optional을 쓰면 오히려 불필요한 객체 할당이 늘어나 성능이 나빠질 수 있음
✅ 언제 Optional을 사용해야 할까?
1.null을 반환할 가능성이 있는 메서드 결과값
public Optional<String> getUsername(User user) {
return Optional.ofNullable(user.getName());
}
2.데이터베이스 조회 결과 (findById() 같은 경우)
Optional<User> user = userRepository.findById(1L);
public class UncheckedExceptionExample {
public static void main(String[] args) {
String str = null;
System.out.println(str.length()); // ❌ NullPointerException 발생
}
}
✔ 출력 (실행 중 오류 발생)
Exception in thread "main" java.lang.NullPointerException
✅ 3️⃣ Optional을 활용한 안전한 null 처리 (Optional<String>)
✔ 기존에는 null을 반환했지만, Optional을 사용하면 null 체크가 필요 없음!
import java.util.Optional;
public class OptionalExample {
public static void main(String[] args) {
Optional<String> name = getUserName(false); // ✅ null 대신 Optional 사용 → 안전하게 처리 가능
System.out.println(name.orElse("기본 이름")); // 값이 없으면 "기본 이름" 반환
}
public static Optional<String> getUserName(boolean exists) {
if (exists) {
return Optional.of("홍길동");
} else {
return Optional.empty(); // ✅ null 대신 빈 Optional 반환
}
}
}
✔ 출력 결과 (exists = false일 경우)
기본 이름
컬렉션(Collection)이란?
✔ 컬렉션(Collection)은 데이터를 효율적으로 저장하고 관리하는 자료 구조(데이터 컨테이너)
✔ 배열(Array)처럼 여러 개의 데이터를 저장할 수 있지만, 크기가 동적으로 변경되고 다양한 기능을 제공함.
✔ 자바의 Collection Framework를 사용하면, 데이터를 쉽고 효율적으로 추가/삭제/검색할 수 있음.
// List 를 구현한 ArrayList
ArrayList<String> names = new ArrayList<>();
names.add("Spartan"); // 1 번째 요소 추가
names.add("Steve"); // 2 번째 요소 추가
names.add("Isac"); // 3 번째 요소 추가
names.add("1");
names.add("2");
// ✅ 순서 보장
System.out.println("names = " + names);
// ✅ 중복 데이터 허용
names.add("Spartan");
System.out.println("names = " + names);
// ✅ 단건 조회
System.out.println("1 번째 요소 조회: " + names.get(0)); // 조회 Spartan
// ✅ 데이터 삭제
names.remove("Steve");
System.out.println("names = " + names);
import java.util.ArrayList;
public class NoGenericsExample {
public static void main(String[] args) {
ArrayList list = new ArrayList(); // ❌ 제너릭 미사용 → Object 타입으로 저장됨
list.add("Hello"); // 문자열 저장
list.add(123); // 정수 저장 (다른 타입 가능)
String str = (String) list.get(0); // ✅ 형 변환 필요
System.out.println(str);
// ❌ 형 변환 오류 (Integer → String)
String num = (String) list.get(1); // ClassCastException 발생
}
}
제너릭 사용
import java.util.ArrayList;
public class GenericsExample {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>(); // ✅ 제너릭 사용 → String 타입만 저장 가능
list.add("Hello"); // ✅ 정상
// list.add(123); // ❌ 컴파일 오류 발생! (Integer는 저장 불가능)
String str = list.get(0); // ✅ 형 변환 없이 안전하게 가져오기 가능
System.out.println(str);
}
}
제너릭 클래스
제네릭 클래스는 클래스 선언부에 <T> 가 선언된 클래스입니다.
제네릭 클래스는 클래스 선언 시 타입 매개변수를 사용해 다양한 데이터 타입을 안전하게 처리할 수 있는 구조입니다.
GenericBox<T> 를 활용해서 String, Integer, Double 등 다양한 타입 저장 가능 합니다.
// ✅ 제너릭 클래스 정의 (T는 타입 변수)
class Box<T> {
private T value;
public void set(T value) { this.value = value; }
public T get() { return value; }
}
public class GenericsClassExample {
public static void main(String[] args) {
Box<String> stringBox = new Box<>(); // ✅ String 타입 지정
stringBox.set("Hello");
System.out.println(stringBox.get()); // Hello
Box<Integer> intBox = new Box<>(); // ✅ Integer 타입 지정
intBox.set(123);
System.out.println(intBox.get()); // 123
}
}
별도의 클래스 파일을 만들지 않고 코드 내에서 일회성으로 정의해 사용하기 때문에 이름이 없다고 부릅니다.
인터페이스, 클래스(일반, 추상)의 구현과 상속을 활용해 익명 클래스를 구현할 수 있습니다.
→ 람다에서는 인터페이스를 사용한 익명 클래스가 활용됩니다.
람다
함수형 인터페이스를 통해서 구현하는 것을 권장합니다.
→하나의 추상 메서드만 가져야하기 때문입니다.
→ 하지만,하나의 추상 메서드를 가진 일반 인터페이스를 통해서도 사용 가능합니다.
람다식을 활용한 익명 클래스 변환 방법
컴파일 시점에 컴파일러가(a, b) -> a + b람다 표현식을 보고sum()메서드를 가진 익명 클래스를 구현합니다.
Calculator 인터페이스에 추상 메서드가 하나뿐이기 때문에 컴파일러는(a, b) -> a + b람다 표현식이sum()메서드라고 추론 가능하기 때문입니다.
// 람다 표현식
Calculator calculator1 = (a, b) -> a + b;
// 익명클래스
Calculator calculator1 = new Calculator() {
@Override
public int sum(int a, int b) {
return a + b;
}
};
@FunctionalInterface // ✅ 함수형 인터페이스 선언
public interface Calculator {
int sum(int a, int b); // ✅ 오직 하나의 추상 메서드만 선언해야합니다.
}
public class Main {
public static void main(String[] args) {
...
// ✅ 람다식 활용
Calculator calculator2 = (a, b) -> a + b;
int ret2 = calculator2.sum(2, 2);
System.out.println("ret2 = " + ret2);
}
}
람다 사용시 주의사항
람다식을 활용할때는 꼭 함수형 인터페이스를 활용합시다.
함수형 인터페이스는단 하나의 추상 메서드만 가지도록 강제하는 어노테이션입니다.
람다식에서는 함수형 인터페이스가 활용됩니다.
인터페이스에 두 개 이상의 추상 메서드가 존재하면 컴파일러가 어떤 메서드를 구현하는지 모호해지기 때문입니다.
예를 들어오버로딩(Overloading)기능을 통해 같은 이름의 sum() 메서드를 여러 형태로 정의한다면 람다 표현식이 어떤 메서드를 구현하는 것인지 명확하지 않아 모호성이 발생할 수 있습니다.
✅ 1️⃣ 익명 클래스로 작성한 코드
interface MyInterface {
void show();
}
public class AnonymousClassExample {
public static void main(String[] args) {
MyInterface obj = new MyInterface() {
@Override
public void show() {
System.out.println("익명 클래스 실행!");
}
};
obj.show();
}
}
✅ 2️⃣ 람다 표현식으로 변환 (()-> {} 사용)
interface MyInterface {
void show();
}
public class LambdaExample {
public static void main(String[] args) {
// ✅ 익명 클래스를 람다로 변환
MyInterface obj = () -> System.out.println("람다 실행!");
obj.show();
}
}
📌 함수형 인터페이스(@FunctionalInterface)와 람다
✔ 람다는 “함수형 인터페이스”에서만 사용 가능.
✔ “함수형 인터페이스”는 “메서드가 1개만 있는 인터페이스”를 의미.
✔ @FunctionalInterface를 붙여서 “람다에서 사용할 인터페이스”라고 표시
🔹 @FunctionalInterface 예제
@FunctionalInterface
interface Calculator {
int add(int a, int b);
}
public class LambdaExample {
public static void main(String[] args) {
// ✅ 람다 표현식으로 함수형 인터페이스 구현
Calculator calc = (a, b) -> a + b;
System.out.println(calc.add(5, 3)); // 8
}
}
오버로딩(Overloading) vs 오버라이딩(Overriding)
**오버로딩**은 같은 클래스나 인터페이스 내에서 동일한 메서드 이름을 사용해서 선언하는 기능입니다. → 매개변수의 개수나 타입, 순서는 다르게 선언해야 합니다.
**오버라이딩**은 부모 클래스에 정의된 메서드를 자식 클래스에서 재정의하는 것을 의미합니다.
public class Main {
public static int calculate(int a, int b, Calculator calculator) {
return calculator.sum(a, b);
}
public static void main(String[] args) {
Calculator cal1 = new Calculator() {
@Override
public int sum(int a, int b) {
return a + b;
}
};
// ✅ 익명 클래스를 변수에 담아 전달
int ret3 = calculate(3, 3, cal1);
System.out.println("ret3 = " + ret3); // 출력: ret3 = 6
}
}
람다식을 변수에 담아 전달
람다식을 변수에 담아 매개변수로 전달하는 방식입니다.
람다식을 전달하면 calculate() 메서드의 매개변수의 타입으로 Calculator 인터페이스를 구현했는지 추론되기 때문에 람다식을 전달 가능합니다.
public class Main {
public static int calculate(int a, int b, Calculator calculator) {
return calculator.sum(a, b);
}
public static void main(String[] args) {
Calculator cal2 = (a, b) -> a + b;
// ✅ 람다식을 변수에 담아 전달
int ret4 = calculate(4, 4, cal2);
System.out.println("ret4 = " + ret4); // 출력: ret4 = 8
}
}
람다식을 직접 전달
람다식을 직접 전달합니다.
마찬가지로 calculate() 메서드의 매개변수의 타입으로 Calculator 인터페이스를 구현했는지 추론됩니다.
public class Main {
public static int calculate(int a, int b, Calculator calculator) {
return calculator.sum(a, b);
}
public static void main(String[] args) {
// ✅ 람다식을 직접 매개변수로 전달
int ret5 = calculate(5, 5, (a, b) -> a + b);
System.out.println("ret5 = " + ret5); // 출력: ret5 = 10
}
}
스트림(stream) 이란?
✔ 스트림(Stream)은 “데이터 처리 기능”을 제공하는 자바의 기능.
✔ 배열이나 컬렉션(List, Set, Map)의 요소를 쉽게 “필터링, 변환, 정렬, 집계”할 수 있음.
✔ 반복문(for)을 사용하지 않고, 더 간결하고 효율적인 코드로 데이터를 다룰 수 있음.
✔ filter(), map(), sorted(), collect() 같은 “체이닝 방식”으로 가독성이 좋아짐.
stream(): 데이터 준비 - 데이터를 스트림으로 변환하여 연산 흐름을 만들 준비합니다.
map(): 중간 연산 등록 - 각 요소를 주어진 함수에 적용해서 변환합니다.
collect(): 최종 연산 - 결과를 원하는 형태(List, Set)로 수집합니다.
반복문 없이 간결하게 데이터 변환이 가능합니다.
package chapter2.stream;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> arrayList = new ArrayList<Integer>(List.of(1,2,3,4,5));
// for 명령형 스타일 : 각 요소 * 10 처리
List<Integer> ret1 = new ArrayList<>();
for(Integer num : arrayList){
Integer multipliedNum = num * 10;
ret1.add(multipliedNum);
}
System.out.println("ret1 = " + ret1);
// stream 선언형 스타일: 각 요소 * 10 처리
List<Integer> ret2 = arrayList.stream().map(num -> num *10).collect(Collectors.toList());
System.out.println("ret2 = " + ret2);
// steam > map > collect
// steam : 데이터를 스트림으로 변환해서 데이터 준비
// map : 중간 연산 등록 단계, 데이터를 어떻게 처리 할 것인지 명시
// collect : 최종 연산, 결과를 어떤 형태로 받을지 명시 해주는 것
// ArrayList를 List로 받는 이유
// 코드 수정을 최소화 하기 위해
// ArrayList는 List 중 한 종류다. 다른 타입으로 변경하기 위해
//스트림과 람다식을 활용
// 1. 익명 클래스를 만들어서 변수에 담아 매개변수로 전달
Function<Integer, Integer> function = new Function<Integer, Integer>(){
@Override
public Integer apply(Integer integer){
return integer * 10;
}
};
List<Integer> ret3 = arrayList.stream().map(function).collect(Collectors.toList());
System.out.println("ret3 = " + ret3);
// 2. 람다식을 만들어서 변수에 담아 매개변수로 전달
Function<Integer, Integer> functionLambda = (integer -> integer*10);
List<Integer> ret4 = arrayList.stream()
.map(functionLambda)
.collect(Collectors.toList());
System.out.println("ret4 = " + ret4);
// 3. 람다식을 직접 매개변수로 전달
List<Integer> ret5 = arrayList.stream()
.map(num -> num*10)
.collect(Collectors.toList());
System.out.println("ret5 = " + ret5);
// 4. 중간 연산 함께 사용 방법
// filter(), map()
// 리스트에서 짝수를 찾아서 * 10
List<Integer> ret6 = arrayList.stream()
.filter(num -> num % 2 == 0)
.map(num -> num * 10)
.collect(Collectors.toList());
System.out.println("ret6 = " + ret6);
}
}
