1. Predicate
Predicate<String> predicate = str -> str.length() > 5;
boolean result = predicate.test("Hello World");
설명: Predicate 인터페이스는 단일 인수를 사용하고 조건에 따라 부울 값을 반환합니다. 이 예제에서는 주어진 문자열의 길이가 5자보다 큰지 확인하는 술어를 만듭니다. 그런 다음 test() 메서드를 사용하여 술어를 문자열 "Hello World"에 적용합니다. "Hello World"의 길이가 5보다 크기 때문에 result의 값은 true가 됩니다.
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class PredicateExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Predicate<Integer> evenPredicate = num -> num % 2 == 0;
List<Integer> evenNumbers = filterNumbers(numbers, evenPredicate);
System.out.println("Even numbers: " + evenNumbers);
}
public static List<Integer> filterNumbers(List<Integer> numbers, Predicate<Integer> predicate) {
return numbers.stream()
.filter(predicate)
.toList();
}
}
설명: 이 예에는 1에서 10까지의 숫자 목록이 있습니다. 'Predicate'를 사용하여 이 목록에서 짝수를 필터링하려고 합니다. 모듈러스 연산을 수행하여 숫자가 짝수인지 확인하는 evenPredicate라는 Predicate를 정의합니다. 그런 다음 filterNumbers 메서드를 사용하여 evenPredicate를 기반으로 숫자 목록을 필터링합니다. 필터링된 짝수는 evenNumbers 목록에 저장됩니다. 마지막으로 System.out.println()을 사용하여 짝수를 인쇄합니다.
2. Function<T, R>
Function<Integer, String> function = num -> "The number is: " + num;
String result = function.apply(42);
설명: Function 인터페이스는 T 유형의 인수를 취하고 R 유형의 결과를 생성하는 함수를 나타냅니다. 이 예제에서는 정수를 사용하고 사용자 지정 메시지와 함께 숫자의 문자열 표현을 반환하는 함수를 만듭니다. apply() 메서드를 사용하여 숫자 42에 함수를 적용합니다. result의 값은 "The number is: 42"가 됩니다.
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
public class FunctionExample {
public static void main(String[] args) {
List<String> strings = Arrays.asList("apple", "banana", "cherry");
Function<String, String> uppercaseFunction = str -> str.toUpperCase();
List<String> uppercaseStrings = transformStrings(strings, uppercaseFunction);
System.out.println("Uppercase strings: " + uppercaseStrings);
}
public static List<String> transformStrings(List<String> strings, Function<String, String> function) {
return strings.stream()
.map(function)
.toList();
}
}
설명: 이 예제에는 "apple", "banana" 및 "cherry"라는 문자열 목록이 있습니다. 우리는 Function을 사용하여 각 문자열을 대문자 버전으로 변환하려고 합니다. uppercaseFunction이라는 Function<String, String>을 정의합니다. 이 함수는 문자열을 입력으로 사용하고 toUpperCase() 메서드를 사용하여 대문자 버전을 반환합니다. 그런 다음 transformStrings 메서드를 사용하여 목록의 각 문자열에 uppercaseFunction을 적용합니다. 변환된 대문자 문자열은 uppercaseStrings 목록에 저장됩니다. 마지막으로 System.out.println()을 사용하여 대문자 문자열을 인쇄합니다.
3. Consumer
Consumer<String> consumer = str -> System.out.println("Value: " + str);
consumer.accept("Hello World");
설명: Consumer 인터페이스는 단일 입력을 수락하고 일부 작업을 수행하는 작업을 나타냅니다. 이 예제에서는 문자열을 사용하여 문자열 값이 포함된 메시지를 인쇄하는 소비자를 만듭니다. accept() 메서드를 사용하여 "Hello World"라는 문자열에 소비자를 적용합니다.
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
public class ConsumerExample {
public static void main(String[] args) {
List<String> fruits = Arrays.asList("apple", "banana", "cherry");
Consumer<String> printConsumer = str -> System.out.println("Fruit: " + str);
consumeList(fruits, printConsumer);
}
public static <T> void consumeList(List<T> list, Consumer<T> consumer) {
for (T item : list) {
consumer.accept(item);
}
}
}
설명: 이 예에는 "사과", "바나나" 및 "체리"라는 과일 목록이 있습니다. 우리는 Consumer를 사용하여 각 과일을 인쇄하려고 합니다. printConsumer라는 Consumer을 정의합니다. 이 함수는 문자열을 입력으로 받고 System.out.println()을 사용하여 과일과 함께 메시지를 인쇄합니다. 그런 다음 'consumeList' 메서드를 사용하여 목록의 각 과일을 반복하고 'accept()' 메서드를 사용하여 각 항목에 'printConsumer'를 적용합니다. 이렇게 하면 "Fruit: " 접두사가 있는 각 과일이 인쇄됩니다.
4. Supplier
Supplier<Integer> supplier = () -> 42;
int result = supplier.get();
설명: Supplier 인터페이스는 결과 공급자를 나타냅니다. 입력을 받지 않고 'T' 유형의 값을 제공합니다. 이 예제에서는 상수 값 42를 제공하는 공급자를 생성합니다. get() 메서드를 사용하여 공급자로부터 값을 검색합니다. 결과 값은 42입니다.
import java.util.function.Supplier;
public class SupplierExample {
public static void main(String[] args) {
Supplier<String> passwordSupplier = () -> generatePassword(8);
String password = passwordSupplier.get();
System.out.println("Generated Password: " + password);
}
public static String generatePassword(int length) {
String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()";
StringBuilder password = new StringBuilder();
for (int i = 0; i < length; i++) {
int randomIndex = (int) (Math.random() * characters.length());
password.append(characters.charAt(randomIndex));
}
return password.toString();
}
}
설명: 이 예제에는 임의 암호를 생성하는 passwordSupplier라는 Supplier이 있습니다. 'passwordSupplier'는 원하는 길이(이 경우 8자)로 'generatePassword()' 메서드를 호출하는 람다 식을 사용하여 정의됩니다. passwordSupplier의 get() 메서드를 사용하여 생성된 암호를 검색하고 password 변수에 저장합니다. 마지막으로 System.out.println()을 사용하여 생성된 암호를 인쇄합니다. 비밀번호는 대문자, 소문자, 숫자, 특수문자의 조합으로 구성됩니다.
5. UnaryOperator
UnaryOperator<Integer> operator = num -> num * 2;
int result = operator.apply(5);
설명: UnaryOperator 인터페이스는 T 유형의 단일 피연산자에 대한 작업을 나타내며 동일한 T 유형의 결과를 생성합니다. 이 예제에서는 주어진 숫자를 두 배로 만드는 단항 연산자를 만듭니다. apply() 메서드를 사용하여 숫자 5에 연산자를 적용합니다. result의 값은 10이 됩니다.
import java.util.Arrays;
import java.util.List;
import java.util.function.UnaryOperator;
public class UnaryOperatorExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
UnaryOperator<Integer> squareOperator = num -> num * num;
squareNumbers(numbers, squareOperator);
System.out.println("Squared numbers: " + numbers);
}
public static void squareNumbers(List<Integer> numbers, UnaryOperator<Integer> operator) {
for (int i = 0; i < numbers.size(); i++) {
numbers.set(i, operator.apply(numbers.get(i)));
}
}
}
설명: 이 예제에는 1, 2, 3, 4 및 5의 숫자 목록이 있습니다. UnaryOperator를 사용하여 각 숫자를 제곱하려고 합니다. squareOperator라는 UnaryOperator를 정의합니다. 이 함수는 정수를 입력으로 받고 그 제곱을 반환합니다. 그런 다음 squareNumbers 메서드를 사용하여 목록의 각 숫자를 반복하고 apply() 메서드를 사용하여 각 숫자에 squareOperator를 적용합니다. 이렇게 하면 제곱 값을 포함하도록 원래 목록이 수정됩니다. 마지막으로 System.out.println()을 사용하여 제곱된 숫자를 인쇄합니다. 출력은 "숫자 제곱: [1, 4, 9, 16, 25]"입니다.
6. BinaryOperator
BinaryOperator<Integer> operator = (num1, num2) -> num1 + num2;
int result = operator.apply(10, 20);
설명: BinaryOperator 인터페이스는 T 유형의 두 피연산자에 대한 작업을 나타내며 동일한 T 유형의 결과를 생성합니다. 이 예제에서는 두 숫자에 대해 더하기를 수행하는 이항 연산자를 만듭니다. apply() 메서드를 사용하여 숫자 10과 20에 연산자를 적용합니다. result의 값은 30이 됩니다.
import java.util.function.BinaryOperator;
public class BinaryOperatorExample {
public static void main(String[] args) {
BinaryOperator<Integer> maxOperator = BinaryOperator.maxBy(Integer::compare);
int result1 = maxOperator.apply(5, 10);
System.out.println("Maximum value: " + result1); // Output: Maximum value: 10
int result2 = maxOperator.apply(15, 8);
System.out.println("Maximum value: " + result2); // Output: Maximum value: 15
}
}
설명: 이 예제에는 maxOperator라는 BinaryOperator가 있으며 BinaryOperator.maxBy()를 사용하여 두 정수 사이의 최대값을 찾습니다. maxOperator는 Integer::compare를 사용하여 두 정수를 비교하여 최대값을 결정합니다. apply() 메서드를 사용하여 maxOperator를 두 쌍의 정수((5, 10) 및 (15, 8))에 적용합니다. 결과는 각각 result1 및 result2에 저장됩니다. 마지막으로 System.out.println()을 사용하여 최대값을 인쇄합니다. 출력은 "최대값: 10" 및 "최대값: 15"이며 각 쌍에서 찾은 최대값을 나타냅니다.
7. BiPredicate<T, U>
BiPredicate<String, Integer> predicate = (str, num) -> str.length() > num;
boolean result = predicate.test("Hello World", 5);
설명: BiPredicate 인터페이스는 두 개의 인수를 취하고 조건에 따라 부울 값을 반환하는 술어를 나타냅니다. 이 예제에서는 주어진 문자열의 길이가 주어진 숫자보다 큰지 확인하는 bi-predicate를 생성합니다. test() 메서드를 사용하여 조건자를 문자열 "Hello World"와 숫자 5에 적용합니다. result의 값은 "Hello World"의 길이가 5보다 크기 때문에 true가 됩니다.
import java.util.function.BiPredicate;
public class BiPredicateExample {
public static void main(String[] args) {
BiPredicate<String, Integer> lengthCheck = (str, length) -> str.length() > length;
boolean result1 = lengthCheck.test("Hello", 5);
System.out.println("Length greater than 5? " + result1); // Output: Length greater than 5? true
boolean result2 = lengthCheck.test("Java", 10);
System.out.println("Length greater than 10? " + result2); // Output: Length greater than 10? false
}
}
설명: 이 예제에는 주어진 문자열의 길이가 제공된 숫자보다 큰지 확인하는 lengthCheck라는 BiPredicate<String, Integer>가 있습니다. lengthCheck는 문자열의 길이(str.length())와 주어진 숫자(length)를 비교하는 람다 식을 사용하여 정의됩니다. test() 메서드를 사용하여 lengthCheck를 ("Hello", 5) 및 ("Java", 10)의 두 쌍에 적용합니다. 결과는 각각 result1 및 result2에 저장됩니다. 마지막으로 System.out.println()을 사용하여 결과를 인쇄합니다. 출력은 "5보다 큰 길이? 참" 및 "10보다 큰 길이? 거짓"이며 각 경우에 문자열의 길이가 주어진 숫자보다 큰지 여부를 나타냅니다.
8. BiFunction<T, U, R>
BiFunction<Integer, String, String> function = (num, str) -> "The number " + num + " corresponds to " + str;
String result = function.apply(42, "forty-two");
설명: BiFunction 인터페이스는 두 개의 인수를 취하고 결과를 생성하는 함수를 나타냅니다. 이 예제에서는 정수와 문자열을 취하고 두 값을 결합한 문자열 표현을 반환하는 이중 함수를 만듭니다. 숫자 42와 문자열 "forty-two"에 함수를 적용하기 위해 apply() 메서드를 사용합니다. result의 값은 "42라는 숫자는 42에 해당합니다."가 됩니다.
import java.util.function.BiFunction;
public class BiFunctionExample {
public static void main(String[] args) {
BiFunction<String, String, String> concatenate = (str1, str2) -> str1 + str2;
String result1 = concatenate.apply("Hello", "World");
System.out.println("Concatenated string: " + result1); // Output: Concatenated string: HelloWorld
String result2 = concatenate.apply("Java", "Programming");
System.out.println("Concatenated string: " + result2); // Output: Concatenated string: JavaProgramming
}
}
설명: 이 예제에는 두 문자열을 함께 연결하는 concatenate라는 BiFunction<String, String, String>이 있습니다. concatenate는 첫 번째 문자열(str1)을 두 번째 문자열(str2)과 연결하는 람다 식을 사용하여 정의됩니다. apply() 메서드를 사용하여 concatenate 함수를 ("Hello", "World") 및 ("Java", "Programming")의 두 쌍의 문자열에 적용합니다. 결과는 각각 result1 및 result2에 저장됩니다. 마지막으로 System.out.println()을 사용하여 연결된 문자열을 인쇄합니다. 출력은 "연결된 문자열: HelloWorld" 및 "연결된 문자열: JavaProgramming"이며 각 경우에 두 문자열의 연결을 나타냅니다.
9. BiConsumer<T, U>
BiConsumer<String, Integer> consumer = (str, num) -> System.out.println("Value: " + str + ", Number: " + num);
consumer.accept("Hello World", 42);
설명: BiConsumer 인터페이스는 두 개의 인수를 수락하고 일부 작업을 수행하는 작업을 나타냅니다. 이 예제에서는 문자열과 정수를 사용하고 두 값을 모두 포함하는 메시지를 인쇄하는 이중 소비자를 만듭니다. 우리는 accept() 메서드를 사용하여 "Hello World" 문자열과 숫자 42에 소비자를 적용합니다. 출력은 "Value: Hello World, Number: 42"입니다.
import java.util.function.BiConsumer;
public class BiConsumerExample {
public static void main(String[] args) {
BiConsumer<String, Integer> displayInfo = (name, age) -> System.out.println("Name: " + name + ", Age: " + age);
displayInfo.accept("John", 25);
// Output: Name: John, Age: 25
displayInfo.accept("Sarah", 30);
// Output: Name: Sarah, Age: 30
}
}
설명: 이 예제에는 displayInfo라는 BiConsumer<String, Integer>가 있는데, 이름과 나이를 입력으로 받아 표시합니다. displayInfo는 System.out.println()을 사용하여 이름과 나이를 인쇄하는 람다 식을 사용하여 정의됩니다. 우리는 accept() 메서드를 사용하여 ("John", 25) 및 ("Sarah", 30)의 두 쌍의 입력을 수락합니다. 그런 다음 displayInfo 소비자가 각 쌍에 적용되어 이름과 나이 정보가 콘솔에 인쇄됩니다. 출력은 다음과 같습니다.
Name: John, Age: 25
Name: Sarah, Age: 30
각 쌍의 이름과 나이 조합을 나타냅니다.
0개의 댓글
