框架前置知识(四)

整体介绍

◆实例讲解Lambda语法 ◆基于Lambda实现函数式编程 ◆Stream流式处理

什么是Lambda表达式

◆JDK8(SDK 1.8)开始支持Lambda表达式，用来让程序编写更优雅 ◆利用Lambda可以更简洁的实现匿名内部类与函数声明与调用 ◆基于Lambda提供streami流式处理极大简化对集合的操作

传统代码

使用Lambda表达式

Lambda语法格式

新建四则运算接口，MathOperation.java

package com.imooc.lambda;
 
/**
 * 四则运算接口
 */
public interface MathOperation {
    public Float operate(Integer a ,Integer b);
}

实现接口，新建LambdaSample.java文件

package com.imooc.lambda;
 
public class LambdaSample {
 
    public static void main(String[] args) {
        //1.标准Lambda使用方式
        //约束条件:Lambda表达式只能实现有且只有一个抽象方法的接口,Java称为"函数式接口"
        MathOperation addition = (Integer a,Integer b)->{
            System.out.println("加法运算");
            return a+b+0f;
        };
        System.out.println(addition.operate(5,3));
        /*等价代码
        1.创建类
        class Addition implements MathOperation{
            @Override
            public Float operate(Integer a, Integer b) {
                System.out.println("加法运算");
                return a+b+0f;
            }
        }
        2.实例化对象
        Addition addition = new Addition();
        3.调用函数
        System.out.println(addition.operate(5,3));
        */
 
        //2.Lambda允许忽略参数类型
        MathOperation substraction = (a,b)->{
            return a-b+0f;
        };
        System.out.println(substraction.operate(5,3));
 
        //3.单行实现代码可以省略大括号和return
        MathOperation multiplication = (a,b)->a*b+0f;
        System.out.println(multiplication.operate(5,3));
 
    }
}

注意：约束条件:Lambda表达式只能实现有且只有一个抽象方法的接口,Java称为”函数式接口” 因为lambda不知道该实现哪个抽象方法

函数式编程

基于Lambda的一种全新开发方式

什么是函数式编程

◆函数式编程是基于函数式接口并使用lambda表达的编程方式 ◆函数式编程理念是将代码作为可重用数据代入到程序运行中 ◆函数式编程强调”你想做什么”，而不是”你想怎么做’

什么是函数式接口

◆函数式接口是有且只有一个抽象方法的接口 ◆Java中拥有大量函数式接口，如java.lang.Runnable ◆JDK8后提供了一系列新的函数式接口，位于java.util.function

函数式接口Predicate

◆Predicate是新增的函数式接口，位于java.util.function ◆Predicate用于测试传入的数据是否满足判断要求 ◆Predicate接口需要实现test()方法进行逻辑判断,返回true或false

package com.imooc.lambda;
 
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
 
/**
 
* 理解函数式编程
* Predicate函数式接口的使用方法
  */
  public class PredicateSample {
  public static void main(String[] args) {
  //内部是泛型 Integer传入T，得知test方法传入需为整形
  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 num:list){
if(num%2==1){
System.out.println(num);
}
}*/
 
 
  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 + " ");
  }
  }
  System.out.println("");
  }
  }

注意Filter函数的第二个参数类型，是predicate接口Predicate<Integer> predicate

其它函数式接口

java.util.function (Java Platform SE 8 ) (oracle.com)

Consumer使用

package com.imooc.lambda;
 
import java.util.function.Consumer;
 
/**
 * Consumer接口的使用
 */
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);
    }
}

Function<T,R>使用

随机生成32位长度的字符串，常用于安全领域的加密与解密

package com.imooc.lambda;
 
import java.util.Random;
import java.util.function.Function;
 
/**
 * 利用Function函数式接口生成定长随机字符串
 */
public class FunctionSample {
    public static void main(String[] args) {
        Function<Integer,String> randomStringFunction = l->{
          String chars = "abcdefghijklmnopqrstuvxwyz0123456789";
            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 randomString = randomStringFunction.apply(32);
        System.out.println(randomString);
    }
}

总结

Stream介绍

Stream流式处理

◆Stream流式处理是建立在Lambda基础上的多数据处理技术 ◆Stream对集合数据处理进行高度抽象极大简化代码量 ◆Stream可对集合进行迭代，去重，筛选，排序，聚合等一系列处理

Stream实例

流水线式加工代码，第一步筛选偶数，第二步大到小排序，最后找出最大的数

Stream常用方法

Stream的五种创建方式

package com.imooc.stream;
 
import org.junit.Test;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;
 
/**
 * Stream流对象的五种创建方式
 */
public class StreamGenerator {
    //1.基于数组进行创建
    @Test
    public void generator1(){
        String[] arr = {"Lily" , "Andy" , "Jackson" , "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("Jackson");
        list.add("Smith");
        Stream<String> stream = list.stream();
        stream.forEach(s->System.out.println(s));
    }
 
    //3.利用generate方法创建无限长度流
    @Test
    public void generator3(){
        Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(100000));
        stream.limit(10).forEach(i->System.out.println(i));
    }
 
    //4.基于迭代器创建流
    @Test
    public void generator4(){
        Stream<Integer> stream = Stream.iterate(1,n->n+1);
        stream.limit(100).forEach(i->System.out.println(i));
    }
    //5.基于字符序列创建流
    @Test
    public void generator5(){
        String str = "abcdefg我的";
        IntStream stream = str.chars();
        stream.forEach(c -> System.out.println((char)c));
    }
}

stream.of()方法解析生成对应的Stream对象，需要指定泛型类型，此处为String类型 按住ctrl，点击forEach，即可看到内部的实现为Coustom

void forEach(Consumer<? super T> var1);此处s类型由泛型类型可知是String

Stream常用方法

Stream (Java Platform SE 8 ) (oracle.com)

package com.imooc.stream;
 
import org.junit.Test;
 
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class StreamMethod {
    //提取集合中所有偶数并求和
    @Test
    public void case1(){
        List<String> list = Arrays.asList("1", "2", "3", "4", "5" , "6");
        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 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 newList = list.stream().distinct()//去除重复的流数据
            .filter(n->n%2==1)
            .sorted((a,b)->b-a) //流数据排序
            .collect(Collectors.toList());
        System.out.println(newList);
 
    }
 
}