Lambda表达式

Lambda

• 格式：（形式参数）->{代码块}
• 形式参数：如果有多个参数，参数之间用逗号隔开；如果无参，留空即可
• ->:中画线和大于符号组成，代表指向动作
• 代码块：是我们具体要做的事情，也就是所写的方法体

抽象无参无返回值

public class EatableDemo {
    public static void main(String[] args) {
        //主方法中调用
        Eatable e = new EatableImpl();
        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("吃苹果");
            }
        });
        //Lambda表达式
        useEatable(()->{
            System.out.println("吃苹果");
        });

    }
    private static void useEatable(Eatable e){
        e.eat();

    }
}
----------------
public class EatableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("吃苹果");
    }
}
------------------
public interface Eatable {
    void eat();
}

省略规则

• 参数类型可以省略。但是有多个参数的情况下，不能只省略一个。
• 如果参数有且仅有一个，那么小括号可以省略
• 如果代码块的语句只有一条，可以省略大括号和分号、return

Lambda表达式和匿名内部类的区别

接口默认方法

接口静态方法

接口私有方法

方法引用符：::

public class AbleDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useAble(s -> System.out.println(s));

        //方法引用符
        useAble( System.out::println);
    }
    private static void useAble(Able s){
        s.abb("爱Java");
    }
}
----------------
public interface Able {
    void abb(String s);
}

引用对象的实例方法

public class PrinterDemo {
    public static void main(String[] args) {
        //主方法调用
        usePrinter(s -> System.out.println(s.toUpperCase()));
        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);

    }
    private static void usePrinter(Printer p){
        p.printUpperCase("hello tom");
    }
}
--------------------
public interface Printer {
    void printUpperCase(String s);
}
---------------
public class PrintString {
    public void printUpper(String s){
        String result = s.toUpperCase();
        System.out.println(result);
    }
}

引用构造器

Consumer接口

public class ConsumerDemo {
    public static void main(String[] args) {
        String[] strArray={"林丹，35","虞姬，25","张飞，42"};
        printInfo(strArray,str ->{String name=str.split("，")[0]; System.out.print("姓名："+name);}
        ,str ->{int age=Integer.parseInt(str.split("，")[1]); System.out.println(",年龄："+age);});

    }


    private static void printInfo(String[] strArray, Consumer<String> con1,Consumer<String> con2){
        for (String str:strArray){
            con1.andThen(con2).accept(str);
        }
    }
}
---------------
姓名：林丹,年龄：35
姓名：虞姬,年龄：25
姓名：张飞,年龄：42

predicate接口

public class PredicateDemo {
    public static void main(String[] args) {
        String[] strArray={"林丹，35","虞姬，25","张大飞，42"};
        ArrayList<String> array=myFilter(strArray,s -> s.split("，")[0].length()>2,s -> Integer.parseInt(s.split("，")[1])>33);
        for (String str:array){
            System.out.println(str);
        }
    }
    private static ArrayList<String> myFilter (String[] strArray, Predicate<String> pre1,Predicate<String> pre2){
        ArrayList<String> array = new ArrayList<>();
        for (String str:strArray){
            if (pre1.and(pre2).test(str)){
                array.add(str);
            }
        }
        return array;
    }
}
-----------------
张大飞，42

Function接口

public class FunctionDemo {
    public static void main(String[] args) {
        String s="林丹，25";
        convert(s,s1 ->s1.split("，")[1],Integer::parseInt,i ->i+70);

    }
    private static void convert(String s, Function<String,String> fun1,Function<String,Integer> fun2,Function<Integer,Integer> fun3){
        int i=fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i);
    }
}

Stream流

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("琳达");
        list.add("张大雷");
        list.add("王德发");
        list.add("张飞");
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);
    }
}

** Stream流生成方式**

常见中间操作

常见终结操作

收集操作