作为一名学习Java的非Java程序员,我正在阅读Supplier和Consumer接口.我无法围绕他们的用法和意义.您何时以及为何使用这些界面？有人可以给我一个简单的非专业人士的例子......我发现Doc的例子不够简洁,我的理解.
我认为这个问题已经存在,但我无法找到它.
我不明白,为什么有必要使用功能界面来处理lambdas.请考虑以下示例:
public class Test {
public static void main(String...args) {
TestInterface i = () -> System.out.println("Hans");
// i = (String a) -> System.out.println(a);
i.hans();
// i.hans("Hello");
}
}
public interface TestInterface {
public void hans();
// public void hans(String a);
}
这没有问题,但如果您取消注释注释行,它不会.为什么？在我的理解中,编译器应该能够区分这两种方法,因为它们具有不同的输入参数.为什么我需要一个功能界面并炸毁我的代码？
编辑:链接重复项没有回答我的问题,因为我问的是不同的方法参数.但是我在这里得到了一些非常有用的答案,感谢所有帮助过的人!:)
编辑2:对不起,我显然不是母语人士,但为了准确自己:
public interface TestInterface {
public void hans(); //has no input parameters</br>
public void hans(String a); //has 1 input parameter, type String</br>
public void hans(String a, int b); //has 2 input parameters, 1. type = String, …如果我们的接口中只有一个抽象方法，那么默认情况下它是函数式接口。任何人都可以解释@FunctionalInterface 注释带来的额外优势吗？
我知道如果我们添加@FunctionalAnnotation，它不会允许有人在接口中添加另一个抽象方法，因为它会给出编译错误，但我的意思是即使你不使用@FucntionalInterface注解，那么还有，如果有人会添加另一个抽象方法，它会破坏代码中所有现有的 lambda 表达式，编译器会抱怨。
例如：
如果我有以下界面：
public interface User {
Integer fetchData(Integer userId);
}
具有以下实现：
public class UserImpl implements User{
@Override
public Integer fetchData(Integer userId) {
return 1;
}
}
和以下用法：
公共类 TestFunctionalInterface {
public static void main(String[] args) {
User user = a -> a*2;
System.out.println("FetchedData:"+user.fetchData(2));
}
}
现在，如果我尝试在界面中添加另一个方法，如下所示：
public interface User {
Integer fetchData(Integer userId);
Integer fetchLoginDetails(Integer userId);
}
编译器在下面的代码中抱怨：
public class TestFunctionalInterface {
public static void main(String[] args) {
User user = a -> a*2;
System.out.println("FetchedData:"+user.fetchData(2)); …在" OCP学习指南 "一书中,有一个关于可以用两种方式初始化的比较器的示例.第一个是通过这样的匿名类:
Comparator<Duck> byWeight = new Comparator<Duck>(){
public int compare(Duck d1, Duck d2){
return d1.getWeight() - d2.getWeight();
}
};
这个我能理解.根据这本书,这可以用这样的lambda表达式替换:
Comparator<Duck> byWeight = (d1,d2) -> d1.getWeight() - d2.getWeight();
现在这个我不明白.lambda表达式不返回Comparator对象,由于Comparator是一个接口,因此我现在无法想到它.
那么new第一个例子中的运算符是否引用了正在创建的匿名类,它被称为Comparator,因为匿名类实现了Comparator接口？
那么在例2中到底发生了什么？是否以lambda表达式创建了某个对象？在这个例子中,你byWeight用作参考变量吧？
我真的不明白这一点,有人可以解释一下吗？谢谢.
关于Java8 内置功能接口,我遇到过很多问题,包括this,this,this和this.但所有人都在问"为什么只有一种方法？" 或"如果我使用我的功能界面执行X,为什么会出现编译错误"等等.我的问题是:当我在自己的界面中使用lambda时,这些新功能接口的存在目的是什么？
请考虑以下来自oracle文档的示例代码:
// Approach 6: print using a predicate
public static void printPersonsWithPredicate(List<Person> roster,
Predicate<Person> tester) {
for (Person p : roster) {
if (tester.test(p)) {
System.out.println(p);
}
}
}
好的,很好,但这可以用上面的自己的例子来实现(一个单一方法的接口并不新鲜):
// Approach 5:
public static void printPersons(<Person> roster,
CheckPerson tester) {
for (Person p : roster) {
if (tester.test(p)) {
System.out.println(p);
}
}
}
interface CheckPerson {
boolean test(Person p);
}
我可以将lambda传递给两个方法. …
我遇到过这种设计，但我没有完全掌握在 Java 8 中混合面向对象编程和函数式编程。
我对混合两种语言范式很感兴趣，而且互联网上的大多数教程都很简单，所以我无法通过混合来找到有关大规模软件设计的示例。所以有了这个示例案例，我想我有机会挖掘它的某些案例。
在这种情况下，让我展示代码的相关部分。这段代码包含一个通用的 FetchUtils 类，它实现了一个自定义迭代器，但为了简洁起见，我删除了一些部分。
public class FetchUtils<R, MSGIN, MSGOUT> {
public SomeClass<R> getSomething(MSGIN query,
Function<MSGIN, MSGOUT> queryFunc,
Function<MSGOUT, List<R>> getResultList) {
//...
MSGOUT callResult = queryFunc.apply(query);
buffer = getResultList.apply(callResult);
//...
//return someThing;
}
//...
}
在客户端中定义了一个函数和一个指向getCustomer类方法引用的 lambda 表达式。从客户端到使用泛型类型的上述方法的实际调用正在发送这些功能。
public class CustomerResponse {
//...
public List<Customer> getCustomer() {
if (thing == null) {
thing = new ArrayList<Customer>();
}
return this.customers;
}
//...
}
public class MyClient {
//...
@Autowired
private FetchUtils<Customer, CustomerRequest, CustomerResponse> fetchUtils;
//... …我正在尝试学习Lambda表达式,
interface MathOperartor 我已经确定使用Lambda表达式可以做到的操作()重载了,我确实可以使用Lambda表达式,但似乎无法弄清楚这里的问题是什么:
public static void main(String[] args) {
LambdaLearning lb = new LambdaLearning();
MathOperartor add = (a , b )-> a + b; // error: The target type of this expression must be a functional interface
MathOperartor sub = (a , b) -> a - b; // same error
MathOperartor mul = (a , b) -> a * b; // ''
MathOperartor div = (a , b) -> a / b; // ''
System.out.println(lb.operate(10, 15, add));
System.out.println(lb.operate(10.5f, 15.5f, …Java 中的 lambda 表达式对象如何？作为函数式编程一部分的lambda表达式如何在Java这种面向对象的语言中实现呢？要理解 lambda 表达式，我需要哪些 Java 概念？
我写了一个线性搜索实现.我也使用Java 7和8编写了代码.
以下是我的代码:
int[] arr = new int[] { 12, 34, 94, 8, 37, 10 };
System.out.println("Enter the element to search: ");
Scanner scan = new Scanner(System.in);
int element = scan.nextInt();
boolean found = false;
// Linear search implementation using Java 7 features
for (int i = 0; i < arr.length; i++) {
if (element == arr[i]) {
int n = element;
System.out.println("Element : "+n+" has been found at the index : "+i);
found = true;
break;
}
}
// …我正在测试java的lambda是否与接口函数匹配，我在下面编写了代码，它可以工作。我有界面MyHandler，及其myFunction。在构造时，Java lambda 被转换为我的接口的实现者。
package mygroup;
interface MyHandler{
void myFunction(int i);
}
class Worker{
private final MyHandler handler;
public Worker(MyHandler h){
handler = h;
}
public void work(int i){handler.myFunction(i);};
}
public class TestLambda {
public static void main(String[] args) {
Worker worker = new Worker(i -> System.out.println(i));
worker.work(3);
}
}
程序将打印3. 到目前为止一切顺利，但如果我添加一些其他函数声明，MyHandler如下所示：
interface MyHandler{
void myFunction(int i);
void f(int i, int j);
}
Thread 构造函数中的 lambda 将无法编译，表示
The constructor Worker((<no type> i) -> …在浏览功能接口时，我无法理解它们与使用单一方法的其他接口有何不同，例如 Runnable。
我们可以在尝试使用其他 Functional 接口时使用 Runnable。在 Java 8 之前，我们已经可以为单个功能创建接口和匿名对象。
例如：
@FunctionalInterface
public interface ITrade {
public boolean check(Trade t);
}
这与以下有何不同：
public interface ITrade {
public boolean check(Trade t);
}
java ×10
java-8 ×9
lambda ×5
comparator ×1
function ×1
generics ×1
interface ×1
java-stream ×1
types ×1