【Java】Java函数式编程以及流的操作

• • 大纲
  • lambda表达式
  • • 一般内部类
    • 局部内部类
    • 匿名内部类
  • 基于函数式接口的lambda表达式
  • JDK8中自带的函数式接口
  • • Predicate判断
    • Consumer消费
    • Supplier供应商
    • Function方法
    • 其他接口
  • 方法引用和构造器引用
  • • 静态方法引用
    • 非静态方法引用
    • 构造器引用
  • lambda表达式中的异常处理
  • Currying in java
  • Java Stream API
  • 使用stream流操作Collections
  • • 创建stream流
    • • 方法一：Stream.generate
      • 方法二：Stream.of
      • 方法三：streamFromCollections
      • 方法四：Stream.builder
    • 操作stream
    • • foreach
      • map
      • collect
      • filter
      • findFirst
      • peek
      • flatmap
  • stream流操作nio
  • ParallelStream

函数式编程学习的重点

• Lambda表达式
• Java Stream API

Lambda表达式

• 基于匿名类
• 基于函数式接口
• JDK8自带的函数式接口
• 方法引用和构造器引用

Java Stream API

• 操作Collections
• 操作NIO2.0
• 线程解析

实现的接口

public interface PriceDashboard {
    Price getPrice(String symbol);
}

内部类可以调用外部属性

@Slf4j
public class DemoPart1Test {
    private Map stockPrices = new HashMap<>();
    private int accessCount = 0;

    public void init() {
        stockPrices.put("APPL", Price.builder()
                .currPrice(new BigDecimal("130.06"))
                .build());
    }

    private class PriceDashboardNewImpl implements PriceDashboard {
        @Override
        public Price getPrice(String symbol) {
            log.info("log this inner class action");
            return stockPrices.get(symbol);
//            log.info("about to reference by this");
//            return DemoPartOneTest.this.stockPrices.get(symbol);
        }
    }

    public static void main(String[] args) {
        DemoPart1Test test = new DemoPart1Test();
        test.init();
        PriceDashboard priceDashboard = test.new PriceDashboardNewImpl();
        log.info(priceDashboard.getPrice("APPL").toString());
    }
}

定义在成员方法中，在代码块之外无法使用

@Slf4j
public class DemoPart2Test {
    private Map stockPrices = new HashMap<>();
    private int accessCount = 0;

    public void init() {
        stockPrices.put("APPL", Price.builder()
                .currPrice(new BigDecimal("130.06"))
                .build());
    }

    public PriceDashboard priceBoard() {
         class PriceDashboardInMethodImpl implements PriceDashboard {
            @Override
            public Price getPrice(String symbol) {
                log.info("log this in-method action");
                return stockPrices.get(symbol);
            }
        }
        return new PriceDashboardInMethodImpl();
    }

    public static void main(String[] args) {
        DemoPart2Test test = new DemoPart2Test();
        test.init();
        PriceDashboard priceDashboard = test.priceBoard();
        log.info(priceDashboard.getPrice("APPL").toString());
    }
}

一般写法

函数式写法

public PriceDashboard anonPriceBoard() {
    return symbol -> {
        log.info("log this in-method anonymous action");
        return stockPrices.get(symbol);
    };
}

函数式接口的使用只能存在一个抽象方法，存在多余的抽象方法则编译不通过。

@FunctionalInterface
public interface PriceCalculation {
    BigDecimal increase(BigDecimal curr, BigDecimal inc);

    static void staticMethod() {
        System.out.println("static method");
    }

    default void defaultMethod() {
        System.out.println("default method");
    }
}

静态方法的调用可以通过接口名称直接调用，而default方法只能通过实现类来调用。

public class PriceCalculationImpl implements PriceCalculation{
    @Override
    public BigDecimal increase(BigDecimal curr, BigDecimal inc) {
        return curr.add(inc);
    }

    @Override
    public void defaultMethod() {
        System.out.println("customized default");
    }

    public static void main(String[] args) {
        //static method
        PriceCalculation.staticMethod();
        //default method
        new PriceCalculationImpl().defaultMethod();
    }
}

举例：

// 接口一
@FunctionalInterface
public interface Demo0ParamInterf {
    String print();
}

// 接口二
@FunctionalInterface
public interface Demo1ParamInterf {
    void print(int a);
}

// 接口三
@FunctionalInterface
public interface Demo2ParamInterf {
    int print(int a, int b);
}

// 接口四
@FunctionalInterface
public interface Demo3ParamInterf {
    int print();

    //equals is Object method
    boolean equals(Object a);

    //Object.clone is not public, so not functional
//    Object clone();
}

表达式

public class DemoParamTest {
    public static void main(String[] args) {
        Demo0ParamInterf impl0 = () -> "0 param";

        Demo1ParamInterf impl1 = (a) -> System.out.println(a);

        Demo2ParamInterf impl2 = (a, b) -> {
            int c = a * b;
            int d = Math.floorMod(c, a - 1);
            return d;
        };
    }
}

接口

@FunctionalInterface
public interface Predicate {

    
    boolean test(T t);

    
    default Predicate and(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    
    default Predicate negate() {
        return (t) -> !test(t);
    }

    
    default Predicate or(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    
    static  Predicate isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

    
    @SuppressWarnings("unchecked")
    static  Predicate not(Predicate target) {
        Objects.requireNonNull(target);
        return (Predicate)target.negate();
    }
}

使用

@Slf4j
public class DemoPredicateTest {

    @Test
    public void SimplePredicate() {
        Predicate isAdult = age -> (age > 18);
        log.info(String.valueOf(isAdult.test(20)));
        log.info(String.valueOf(isAdult.test(16)));
    }

    @Test
    public void AndPredicate() {
        Predicate isAdult = new Predicate() {
            @Override
            public boolean test(Integer age) {
                log.info("we are young once");
                return age > 18;
            }
        };
        Predicate isRetired = age -> {
            log.info("yes, pension");
            return age > 70;
        };

        log.info(String.valueOf(isAdult.and(isRetired).test(25)));
//        log.info(String.valueOf(isRetired.and(isAdult).test(25)));
    }

    @Test
    public void OrPredicate() {
        Predicate cannotRead = age -> (age < 4);
        Predicate cannotCode = age -> (age > 99);
        log.info("Should quit coding at 35? {}",
                cannotRead.or(cannotCode).test(35));
    }

    @Test
    public void NegatePredicate(){
        Predicate isAdult = age -> (age >18);
        log.info(String.valueOf(isAdult.negate().test(16)));
    }

    @Test
    public void compositePredicate(){
        Predicate cannotRead = age -> (age < 4);
        Predicate cannotCode = age -> (age > 99);

        //composite them together
        Predicate compositePredicate = cannotRead
                .or(cannotCode)
                .negate();
        //now you can pass this composite predicate around in your program
        log.info("Should quit coding at 35? {}", compositePredicate.test(35));
    }

}

接口

@FunctionalInterface
public interface Consumer {

    
    void accept(T t);

    
    default Consumer andThen(Consumer after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

使用

@Slf4j
public class DemoConsumerTest {

    @Test
    public void LogConsumer() {
        Consumer