lamda表达式

lamda表达式是jdk1.8新特性之一java

lamda表达式的前提：有一个函数式接口。web

函数式接口定义：接口中有一个函数。ide

下面用代码作演示。svg

首先接口中的函数时无参的
原本是下面这样的：接口，接口实现类，和main方法。也就是说须要一个接口，两个类。函数

package com.yang;

public class Noargs { 
 
  

    public static void main(String[] args) { 
 
  
        Ilike like = new Like();
        like.likeLamda();
    }
}

//定义函数式接口
interface Ilike{ 
 
  
    void likeLamda();
}
//定义接口实现类
class Like implements Ilike{ 
 
  
    @Override
    public void likeLamda() { 
 
  
        System.out.println("I like Java");
    }
}

而后实现类能够用静态内部类代替，就演化成：一个接口，一个类！spa

package com.yang;

public class Noargs { 
 
  
    
    //静态内部类
    static class Like implements Ilike{ 
 
  
        @Override
        public void likeLamda() { 
 
  
            System.out.println("I like Java");
        }
    }

    public static void main(String[] args) { 
 
  
        Ilike like = new Like();
        like.likeLamda();
    }
}

//定义函数式接口
interface Ilike{ 
 
  
    void likeLamda();
}

而静态内部类还能够用局部内部类来代替。3d

package com.yang;

public class Noargs { 
 
  
    public static void main(String[] args) { 
 
  
        //局部内部类
        class Like implements Ilike{ 
 
  
            @Override
            public void likeLamda() { 
 
  
                System.out.println("I like Java");
            }
        }
        Ilike like = new Like();
        like.likeLamda();
    }
}

//定义函数式接口
interface Ilike{ 
 
  
    void likeLamda();
}

局部内部类再简化，就是匿名内部类：没有类的名称，必须借助接口或者父类。code

package com.yang;
public class Noargs { 
 
  
  public static void main(String[] args) { 
 
  
        //匿名内部类
        Ilike like = new Ilike() { 
 
  
            @Override
            public void likeLamda() { 
 
  
                System.out.println("I like Java");
            }
        };
        like.likeLamda();        
    }
}

//定义函数式接口
interface Ilike{ 
 
  
    void likeLamda();
}

再简化，就是lamda表达式了。比匿名内部类，省略了：
xml

package com.yang;
public class Noargs { 
 
  
    
    public static void main(String[] args) { 
 
  

        //lamda表达式
        Ilike like = () -> { 
 
  
            System.out.println("I like Java");
        };
        like.likeLamda();

    }
}

//定义函数式接口
interface Ilike{ 
 
  
    void likeLamda();
}

而后是有参的blog

package com.yang;

public class Args { 
 
  
    public static void main(String[] args) { 
 
  
        Ilove love = new Love();
        love.loveLamda(2);
        
    }
}

//函数式接口
interface Ilove{ 
 
  
    void loveLamda(int a);
}

//实现类
class Love implements Ilove{ 
 
  
    @Override
    public void loveLamda(int a) { 
 
  
        System.out.println("I love Java" + a);
    }
}

静态内部类：

package com.yang;

public class Args { 
 
  
    //静态内部类
    static class Love implements Ilove{ 
 
  
        @Override
        public void loveLamda(int a) { 
 
  
            System.out.println("I love Java" + a);
        }
    }
    
    public static void main(String[] args) { 
 
  
        Ilove love = new Love();
        love.loveLamda(2);

    }
}

//函数式接口
interface Ilove{ 
 
  
    void loveLamda(int a);
}

局部内部类：

package com.yang;

public class Args { 
 
  


    public static void main(String[] args) { 
 
  
        //局部内部类
        class Love implements Ilove{ 
 
  
            @Override
            public void loveLamda(int a) { 
 
  
                System.out.println("I love Java" + a);
            }
        }
        Ilove love = new Love();
        love.loveLamda(2);

    }
}

//函数式接口
interface Ilove{ 
 
  
    void loveLamda(int a);
}

匿名内部类：

package com.yang;

public class Args { 
 
  
    public static void main(String[] args) { 
 
  

        //匿名内部类
        Ilove love = new Ilove(){ 
 
  
            @Override
            public void loveLamda(int a) { 
 
  
                System.out.println("I love Java" + a);
            }
        };
    }
}

//函数式接口
interface Ilove{ 
 
  
    void loveLamda(int a);
}

lamda表达式：

package com.yang;

public class Args { 
 
    
    public static void main(String[] args) { 
 
  
        Ilove love = (int a) ->{ 
 
  
            System.out.println("I love Java" + a);
        };
        love.loveLamda(2);
    }
}

//函数式接口
interface Ilove{ 
 
  
    void loveLamda(int a);
}

还能够再简化：去掉参数类型。

package com.yang;

public class Args { 
 
  

    public static void main(String[] args) { 
 
  
       //去掉参数类型
        Ilove love = (a) ->{ 
 
  
            System.out.println("I love Java" + a);
        };
        love.loveLamda(2);
    }
}

//函数式接口
interface Ilove{ 
 
  
    void loveLamda(int a);
}

还能够去掉括号：

package com.yang;

public class Args { 
 
  

    public static void main(String[] args) { 
 
  
    	//去掉括号
        Ilove love = a ->{ 
 
  
            System.out.println("I love Java" + a);
        };
        love.loveLamda(2);
    }
}

//函数式接口
interface Ilove{ 
 
  
    void loveLamda(int a);
}

还能够去掉花括号：

package com.yang;

public class Args { 
 
  

    public static void main(String[] args) { 
 
  
		//去掉花括号
        Ilove love = a -> System.out.println("I love Java" + a);
        love.loveLamda(2);
    }
}

//函数式接口
interface Ilove{ 
 
  
    void loveLamda(int a);
}

可是要注意： 1.lamda表达式只能在只有一行代码的状况下才能简化为一行（就是去掉花括号的状况），若是有多行的话，只能用花括号。 2.前提是：接口时函数式接口 3.若是是多个参数的话，去掉参数类型时，要去掉只能都去掉，并且必需要加上括号。