函数式编程-常用的函数式接口

1 lambda作为参数和返回值

package com.stream.函数式编程.lambda作为参数和返回值;

public class LambdaAsParams {
    public static void main(String[] args) {
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " --> " + "Thread starting ...");
            }
        });

        startThread(() -> System.out.println(Thread.currentThread().getName() + " --> " + "Thread starting ..."));
    }

    public static void startThread(Runnable runnable) {
        new Thread(runnable).start();
    }
}

package com.stream.函数式编程.lambda作为参数和返回值;

import java.util.Arrays;
import java.util.Comparator;

public class LambdaAsReturn {
    public static void main(String[] args) {
        String[] strArr = {"aaa", "bbbb", "ddddd", "ss"};
        System.out.println(Arrays.toString(strArr));

        Arrays.sort(strArr, getComparator());
        Arrays.sort(strArr, (o1, o2) -> o2.length() - o1.length());
        System.out.println(Arrays.toString(strArr));

    }

    public static Comparator<String> getComparator() {

        return (o1, o2) -> o2.length() - o1.length();
    }
}

2 lambda延时运行

package com.stream.函数式编程.lambda延时运行;

public class DelayRunning {
    public static void main(String[] args) {
        String msg_1 = "... msg 1 ...";
        String msg_2 = "... msg 2 ...";
        printLogByLevel(1, msg_1 + msg_2);
    }

    public static void printLogByLevel(Integer level, String msg) {
        if (level == 1) {
            System.out.println(msg);
        }
    }
}

package com.stream.函数式编程.lambda延时运行;

public class DelayRunningByLambda {
    public static void main(String[] args) {
        String msg_1 = "... msg 1 ...";
        String msg_2 = "... msg 2 ...";
        printLogByLevel(1, () -> msg_1 + msg_2);
    }

    public static void printLogByLevel(Integer level, MsgBuilder msgBuilder) {
        if (level == 1) {
            System.out.println(msgBuilder.buildMsg());
        }
    }
}

@FunctionalInterface
interface MsgBuilder {
    String buildMsg();
}

3 ConsumerInterface

package com.stream.函数式编程.常用的函数式接口.ConsumerInterface;

import com.google.common.collect.Lists;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        List<Integer> listNew = Lists.newArrayList();

        Consumer<Integer> processor = value -> putIntegerToList(listNew, value);
        List<Integer> list = Arrays.asList(1, 2, 3, 4);

        list.forEach(processor);
        System.out.println(listNew);
    }

    public static void putIntegerToList(List<Integer> list, Integer value) {
        list.add(value);
    }
}

package com.stream.函数式编程.常用的函数式接口.ConsumerInterface;

import cn.hutool.core.util.StrUtil;
import com.google.common.collect.Lists;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerTestAndThen {
    public static void main(String[] args) {

        formatInfo();
    }

    private static void formatInfo() {
        List<String> list = Lists.newArrayList();
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马儿扎哈,男"};
        Consumer<String> processor = info -> {
            String[] split = info.split(StrUtil.COMMA);
            list.add("姓名:" + split[0] + " " + "性别:" + split[1]);
        };
        Arrays.asList(array).forEach(processor);
        System.out.println(list);
    }

    private static void andThenTest() {
        List<String> list_1 = Lists.newArrayList();
        List<String> list_2 = Lists.newArrayList();
        Consumer<String> processor_1 = e -> list_1.add(e.toLowerCase());
        Consumer<String> processor_2 = e -> list_2.add(e.toUpperCase());

        Arrays.asList("hEllo", "World")
                .forEach(processor_1.andThen(processor_2));
        System.out.println(list_1);
        System.out.println(list_2);
    }
}

4 SupplierInterface

package com.stream.函数式编程.常用的函数式接口.SupplierInterface;

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        String string = getString(() -> "hello supplier");
        System.out.println(string);
    }

    public static String getString(Supplier<String> supplier) {
        return supplier.get();
    }
}

package com.stream.函数式编程.常用的函数式接口.SupplierInterface;

