Java 8实战阅读-函数式编程

Java 8实战阅读笔记
1、自定义特性接口(使用default关键字默认接口中函数实现)
2、谓词的复合(and or)
3、函数的复合(andThen) 管道处理必备

实践代码如下：
 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
// import java.util.stream.Collectors;

public class TestPredicate
{
    
    // 可使用boolean
    public interface PredicateTest<T>
    {
        String testStr(T t);
        // java8特性 接口可以定义实现 使用default
        default strictfp void sort()
        {
        }
    }
    
    public static String isContainA(String str)
    {
        return String.valueOf(str.contains("a"));
    }
    
    public static String isContainB(String str)
    {
        return String.valueOf(str.contains("b"));
    }
    
    public static List<String> filterStringLst(List<String> strList, PredicateTest<String> pre)
    {
        // List<String> newStr = strList.stream().filter(a->pre.testStr(a)).collect(Collectors.toList());
        List<String> newStr = new ArrayList<String>();
        for (String str : strList)
        {
            if (pre.testStr(str).equals("true"))
            {
                newStr.add(str);
            }
        }
        // java 8 排序方式
        // newStr.sort((a,b)->{return a.length() - b.length();});
        // newStr.sort(Comparator.comparing((a)->a.length()));
        // newStr.sort(Comparator.comparing(String::length));
        // 逆序
        newStr.sort(Comparator.comparing(String::length).reversed());
        // 二级排序 newStr.sort(Comparator.comparing(String::length).reversed().thenComparing(String::length));
        return newStr;
    }
    
    public static void LambdaComplex(String str)
    {
        // 谓词复合
        Predicate<String> p = String::isEmpty;
        p.and(a -> a.length() <= 0).or(a -> a.trim() == str);
        System.out.println("p(str)-->" + p.test(str));
        // 函数复合
        Function<String,Integer> f = String::length;
        System.out.println("f(str)-->" + f.andThen(x -> x+1).andThen(y -> y*y).apply(str));
    }

    public static void main(String[] args)
    {
        List<String> oldStr = Arrays.asList(new String[]{"a","b","abcd","c","ab","aa","aaa"});
        System.out.println(filterStringLst(oldStr,TestPredicate::isContainA).toString());
        System.out.println(filterStringLst(oldStr,TestPredicate::isContainB).toString());
        // 谓词/函数复合
        LambdaComplex("strTest");

    }

}

输出：

p(str)-->false
f(str)-->64
[abcd, aaa, ab, aa, a]
[abcd, ab, b]