.Net转Java自学之路—基础巩固篇二十（Lambda）

Lambda表达式

　　语义本身就代表了做事情的动作，没有对象的概念在其中。

　　Java中使用Lambda表达式的前提：必须有 函数式接口。

　　概念：有且只有一个的抽象方法的接口就叫函数式接口。

　　为确保当前接口为函数式接口，在定义接口的前一行加 @FunctionalInterface

　　格式：

@FunctionalInterface
public interface 函数式接口名{
    //Code...
}

　　Lambda表达式使用必须要有函数式接口的推断环境。

　　　　1、要么通过方法的参数类型类确定是那个函数式接口。

　　　　2、要么通过复制操作来确定是那个函数式接口。

　　Lambda的格式就是将抽象方法分解成为以下三点：

　　　　1、参数　　

　　　　2、箭头　　

　　　　3、代码

　　例：

public sbstract int sum(int a,int b);
//Lambda的标准格式：
(int a,int b) -> {return a+b;}
//Lambda的简化格式：
(a,b) -> a+b
//若参数有且只有一个参数，可以省略小括号。

实例：

@FunctionalInterface
public interface Calculator{
    public sbstract int sum(int a,int b);//int sum(int a,int b);
}

public class CalculatorImpl implements Calculator{
    public int sum(int a,int b){
        return a+b;
    }
}

public static void main(String[] args){
    Calculator calculator=new CalculatorImpl();
    method(calculator);
    //等于
    method((a,b) -> a+b);
}

public static void method(Calculator calculator){
    int result=calculator.sum(1,2);
    System.out.println(result);
}

　　方法引用：

　　　　防止Lambda表达式的代码冗余。

　　　　若Lambda表达式定义的动作在其他类中已经定义，那么使用方法引用来解决。

　　　　第一种：类名引用静态方法格式

　　　　　　类名::静态方法

　　　　第二种：对象名引用成员方法格式

　　　　　　对象名::成员方法名

实例：

@FuncationalInterface
pulic interface Calculator{
    void show(string str);
}

public class Test{
    public static void methodShow(String str){
        System.out.println(str);
    }
}

public static void main(String[] args){
    method(str -> System.out.println(str));
    //或者
    method(Test::methodShow);
    //或者
    Test test=new Test();
    method(test::methodShow);
    //或者
    method(System.out::println);//System.out其实就是jdk创建好的对象，println时System.out的成员方法

    /*总结:
        1、一定要有函数式接口，才能使用lambda
        2、对于重复的lambda场景，可以使用方法引用来进行简化。
    */
}

public static void method(Calculator calculator){
    calculator.show("内容");
}

实例：使用 集合for遍历冗余场景 去掉成绩不及格的成员

ArrayList<String> arr=new ArrayList<String>();
arr.add("a,90");
arr.add("ab,70");
arr.add("abc,50");

//截取
ArrayList<String> scoreList=new ArrayList<String>();
for(int i=0;i>arr.size();i++){
    String[] strList=arr.get(i);
    String score=strList[1];
    scoreList.add(score);
}

//String转int
ArrayList<Integer> numList=new ArrayList<Integer>();
for(int i=0;i<scoreList.size(); i++){y8
    int num=Integer.parseInt(scoreList.get(i));
    numList.add(num);
}

//过滤
ArrayList<String> resultList=new ArrayList<String>();
for(int i=0; i<numList.size(); i++){
    int num=numList.get(i);
    if(num>60){
        resultList.add(num);
    }
}

//打印输出
for(int i=0; i<resultList.size();i++){
    System.out.println(resultList.get(i));
}

//java8的简化stream流式操作
ArrayList<String> arr=new ArrayList<String>();
arr.add("a,90");
arr.add("ab,70");
arr.add("abc,50");

//Stream API更优写法   map映射   filter过滤  forEach遍历
arr.stream().map(s -> s.split(",")[1]).map(Integer::parseInt)
.filter(n -> n>60).forEach(System.out::println);

Stream API 流式操作

　　Java 8当中的“流”其实就是Stream接口的对象。

　　JDK提供了一个流接口，java.util.stream.Stream<T>

　　获取流的方式：

　　　　1、根据集合获取流：集合对象名称.stream();

　　　　2、分解数组获取流：Stream.of(数组名称)　　数组当中的元素必须是引用类型

//实例1
ArrayList<String> arr=new ArrayList<String>();
arr.add("a");
arr.add("ab");
arr.add("abc");

Stream<String> streamA=arr.stream();

//实例2
String[] strList={"","",""};
Stream<String> streamS=Stream.of(strList);

　　流的映射map：

　　　　获取流之后，使用映射方法：map（用于转换的Lambda表达式）

　　　　映射：就是将一个对象转换成为另一个对象，把老对象映射到新对象上。

ArrayList<String> arr=new ArrayList<String>();
arr.add("1");
arr.add("2");
arr.add("3");

Stream<Integer> streamA=arr.stream().map((String str) -> {
    int num=Integer.parseInt(str);
    return num;
});
//简化 详细步骤如下：
streamA=arr.stream().map(str -> {
    int num=Integer.parseInt(str);
    return num;
});
streamA=arr.stream().map(str -> {
    return Integer.parseInt(str);
});
streamA=arr.stream().map(Integer::parseInt);//方法引用

实例：

ArrayList<String> arr=new ArrayList<String>();
arr.add("a,90");
arr.add("ab,70");
arr.add("abc,50");

//Lambda的标准写法
Stream<String> streamA=arr.stream().map((String s) -> {
    String[] strList=s.split(",");
    String result=strList[1];
    return result;
});

//简化 步骤：
streamA=arr.stream().map(s -> {
    String[] strList=s.split(",");
    String result=strList[1];
    return result;
});
streamA=arr.stream().map(s -> {
    String[] strList=s.split(",");
    return strList[1];
});
streamA=arr.stream().map(s -> {
    return s.split(",")[1];
});
streamA=arr.stream().map(s -> s.split(",")[1]);

　　filter 过滤

　　　　filter 能产生boolean结果的Lambda；true则取，false则丢

ArrayList<String> arr=new ArrayList<String>();
arr.add(90);
arr.add(70);
arr.add(50);

Stream<Integer> streamA=arr.stream().filter((int num) -> {
    boolean b=num>60;
    return num;
});
//简化 步骤：
streamA=arr.stream().filter(num -> {
    boolean b=num>60;
    return num;
});
streamA=arr.stream().filter(num -> {
    return num>60;
});
streamA=arr.stream().filter(num -> num>60);

　　forEach 遍历

　　　　forEach(Lambda表达式);

　　　    参数Lambda表达式必须是一个能够消费的一个参数，而且不产生结果的Lambda表达式。

ArrayList<String> arr=new ArrayList<String>();
arr.add(90);
arr.add(70);
arr.add(50);

Stream<Integer> streamA=arr.stream().forEach((int i) -> {
    System.out.println(i);
});
//简化 步骤：
streamA=arr.stream().forEach(i -> {
    System.out.println(i);
});
streamA=arr.stream().forEach(i -> System.out.println(i));
streamA=arr.stream().forEach(System.out::println);

　　并发（Paralle）流

　　　　对流中的元素进行多个人同时处理，这就是并发。

ArrayList<String> arr=new ArrayList<String>();
//获取一个并发流
arr.parallelStream().........
//或  若已经获取一个普通流，那么只要再调用一下parallel()也会变成并发流
arr.stream().parallel()......