java函数式编程汇总

函数式编程
1.概念：
    面向对象思想需要关注用什么对象完成什么事情。函数式编程思想-关注的是对数据进行了什么操作
2.优点：
    代码简洁，开发快速（消灭大量代码嵌套；）；
    代码可读性搞；
    大数据量下处理集合效率高;（易于并发编程）

3.Lambda表达式：让我们不关注什么是对象，关注对数据进行什么操作。本质是个匿名类。可以多看看Swing里面对各种事件监听器的实现。
   
    编写代码方法：先编写匿名内部类，然后ctrl+1转换为lambda
   lambda表达式的省略规则：
       参数类型可以省略
       方法体只有一句代码时大括号return和唯一一句代码的分号可以省略
       方法只有一个参数的小括号可以省略
   
4.stream流：使用函数式编程，用来对集合或数组链状流式进行操作，方便对集合或数组操作
   
    使用stream注意事项：
        惰性求值（如果没有终结操作，没有中间操作是不会得到执行）
        流是一次性的（一旦一个流对象经过一个终结操作后，该流就不能被使用了）
        不会影响原生数据（对流中进行数据处理，不会影响集合中元素）
5.optional:非空操作的判断，避免空指针

6.常见函数式接口：
   Consumer消费接口：对传入的参数进行消费
   Function计算转换接口
    Predicate:判断接口
    Supplier:生产型接口，在get抽象方法中把创建好的对象返回
7.函数接口常用默认方法：
    and 相当于&&(与运算)
    or 相当于||（或运算）
    negate 相当于结果取反 ！
8.方法引用
     基本格式：  类名或者对象名称::方法名
           
     引用静态方法    类名：：方法名
     引用对象的实例方法  对象名::方法名
     引用类的实例方法 类名：：方法名
     构造方法引用 类名：：new

9.stream基本类型优化 
   stream提供了专门针对基本数据类型的方法。如：mapToInt,mapToLong,mapToDouble,flatMapToInt,flatMapToDouble 等
10.并行流:利用并行流提高操作效率。本质是把任务分配多线程处理。
   利用parallel()：串行流转换为并行流
   利用peek()：打印并行流日志
   利用parallelStream():把集合对象直接转换为并行流对象

    

package com.basic;

import lombok.Data;
import lombok.EqualsAndHashCode;

import java.awt.print.Book;
import java.util.List;

/**
 * The type Author.
 */
@EqualsAndHashCode//用于去重
@Data
public class Author {
    private Long id;
    private String name;
    private int age;
    private String intro;
    private List<Book> books;
}

package com.basic;

import lombok.Data;
import lombok.EqualsAndHashCode;

@EqualsAndHashCode
@Data
public class Book {
   private Long id;
   private  String name;
   private  String category;
   private  int score;
   private  String intro;
}


package com.basic;

import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.IntPredicate;

public class Lamda1 {


    public static int calculateNum(IntBinaryOperator operator){
        int a=10;
        int b=5;
        return  operator.applyAsInt(a,b);
    }

    public static void printNum(IntPredicate predicate){
       int[] arr={1,2,3,4,5};
       for(int i:arr){
           if(predicate.test(i)){
               System.out.println(i);
           }
       }
    }
    public static  void foreachArr(IntConsumer consumer){
        int[] arr={1,2,3,4,5};
        for(int i:arr){
            consumer.accept(i);
        }
    }
    public static void main(String[] args) {
//        new Thread(() -> System.out.println("#########")).start();
//        int sum=calculateNum((left, right) -> left+right);
//        System.out.println(sum);
//
//        printNum(value -> value%2==0);

        foreachArr(value -> System.out.println(value));
    }
}



package com.basic;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;

/**
 * The type Stream 1.
 */
@NoArgsConstructor
@Data
public class Stream1 {


