신비한 비

1. 인터페이스의 기본 메서드 재정의:

interface MyInterface {
    default void myMethod() {
        System.out.println("Default method");
    }
}

// 람다 표현식을 사용하여 기본 메서드를 재정의
MyInterface obj = () -> System.out.println("Overridden method");
obj.myMethod(); // "Overridden method" 출력

2. 제네릭 메서드 사용:

interface MyInterface<T> {
    void myMethod(T value);
}

// 람다 표현식을 사용하여 제네릭 메서드 구현
MyInterface<String> obj = (value) -> System.out.println(value);
obj.myMethod("Hello"); // "Hello" 출력

3. 메서드 참조 활용:

interface MyInterface {
    void myMethod();
}

// 메서드 참조를 사용하여 람다 표현식 대신 메서드를 전달
void myMethodImplementation() {
    System.out.println("Method reference");
}

MyInterface obj = this::myMethodImplementation;
obj.myMethod(); // "Method reference" 출력

4. 변수 캡처:

interface MyInterface {
    void myMethod();
}

// 람다 표현식에서 외부 변수 사용
int num = 10;
MyInterface obj = () -> System.out.println(num);
obj.myMethod(); // 10 출력

5. 조건부 실행:

interface MyInterface {
    void myMethod();
}

// 람다 표현식과 조건문을 결합하여 조건부 실행
boolean condition = true;
MyInterface obj = () -> {
    if (condition) {
        System.out.println("Condition is true");
    } else {
        System.out.println("Condition is false");
    }
};
obj.myMethod(); // "Condition is true" 출력

6. 예외 처리:

interface MyInterface {
    void myMethod() throws Exception;
}

// 람다 표현식에서 예외 처리
MyInterface obj = () -> {
    try {
        throw new Exception("Exception");
    } catch (Exception e) {
        System.out.println("Caught exception: " + e.getMessage());
    }
};
obj.myMethod(); // "Caught exception: Exception" 출력

7. 병렬 처리:

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

// 병렬 처리를 위한 람다 표현식 사용
numbers.parallelStream().forEach(System.out::println);

8. 커스텀 컬렉션 연산:

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

// 커스텀 컬렉션 연산을 위한 람다 표현식 사용
int sum = numbers.stream()
                .filter(n -> n % 2 == 0)
                .mapToInt(n -> n * 2)
                .sum();
System.out.println(sum); // 12 출력

9. Optional 값 처리:

Optional<String> optionalValue = Optional.of("Hello");

// Optional 값에 대한 람다 표현식 사용
optionalValue.ifPresent(value -> System.out.println("Value: " + value));

10. 람다 표현식의 명시적 형변환:

Object lambdaExpression = (Runnable) () -> System.out.println("Lambda expression");

// 명시적 형변환을 통해 람다 표현식 실행
((Runnable) lambdaExpression).run(); // "Lambda expression" 출력

내저장소 바로가기 luxury515

1. 컬렉션 정렬하기 Lambda를 사용하여 컬렉션을 정렬하는 것은 간단하고 효율적입니다. Comparator 인터페이스를 구현하고 람다 표현식으로 전달하여 정렬 기준을 지정할 수 있습니다.

List<String> names = Arrays.asList("John", "Alice", "Bob", "Mary");
names.sort((name1, name2) -> name1.compareTo(name2));

2. 필터링 Predicate 인터페이스를 사용하여 컬렉션의 요소를 필터링할 수 있습니다. 람다 표현식을 전달하여 원하는 조건을 지정할 수 있습니다.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                   .filter(number -> number % 2 == 0)
                                   .collect(Collectors.toList());

3. 맵핑 Function 인터페이스를 사용하여 컬렉션의 요소를 변환할 수 있습니다. 람다 표현식을 전달하여 변환 로직을 작성할 수 있습니다.

List<String> names = Arrays.asList("John", "Alice", "Bob", "Mary");
List<Integer> nameLengths = names.stream()
                                 .map(name -> name.length())
                                 .collect(Collectors.toList());

4. 리소스 관리 AutoCloseable 인터페이스를 구현한 리소스를 사용할 때, try-with-resources 문과 함께 람다 표현식을 사용하여 리소스를 자동으로 닫을 수 있습니다.

try (InputStream in = new FileInputStream("input.txt")) {
    // 파일 읽기 작업 수행
} catch (IOException e) {
    // 예외 처리
}

