在Java 8，方法可被创建为Lambda表达式，并且可以通过引用传递（与引擎盖下一点的工作）。 有很多的例子在线与正在创建和使用方法使用lambda表达式，但不知道如何使服用lambda作为参数的方法的例子。 什么是的语法？
MyClass.method((a, b) -> a+b);
class MyClass{
//How do I define this method?
static int method(Lambda l){
return l(5, 10);
}
}
Lambda表达式是纯粹的调用点构造：拉姆达的接收方不需要知道了lambda参与，而是接受用适当的方法的接口。
换句话说，您定义或使用接受并返回正是你想要的功能接口（即具有单一方法的接口）。
对于这个Java 8附带了一组常用的接口类型java.util.function （感谢莫里斯·纳夫特尔林有关的JavaDoc的提示）。
对于这个特定的使用情况有java.util.function.IntBinaryOperator与一个int applyAsInt(int left, int right)方法 ，所以你可以写你的method是这样的：
static int method(IntBinaryOperator op){
return op.applyAsInt(5, 10);
}
但是你可以一样好定义自己的界面，并使用它像这样：
public interface TwoArgIntOperator {
public int op(int a, int b);
}
//elsewhere:
static int method(TwoArgIntOperator operator) {
return operator.op(5, 10);
}
使用自己的接口的优点是你可以有名字更清楚地表明意图。
要使用你需要创建自己的功能接口或使用Java功能的接口需要两个整数运算和返回值作为Lambda表达式。 IntBinaryOperator
使用用户定义的功能的接口
interface TwoArgInterface {
public int operation(int a, int b);
}
public class MyClass {
public static void main(String javalatte[]) {
// this is lambda expression
TwoArgInterface plusOperation = (a, b) -> a + b;
System.out.println("Sum of 10,34 : " + plusOperation.operation(10, 34));
}
}
使用Java功能接口
import java.util.function.IntBinaryOperator;
public class MyClass1 {
static void main(String javalatte[]) {
// this is lambda expression
IntBinaryOperator plusOperation = (a, b) -> a + b;
System.out.println("Sum of 10,34 : " + plusOperation.applyAsInt(10, 34));
}
}
我创建了其它的例子就是在这里
对于不具有超过2个参数的功能，你可以通过他们没有定义自己的界面。 例如，
class Klass {
static List<String> foo(Integer a, String b) { ... }
}
class MyClass{
static List<String> method(BiFunction<Integer, String, List<String>> fn){
return fn.apply(5, "FooBar");
}
}
List<String> lStr = MyClass.method((a, b) -> Klass.foo((Integer) a, (String) b));
在BiFunction<Integer, String, List<String>> ， Integer和String是它的参数，和List<String>是它的返回类型。
对于只有一个参数的函数，可以使用Function<T, R>其中T是它的参数的类型，和R是其返回值的类型。 请参阅本页面对于所有这些被Java已经提供的接口。
还有的LAMBDA启用的Java 8 JavaDoc中，从连接的公共网络访问的版本http://lambdafaq.org/lambda-resources 。 （这显然应该是对约阿希姆·绍尔的答案评论，但我不能进入我与我需要添加注释的声誉点SO帐户。）的lambdafaq网站（我维护它）回答了这个和许多其他的Java -Lambda问题。
在Java 8 GA文档成为前NB这个答案写公开可用 。 我留在原地，虽然，因为LAMBDA常见问题可能仍然是人们学习有关使用Java 8中引入的功能非常有用。
Lambda表达式可以被传递作为argument.To传递lambda表达式作为参数（其接收λ表达式作为参数）的参数的类型必须是功能性的接口类型。
如果有一个功能界面 -
interface IMyFunc {
boolean test(int num);
}
还有就是它增加了int类型列表中，只有当它大于5。注意这里过滤方法有泛函接口IMyFunc作为参数之一的过滤方法。 在这种情况下λ表达式可以作为用于该方法的参数的参数传递。
public class LambdaDemo {
public static List<Integer> filter(IMyFunc testNum, List<Integer> listItems) {
List<Integer> result = new ArrayList<Integer>();
for(Integer item: listItems) {
if(testNum.test(item)) {
result.add(item);
}
}
return result;
}
public static void main(String[] args) {
List<Integer> myList = new ArrayList<Integer>();
myList.add(1);
myList.add(4);
myList.add(6);
myList.add(7);
// calling filter method with a lambda expression
// as one of the param
Collection<Integer> values = filter(n -> n > 5, myList);
System.out.println("Filtered values " + values);
}
}
对于任何人谁是谷歌搜索这一点，一个好的方法是使用java.util.function.BiConsumer 。 例如：
Import java.util.function.Consumer
public Class Main {
public static void runLambda(BiConsumer<Integer, Integer> lambda) {
lambda.accept(102, 54)
}
public static void main(String[] args) {
runLambda((int1, int2) -> System.out.println(int1 + " + " + int2 + " = " + (int1 + int2)));
}
该outprint将是：166
对我来说，最有意义的解决方案是定义一个Callback接口：
interface Callback {
void call();
}
然后用它作为函数的参数要拨打：
void somewhereInYourCode() {
method(() -> {
// You've passed a lambda!
// method() is done, do whatever you want here.
});
}
void method(Callback callback) {
// Do what you have to do
// ...
// Don't forget to notify the caller once you're done
callback.call();
}
一个lambda不是一个特殊的接口，类或其他任何东西，你可以自己申报。 Lambda只是赋予的名称() -> {}特殊语法，这允许更好的可读性传递单方法接口作为参数时。 它被设计用来替换此：
method(new Callback() {
@Override
public void call() {
// Classic interface implementation, lot of useless boilerplate code.
// method() is done, do whatever you want here.
}
});
所以在上面的例子中， Callback是不是一个拉姆达，这只是一个普通的接口; lambda是你可以用它来实现它的快捷语法的名字。
嗯，这很容易。 lambda表达式的目的是执行功能接口。 这是一个只有一个方法的接口。 下面是有关预定义和传统功能接口awesone文章。
无论如何，如果你想实现自己的功能界面，使之。 只是简单的例子：
public interface MyFunctionalInterface {
String makeIt(String s);
}
因此，让一个班，在那里我们将创建一个方法，它接受MyFunctionalInterface的类型：
public class Main {
static void printIt(String s, MyFunctionalInterface f) {
System.out.println(f.makeIt(s));
}
public static void main(String[] args) {
}
}
你应该做的最后一件事是传递MyFunctionalInterface到我们定义的方法的实现：
public class Main {
static void printIt(String s, MyFunctionalInterface f) {
System.out.println(f.makeIt(s));
}
public static void main(String[] args) {
printIt("Java", s -> s + " is Awesome");
}
}
而已！
LAMBDA不是一个对象，而是一个功能接口。 可以定义多达功能接口，因为他们可以使用@FuntionalInterface作为注解
@FuntionalInterface
public interface SumLambdaExpression {
public int do(int a, int b);
}
public class MyClass {
public static void main(String [] args) {
SumLambdaExpression s = (a,b)->a+b;
lambdaArgFunction(s);
}
public static void lambdaArgFunction(SumLambdaExpression s) {
System.out.println("Output : "+s.do(2,5));
}
}
输出将是如下
Output : 7
lambda表达式的基本概念是定义你自己的逻辑，但已定义的参数。 所以在上面的代码中，你可以改变的除了任何其他定义DO功能的定义，但你的论点被限制为2。
请执行下列操作 ..
您已声明method(lambda l)所有你想要做的就是创建一个接口名为lambda并宣布一个抽象方法
public int add(int a,int b);
方法名称并不重要这里..
所以，当u调用MyClass.method( (a,b)->a+b)此实现(a,b)->a+b将被注入到你的界面添加方法。所以，只要你拨打l.add这是怎么回事借此实现和执行加法的a和b和return l.add(2,3)将返回5 。 - 基本上，这是拉姆达呢..
有一个在使用lambda作为参数的灵活性。 它能够在Java函数式编程。 基本语法
参数：param - > method_body
以下是一个方法，你可以定义服用功能接口（拉姆达使用）作为参数的方法。 一个。 如果你希望定义一个功能接口内声明的方法，比方说，所述功能接口被指定作为参数/参数的方法从被称为main()
@FunctionalInterface
interface FInterface{
int callMeLambda(String temp);
}
class ConcreteClass{
void funcUsesAnonymousOrLambda(FInterface fi){
System.out.println("===Executing method arg instantiated with Lambda==="));
}
public static void main(){
// calls a method having FInterface as an argument.
funcUsesAnonymousOrLambda(new FInterface() {
int callMeLambda(String temp){ //define callMeLambda(){} here..
return 0;
}
}
}
/***********Can be replaced by Lambda below*********/
funcUsesAnonymousOrLambda( (x) -> {
return 0; //(1)
}
}
FInterface FI =（X） - > {返回0; };
funcUsesAnonymousOrLambda（FI）;
这里它上面可以看出，如何lambda表达式可以与一个界面来代替。
以上介绍了lambda表达式的特定用途，还有更多。 REF 的λ内的Java 8的λ不能修改从外的λ可变
{var%20f='http://v.t.sina.com.cn/share/share.php?appkey=1515056452',u=z||d.location,p=['&url=',e(u),'&title=',e(t||d.title),'&source=',e(r),'&sourceUrl=',e(l),'&content=',c||'gb2312','&pic=',e(p||'')].join('');function%20a(){if(!window.open([f,p].join(''),'mb',['toolbar=0,status=0,resizable=1,width=440,height=430,left=',(s.width-440)/2,',top=',(s.height-430)/2].join('')))u.href=[f,p].join('');};if(/Firefox/.test(navigator.userAgent))setTimeout(a,0);else%20a();})(screen,document,encodeURIComponent,'','','https://img.manongdao.com/sparkler-677774__340.jpg', '推荐 叛逆 的文章《如何定义这需要一个lambda作为Java中8的参数的方法？(How do I define a m》','https://www.manongdao.com/article-987451.html','页面编码gb2312|utf-8默认gb2312'));){kind=link}