    /**
     * The entry point of application.
     *
     * @param args the input arguments
     */
    public static void main(String[] args) {


        List<Integer> aa = new ArrayList<>();
        aa.add(3);
        aa.add(8);
        aa.add(3);


        aa.stream()
                .distinct().filter(integer -> integer > 4).forEach(integer -> System.out.println("consuer:" + integer));
        //不大于 negate()
        aa.stream().filter(((Predicate<Integer>) input -> input > 4).negate()).forEach(input -> System.out.println("不大于4的数据：" + input));

        //parallelStream():把集合对象直接转换为并行流对象,提高执行效率
        aa.parallelStream().filter(((Predicate<Integer>) input -> input > 4).negate()).forEach(input -> System.out.println("不大于4的数据：" + input));

        //mapToInt 优化执行效率
        aa.stream().mapToInt(value -> value).map(operand -> operand + 10).forEach(System.out::println);

        //单列集合
        Stream<Integer> stream = aa.stream();
        stream.forEach(integer -> System.out.println(integer));


        //双列集合：转换成单列集合后再创建
        HashMap<String, Integer> m = new HashMap<>();
        m.put("小新", 19);
        m.put("小新2", 139);
        m.put("小新4", 169);

        Stream<Map.Entry<String, Integer>> stream1 = m.entrySet().stream();
        System.out.println("map size:" + stream1.count());

        Set<Map.Entry<String, Integer>> entries = m.entrySet();
        Stream<Map.Entry<String, Integer>> stream2 = entries.stream();
        stream2.filter(stringIntegerEntry -> stringIntegerEntry.getValue() > 20).forEach(mm -> System.out.println(mm.getKey() + ":" + mm.getValue()));


        //最大值
        List<Integer> kk = Stream.of(aa, asList(6, 1, 3)).flatMap((Function<List<Integer>, Stream<Integer>>) integers -> integers.stream()).collect(toList());
        System.out.println("max:" + kk.stream().max((o1, o2) -> o1 - o2).get());

        //count:获取元素中的个数
        ArrayList<String> strings = new ArrayList<>();
        strings.add("b");
        strings.add("kk");
        System.out.println("count：" + strings.stream().count());

        //collect把流中元素转换成集合
        List<String> collect = strings.stream().collect(toList());
        System.out.println("collect:" + collect);

        //reduce对元素求和
        System.out.println("合计：" + Stream.of(1, 23, 4).reduce((integer, integer2) -> integer + integer2).get());

        //map 对流中元素进行计算或者转换
        aa.stream().sorted((o1, o2) -> {
            return o2 - o1;  //确定升降级
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return integer.toString() + "ok";
            }
        }).forEach(s -> System.out.println("s:" + s));

        //limit设置流的最大长度，超出抛出异常
        aa.stream().limit(2).forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println("in:" + integer);
            }
        });

        //跳过流中的n个元素，返回剩下的元素
        aa.stream().skip(2).forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println("i:" + integer);
            }
        });

        //anyMatch 任意匹配的返回true
        System.out.println("anymatch result:" + aa.stream().anyMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 4;
            }
        }));

        //allMatch:判断是否都符合匹配条件，符合返回true
        System.out.println("allMatch result:" + aa.stream().allMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 4;
            }
        }));

        //noneMatch:判断流中元素都不符合匹配条件。如果都不符合返回true
        System.out.println("noneMatch result:" + aa.stream().noneMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 9;
            }
        }));

        //findAny:获取流中任意一个元素。该方法没办法保证获取的一定是流中第一个元素
        System.out.println("findAny result:" + aa.stream().findAny().get());
        //findFirst：获取流中第一个元素
        System.out.println("findFirst：" + aa.stream().findFirst().get());

        //reduce求最大值
        System.out.println("reduce求最大值:" + aa.stream().reduce(Integer.MIN_VALUE, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer result, Integer ele) {
                return result < ele ? ele : result;
            }
        }));

        //reduce求和
        System.out.println("reduce：求和：" + aa.stream().reduce(0, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer result, Integer ele) {
                return result + ele;
            }
        }));

        //optional非空判断
        Integer ara = null;
        Optional<Integer> ara1 = Optional.ofNullable(ara);
        ara1.ifPresent(value -> {
            System.out.println(value);
        });

        //null输出默认值
        System.out.println(ara1.orElse(111));


        Stream<Integer> stream3 = Stream.of(1, 3, 5, 6, 10);
        System.out.println("串行流操作：" + stream3.filter(num -> num > 5).reduce((reuslt, input) -> reuslt + input).get());


        Stream<Integer> stream4 = Stream.of(1, 3, 5, 6, 10);
        System.out.println("并行流操作：" + stream4.parallel().peek(num -> System.out.println("打印执行日志" + num + Thread.currentThread().getName())).filter(num -> num > 5).reduce((reuslt, input) -> reuslt + input).get());

        System.out.println("helloBBB");
    }
}