5. 스레드 생성 Runnable 인터페이스를 구현한 람다 표현식을 사용하여 새로운 스레드를 생성할 수 있습니다.

Thread thread = new Thread(() -> {
    // 스레드에서 실행할 작업
});
thread.start();

6. 예외 처리 함수형 인터페이스의 추상 메서드에서 예외가 발생할 수 있는 경우, 람다 표현식에서 예외를 처리할 수 있습니다.

Function<Integer, Integer> divideByZero = x -> {
    try {
        return x / 0;
    } catch (ArithmeticException e) {
        return 0;
    }
};

7. 조건부 실행 람다 표현식을 사용하여 조건에 따라 코드 블록을 실행할 수 있습니다.

Consumer<String> printIfNotEmpty = text -> {
    if (!text.isEmpty()) {
        System.out.println(text);
    }
};

8. 함수 조합 Function 인터페이스를 사용하여 함수를 조합할 수 있습니다. andThen() 메서드와 compose() 메서드를 사용하여 람다 표현식을 조합할 수 있습니다.

Function<Integer, Integer> addTwo = x -> x + 2;
Function<Integer, Integer> multiplyByThree = x -> x * 3;

Function<Integer, Integer> addTwoAndMultiplyByThree = addTwo.andThen(multiplyByThree);
int result = addTwoAndMultiplyByThree.apply(5); // 결과: 21

9. 값 반환 람다 표현식을 사용하여 값을 반환할 수 있습니다. 함수형 인터페이스의 메서드에 맞게 람다 표현식을 작성하고 값을 반환할 수 있습니다.

Supplier<String> helloSupplier = () -> "Hello, World!";
String message = helloSupplier.get(); // 결과: "Hello, World!"

10. 비동기 처리 CompletableFuture를 사용하여 비동기 작업을 처리할 수 있습니다. 람다 표현식을 사용하여 작업을 정의하고 CompletableFuture의 메서드를 호출하여 비동기적으로 작업을 실행할 수 있습니다.

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello, World!");
future.thenAccept(message -> System.out.println(message)); // 결과: "Hello, World!"

내저장소 바로가기 luxury515

1. 숫자 두 개를 더하는 Lambda 함수:

interface Adder {
    int add(int x, int y);
}

public class Main {
    public static void main(String[] args) {
        Adder add = (x, y) -> x + y;
        System.out.println(add.add(5, 3)); // 출력: 8
    }
}

2. 문자열을 대문자로 변환하는 Lambda 함수:

interface StringConverter {
    String convert(String s);
}

public class Main {
    public static void main(String[] args) {
        StringConverter converter = s -> s.toUpperCase();
        System.out.println(converter.convert("hello")); // 출력: "HELLO"
    }
}

3. 배열의 모든 요소를 출력하는 Lambda 함수:

interface ArrayPrinter {
    void printArray(int[] arr);
}

public class Main {
    public static void main(String[] args) {
        ArrayPrinter printer = arr -> {
            for (int num : arr) {
                System.out.println(num);
            }
        };
        
        int[] numbers = {1, 2, 3, 4, 5};
        printer.printArray(numbers);
    }
}

4. 주어진 숫자가 짝수인지 확인하는 Lambda 함수:

interface EvenChecker {
    boolean isEven(int number);
}

public class Main {
    public static void main(String[] args) {
        EvenChecker checker = number -> number % 2 == 0;
        System.out.println(checker.isEven(4)); // 출력: true
    }
}

5. 두 문자열을 결합하는 Lambda 함수:

interface StringCombiner {
    String combine(String s1, String s2);
}

public class Main {
    public static void main(String[] args) {
        StringCombiner combiner = (s1, s2) -> s1 + s2;
        System.out.println(combiner.combine("Hello", " World!")); // 출력: "Hello World!"
    }
}

6. 문자열의 길이를 반환하는 Lambda 함수:

interface StringLengthCalculator {
    int calculateLength(String s);
}

public class Main {
    public static void main(String[] args) {
        StringLengthCalculator calculator = s -> s.length();
        System.out.println(calculator.calculateLength("Lambda")); // 출력: 6
    }
}

7. 숫자의 제곱을 계산하는 Lambda 함수:

interface Squarer {
    int square(int number);
}

public class Main {
    public static void main(String[] args) {
        Squarer squarer = number -> number * number;
        System.out.println(squarer.square(5)); // 출력: 25
    }
}

8. 문자열이 비어 있는지 확인하는 Lambda 함수:

