Lambda表达式和Stream流使用规则和方法

Lambda表达式：

我们可以把Lambda表达式理解为一段可以传递的代码（将代码像数据一样进行传递）。按照顺序把数据进行操作。
作用：
使代码变得简洁、更加灵活，操作方便
缺点：
如果让别人来看的话，可能不容易看懂，就是可读性不高。
非并行计算情况下，其计算速度没有比传统的 for 循环快。
不容易调试。
Lambda使用需要一个接口并且接口中有且仅有一个方法。（形式参数）->{代码块}
'->'左侧：指定了Lambda表达式需要的所有参数
参数的类型可以省略，省略的话，要么全部省略，要么一个都不省略。如果参数只有一个，那么（）可以省略。
'->‘右侧：制定了Lambda体，即Lambda表达式要执行的功能。
如果函数体就一条语句，’{}‘和’;'可以省略，如果是return 语句不可以省略或者把return也省略了。
下面有一个例子（是我自己写的，里面的注释只是我自己的理解，所以我也不知道准确不准确，但是有助于理解，后面带的有个这个运作的顺序，如果有不对的希望大家指出来）：

package ti;

    interface Eatable{
        void eat();
    }
    interface Flyable{
        void fly(String s);
    }
    interface Addable{
        int Add(int a,int b);
    }
public class Ti31 {
    public static void main(String[] args) {
        useEatable(new Eatable() {//这个new出来的接口是一个匿名内部类，重写了Eatable接口中的eat方法
            @Override
            public void eat() {
                System.out.println("多吃饭");
            }
        });
        useEatable(()->{//这个就相当于重写了Eatable中的eat方法 () 里面的是参数，因为在接口中并不存在参数，所以这个里面就没有写参数  
            System.out.println("多吃饭");
        });
        //调用下面的方法，然后方法需要一个接口的对象，然后咱们就需要一个接口的实现类，所以下面的new出来的就相当于咱们写出了这个实现类，然后传给这个方法，然后被方法调用
        useFlyable(new Flyable() {//这个的解释就和上面的类似了，就是相当于一个重写Flyable接口的实现类
            @Override
            public void fly(String s) {
                System.out.println(s);
            }
        });
        useFlyable((String s)->{//()中的是接口中的方法的参数，这个解释和上面的差不多，暂且可以理解为写出了一个实现类，然后再调用
            System.out.println(s);
        });
        useFlyable(s->System.out.println(s));
        useAddable(new Addable() {
            public int Add(int a, int b) {
                return a+b;
            }
        });
        useAddable((int x,int y)->{
            return x+y;
        });
        useAddable((x,y)->{return x+y;});
        useAddable((x,y)->x+y);
    }
    public static void useEatable(Eatable e){
        e.eat();
    }
    public static void useFlyable(Flyable f){
        f.fly("且看落叶飘零");
    }
}

运行顺序：

在线程中：

package ti;

public class Ti32 {
    public static void main(String[] args) {
        new Thread(()-> System.out.println("线程启动")).start();
    }
}

Thread方法需要一个Runnable接口的对象，Runnable中只有一个无返回值的run方法，所以说可以直接使用

Stream流的获取

package text1;


import java.util.*;
import java.util.stream.Stream;
/*
1.Collection体系的集合可以使用默认的stream()生成流
2.map体系的集合间接的生成流（使用键的set集合生成流，值的Collection集合生成流，键值对set集合生成流）
3.数组可以通过Stream接口的静态方法of(T...values)生成流
 */
public class Test35 {
    public static void main(String[] args){
        //Collection体系的集合可以使用默认的stream()生成流
        List<String> list=new ArrayList<String>();//创建集合对象
        Stream<String> listStream = list.stream();//集合对象使用stream()方法生成流
        //2.map体系的集合间接的生成流（使用键的set集合生成流，值的Collection集合生成流，键值对set集合生成流）
        Map<String,Integer> map=new HashMap<String, Integer>();//创建map集合对象
        Stream<String> mapStream1 = map.keySet().stream();//键的set集合生成流
        Stream<Integer> maStream2 = map.values().stream();//值的Collection集合生成流
        Stream<Map.Entry<String, Integer>> entrysetstream = map.entrySet().stream();//键值对set集合生成流
        //3.数组可以通过Stream接口的静态方法of(T...values)(可变参数)生成流
        String[] str={"hello","world","java"};
        Stream<String> str1 = Stream.of(str);
        Stream<String> str2 = Stream.of("hello", "world", "java");//可变参数可以直接传任意数量的值
    }
    //例子：（这个最主要的记忆和理解方法还是要我们自己多练习）
    String[] arr={"1","2","3","4","5","6","7","8","9"};
        Stream<String> a1= Stream.of(arr);
        a1.filter(s->Integer.parseInt(s)>=5).forEach(System.out::println);
 }