lambda，接口组成,函数式接口,方法引用学习集合

lambda的注意事项
lambda必须要有接口，接口 有且仅有一个抽象方法

//参数的类型可以省略，但是有多个参数情况下，不能只省略一个。
//如果只有一个参数可以省略小括号
        useeat(S->{
            System.out.println(S);
        });
        //如果代码块语句只有一条，可以省略大括号和分号
        useeat(S-> System.out.println(S));

        useadd((a, b) -> {return a+b;});
//如果有return，return也要省略
        useadd((a,b) ->a+b);

  // new Thread(new test()).start();

        //必须要有上下文环境，程序才能推到出lambda
        //根据调用方法对应的参数得知对应的接口
        new Thread(()->{
            System.out.println("lambda1启动");
        }).start();
     //   ()->{ System.out.println("lambda1启动"); }
        //根据调用方法的参数得知对应的接口
    Runnable a=    ()-> System.out.println("lambda1启动");
    new Thread(a);

lambda和匿名内部类的区别
1.匿名内部类会产生单独的class文件
2.匿名内部类实现的接口里面可以有多个方法
3.匿名内部类可以声名抽象类的对象

接口组成
常量：public static final
抽象方法: public void xx();
默认方法java8

  public  default void show3(){
        System.out.println("show3");
    };

public 可以省略 default不可以省略，子类可以选择是否重写，重写去掉default关键字

静态方法java8

    public  static void show4(){
        System.out.println("show4");
    };

私有方法java9

  private static void show5(){
        System.out.println("show5");
    };

引用类方法就是引用类的静态方法

   static  void useconvert(printable printable){
     int a= printable.convert("1");
       System.out.println(a);
   }
main:
  useconvert(Integer::parseInt);

引用对象的实例方法就是引用类的成员方法

      printdemo printdemo=new printdemo1();
        usedemo(printdemo::printupper);
    ------------------------
   static void usedemo(printdemo printdemo){
        printdemo.printupper("aaaa");
    }

引用类的实例方法就是引用类的成员方法

     usemystring(String::substring);

   static void usemystring(mystring mystring){
       System.out.println(mystring.mysub("AAAAAAAAAA",2,5)) ;

//lambda表达式被类的实例方法替代的时候
//第一个参数作为调用者
//后面的参数全部传递给该方法作为参数

usebuilder(student::new);
 static void usebuilder(studentbuilder studentbuilder){
     student s=       studentbuilder.build("aaa",11);
      System.out.println(s.getAge());
      System.out.println(s.getName());
    }

//lambda表达式被构造器替代的时候，他的形式参数全部传递给构造器作为参数

函数式接口
接口中有且仅有一个抽象方法
@FunctionInterface 声名函数式接口
如果方法的参数是一个函数式接口，那么可以使用lambda表达式作为这个方法得参数

常见得函数式接口有Supplier Consumer,Predicate,Function

stream流的生成方式

生成流 通过数据源生成流 list.stream

中间操作 一个流后面可以跟零个或多个中间操作，其目的是打开流，做出某种程度的过滤和映射，然后返回一个新的流，交给下一个操作使用
filter（）
终结操作，一个流只能有一个终结操作，当这个操作执行后流就无法再被使用 foreach（）

stream流的常见生成方式

Collection体系可以使用默认的方法stream生成流，

default Stream<E> stream()

Map 集合间接生成流

数组可以通过Stream接口的静态方法of（T…values）生成流

  List<String> list=new ArrayList<>();
        Stream<String> stream = list.stream();
        Set<String> set=new HashSet<String>();
        Stream<String> stream1 = set.stream();

        Map<String,String> map=new HashMap<>();
        Stream<String> stream2 = map.keySet().stream();
        Stream<String> stream3 = map.values().stream();

        String[] arr={"aaa","bbb"};
        Stream<String> arr1 = Stream.of(arr);
        Stream<String> stream4 = Stream.of("ccc", "dddd");
        Stream<Integer> stream5 = Stream.of(10, 11, 22);

静态方法引用　　　　　　　：　 　ClassName :: staticMethodName
构造器引用　　　　　　　　：　 　ClassName :: new
类的任意对象的实例方法引用：　 　ClassName :: instanceMethodName
特定对象的实例方法引用　　：　 　object :: instanceMethodName