interface EmptyChecker {
    boolean isEmpty(String s);
}

public class Main {
    public static void main(String[] args) {
        EmptyChecker checker = s -> s.isEmpty();
        System.out.println(checker.isEmpty("")); // 출력: true
    }
}

9. 주어진 숫자 배열의 합을 계산하는 Lambda 함수:

import java.util.Arrays;

interface ArraySumCalculator {
    int calculateSum(int[] arr);
}

public class Main {
    public static void main(String[] args) {
        ArraySumCalculator sumCalculator = arr -> Arrays.stream(arr).sum();
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println(sumCalculator.calculateSum(numbers)); // 출력: 15
    }
}

10. 주어진 문자열 배열의 길이가 5 이상인 문자열을 필터링하는 Lambda 함수:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

interface StringFilter {
    List<String> filter(List<String> strings);
}

public class Main {
    public static void main(String[] args) {
        StringFilter filter = strings -> strings.stream()
                .filter(s -> s.length() >= 5)
                .collect(Collectors.toList());
                
        List<String> words = Arrays.asList("apple", "banana", "car", "dragon", "elephant");
        System.out.println(filter.filter(words)); // 출력: ["apple", "banana", "dragon", "elephant"]
    }
}

내저장소 바로가기 luxury515

1. 컬렉션 순회에 람다 식 사용

일반 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
for (String fruit : list) {
    System.out.println(fruit);
}

람다식 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
list.forEach(fruit -> System.out.println(fruit));

2. 람다식을 이용한 정렬

일반 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
Collections.sort(list, new Comparator<String>() {
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});

람다식 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
Collections.sort(list, (s1, s2) -> s1.compareTo(s2));

3. 람다식을 사용한 필터링

일반 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = new ArrayList<String>();
for (String fruit : list) {
    if (fruit.startsWith("a")) {
        filteredList.add(fruit);
    }
}

람다식 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream().filter(fruit -> fruit.startsWith("a")).collect(Collectors.toList());

4. 람다 식으로 매핑

일반 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
List<Integer> lengths = new ArrayList<Integer>();
for (String fruit : list) {
    lengths.add(fruit.length());
}

람다식 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
List<Integer> lengths = list.stream().map(fruit -> fruit.length())
.collect(Collectors.toList());

5. 람다식을 이용한 축소

일반 표현식

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
for (int i : list) {
    sum += i;
}

람다식 표현식

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().reduce(0, (a, b) -> a + b);

6. 람다 식으로 그룹화

일반 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
Map<Integer, List<String>> grouped = new HashMap<Integer, List<String>>();
for (String fruit : list) {
    int length = fruit.length();
    if (!grouped.containsKey(length)) {
        grouped.put(length, new ArrayList<String>());
    }
    grouped.get(length).add(fruit);
}

람다식 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
Map<Integer, List<String>> grouped = list.stream().collect(Collectors.groupingBy(fruit -> fruit.length()));

7. Lambda 표현식을 사용하여 기능적 인터페이스 구현

일반 표현식

public interface MyInterface {
    public void doSomething(String input);
}

MyInterface myObject = new MyInterface() {
    public void doSomething(String input) {
        System.out.println(input);
    }
};
myObject.doSomething("Hello World");

람다식 표현식

MyInterface myObject = input -> System.out.println(input);
myObject.doSomething("Hello World");

8. 람다 식을 사용하여 스레드 생성

일반 표현식

Thread thread = new Thread(new Runnable() {
    public void run() {
        System.out.println("Thread is running.");
    }
});
thread.start();

람다식 표현식

Thread thread = new Thread(() -> System.out.println("Thread is running."));
thread.start();

9. 선택적 작업에 람다 식 사용

일반 표현식

String str = "Hello World";
if (str != null) {
    System.out.println(str.toUpperCase());
}

람다식 표현식

Optional<String> str = Optional.ofNullable("Hello World");
str.map(String::toUpperCase).ifPresent(System.out::println);

10. Lambda 표현식을 사용하여 Stream 파이프라인 작업 수행

일반 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = new ArrayList<String>();
for (String fruit : list) {
    if (fruit.startsWith("a")) {
        filteredList.add(fruit.toUpperCase());
    }
}
Collections.sort(filteredList);

람다식 표현식

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream().filter(fruit -> fruit.startsWith("a")).map(String::toUpperCase).sorted().collect(Collectors.toList());

내저장소 바로가기 luxury515