import com.google.common.collect.Lists;

import java.util.Collections;
import java.util.function.Supplier;

public class MaxValue {
    public static void main(String[] args) {
        Integer[] arrValue = {1, 2, 100, 0, 99};

        Supplier<Integer> processor = () -> Collections.max(Lists.newArrayList(arrValue));
        System.out.println(processor.get());
    }
}

5 PredicateInterface

package com.stream.函数式编程.常用的函数式接口.predicateInterface;

import cn.hutool.core.util.StrUtil;

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

public class PredicateInterface {
    public static void main(String[] args) {
        predicateInfoTest();
    }

    public static void predicateTest() {

        Predicate<String> processor = fistName -> fistName.equals("zhaoShuai11");
        List<String> list = Arrays.asList("zhaoshuai11", "zhaoShuai11");
        list.stream()
                .filter(processor)
                .forEach(System.out::println);
    }

    public static void andOrPredicateTest() {
        List<String> list = Arrays.asList("zhao", "zhaoShuai11");

        System.out.println("-------and---------");
        Predicate<String> processor = str -> str.length() > 5 && str.contains("a");
        list.stream()
                .filter(processor)
                .forEach(System.out::println);

        Predicate<String> processor_1 = str -> str.length() > 5;
        Predicate<String> processor_2 = str -> str.contains("a");
        list.stream()
                .filter(processor_1.and(processor_2))
                .forEach(System.out::println);

        System.out.println("-------or---------");
        Predicate<String> processor_or = str -> str.length() > 5 || str.contains("a");
        list.stream()
                .filter(processor_or)
                .forEach(System.out::println);

        Predicate<String> processor_3 = str -> str.length() > 5;
        Predicate<String> processor_4 = str -> str.contains("a");
        list.stream()
                .filter(processor_3.or(processor_4))
                .forEach(System.out::println);

        System.out.println("--------negate--------");
        Predicate<String> processor_negate = str -> str.length() > 5 || str.contains("a");
        list.stream()
                .filter(processor_negate.negate())
                .forEach(System.out::println);
    }

    private static void predicateInfoTest() {
        List<String> list;
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马儿扎哈,男"};
        Predicate<String> processor = str -> {
            String[] split = str.split(StrUtil.COMMA);
            return split[0].length() == 4 && split[1].equals("女");
        };
        list = Arrays.stream(array)
                .filter(processor)
                .collect(Collectors.toList());
        System.out.println(list);
    }
}

6 FunctionInterface

package com.stream.函数式编程.常用的函数式接口.FunctionInterface;

import com.google.common.collect.Lists;

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

public class FunctionTest {
    public static void main(String[] args) {
        functionInfoTest();
    }

    public static void string2Integer() {
        List<Integer> list;
        String[] array = {"111", "234", "355"};
        Function<String, Integer> processor = Integer::parseInt;
        list = Arrays.stream(array)
                .map(processor)
                .collect(Collectors.toList());
        System.out.println(list);
    }

    public static void andThenFunction() {
        String[] array = {"111", "234", "355"};
        List<String> list = Lists.newArrayList();

        Function<String, String> processor = t -> String.valueOf(Integer.parseInt(t) + 10);
        list = Arrays.stream(array)
                .map(processor)
                .collect(Collectors.toList());
        System.out.println(list);

        Function<String, Integer> processor_1 = e -> Integer.parseInt(e) + 10;
        Function<Integer, String> processor_2 = String::valueOf;
        list = Arrays.stream(array)
                .map(processor_1.andThen(processor_2))
                .collect(Collectors.toList());
        System.out.println(list);
    }

    private static void functionInfoTest() {
        String str = "杨幂,20";
        Function<String, Integer> processor = e -> Integer.parseInt(e.split(",")[1]) + 100;
        System.out.println(processor.apply(str));
    }
}

Original: https://blog.csdn.net/zs18753479279/article/details/127822705
Author: @Autowire
Title: 函数式编程-常用的函数式接口