Java框架前置知识5——函数式编程与stream流

1、什么是函数式编程？

2、函数式接口Predicate

public class PredicateSample {
    public static void main(String[] args) {
        Predicate<Integer> predicate = n -> n > 4;
        boolean result = predicate.test(10);
        System.out.println(result);
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        /*for (Integer integer : list) {
            if (integer%2 == 1)
                System.out.println(integer);
        }*/

        filter(list, n -> n % 2 == 1); //取所有奇数
        filter(list, n -> n % 2 == 0); //取所有偶数
        filter(list, n -> n > 5 && n % 2 == 0); //取所有偶数且大于5的数
    }

    public static void filter(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer num : list) {
            if (predicate.test(num))
                System.out.print(num + " ");
        }
    }

}

3、函数式接口包名java.util.function

/**
 * @author: Mr.Du
 * @description: Consumer接口的使用
 * @date: 2021/04/15 21:35
 */
public class ConsumerSample {
    public static void main(String[] args) {
        output(s -> System.out.println("向控制台打印：" + s));
        output(s -> {
            System.out.println("向XXX网站发送数据包" + s);
        });
    }

    public static void output(Consumer<String> consumer) {
        String text = "谁更厉害的水果沙，拉了科技和的更加你，们呢范冰冰";
        consumer.accept(text);
    }
}

/**
 * @author: Mr.Du
 * @description: 利用Function函数式接口生成定长随机字符串
 * @date: 2021/04/15 21:46
 */
public class FunctionSample {
    public static void main(String[] args) {
        Function<Integer,String> randomStringFunction = l ->{
            String chars = "abcdefjkijklmnopqrstuvwxyz0123456789";
            StringBuffer stringBuffer = new StringBuffer();
            Random random = new Random();
            for (int i = 0; i < l; i++) {
                int position = random.nextInt(chars.length());
                stringBuffer.append(chars.charAt(position));
            }
            return stringBuffer.toString();
        };
        String randomSting = randomStringFunction.apply(32);
        System.out.println(randomSting);
    }
}

4、函数式编程总结

5、Stream流式处理

/**
 * @author: Mr.Du
 * @description: Stream流对象的五种创建方式
 * @date: 2021/04/15 22:27
 */
public class StreamGenerator {
    //1、基于数组进行创建
    @Test
    public void generator1(){
        String[] arr = {"Lily","Andy","Jack","Smith"};
        Stream<String> stream = Stream.of(arr);
        stream.forEach(s -> System.out.println(s));
    }
    //2、基于集合进行创建
    @Test
    public void generator2(){
        List<String> list = new ArrayList<>();
        list.add("lily");
        list.add("Andy");
        list.add("haha");
        list.add("lucky");
        Stream<String> stream = list.stream();
        stream.forEach(s -> System.out.println(s));
    }
    //3、利用generator方法创建无限长度流
    @Test
    public void generator3(){
        Stream<Integer> stream = Stream.generate(()->new Random().nextInt(100000));
        stream.limit(10).forEach(s -> System.out.println(s));
    }
    //4、基于迭代器创建流
    @Test
    public void generator4(){
        Stream<Integer> stream = Stream.iterate(1, n -> n + 1);
        stream.limit(100).forEach(s -> System.out.println(s));
    }
    //5、基于字符序列创建流
    @Test
    public void generator5(){
        String str = "abcdefg我的";
        IntStream stream = str.chars();
        stream.forEach(s -> System.out.println((char)s));
    }
}

stream常用方法案例：

/**
 * @author: Mr.Du
 * @description: stream流的常用方法
 * @date: 2021/04/15 23:11
 */
public class StreamMethod {
    //提取集合中所有偶数并求和
    @Test
    public void case1(){
        List<String> list = Arrays.asList("1","2","3","4","5");
        int sum = list.stream()  //获取stream流
                .mapToInt(s->Integer.parseInt(s))  //mapToInt将流中每一个数据转为整数
                .filter(n->n%2==0)  //filter对流数据进行过滤
                .sum();
        System.out.println(sum);
    }

    //所有名字首字母大写
    @Test
    public void case2(){
        List<String> list = Arrays.asList("lily", "smith", "jackson");
        List<String> newList = list.stream()
                //按规定对每一个流数据进行转换
                .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1))
                //.forEach(s-> System.out.println(s));
                //collect对流数据进行手机，生成新的List/Set
                .collect(Collectors.toList());
        System.out.println(newList);
    }
    //将所有奇数从大到小进行排序，且不许出现重复
    @Test
    public void case3(){
        List<Integer> list = Arrays.asList(1, 60, 38, 21, 51, 60, 51, 73);
        List<Integer> newList = list.stream().distinct()  //去除重复的流数据
                .filter(n -> n % 2 == 1)
                .sorted((a, b) -> b - a)  //流数据
                .collect(Collectors.toList());
        System.out.println(newList);
    }
}