在Java 8中,新包java.util.function包含许多功能接口.该软件包的文档(http://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)对"函数形状"进行了多次引用:
我之前从未听说过"函数形状"这个术语,除了上面的文档之外,我几乎找不到它的引用,但由于这是Oracle关于函数接口的正式文档,我想了解它.
任何人都可以提供"功能形状"的定义,并发明一个例子吗？它是计算机科学中的通用术语,还是仅与Java 8相关？函数形状如何与函数描述符相关(如(T) - > Predicate <T>接口的布尔值)？
更新 Brian Goetz的以下两条评论回答了我在这篇文章中提出的问题.
我在过去几个月里一直在使用Java 8,并试图让我的头脑围绕着lambdas.我对音乐会有很多了解.但是作为lambda调用自定义功能接口执行的努力.
如果我创建java Bifuctional接口实现
BiFunction<t1,t2,R> trade = (t1, t2) -> {
// calling another method for merger
return t1,t2;
};
我可以像下面一样把它称为lambda吗？
(a, b)-> trade:
或者我是否必须创建执行方法？
private int execute(BiFunction<t1,t2,R> trade, int a, int b){
return trade.apply(a, b)
}
以下是调用lambda的代码示例:
BiFunction<t1,t2,R> trade = (t1, t2) -> {
// calling another method for merger return t1+t2;
};
public static void main(String[] args) {
execute(trade , 1, 2);
}
private int execute(BiFunction<t1,t2,R> trade, int a, int b) {
return trade.apply(a, b);
}
我很好奇为什么编译器无法理解这一点
public …Lambda Java 8中有趣的编译错误(Oracle JDK)
java -version
java version "1.8.0_45"
Java(TM) SE Runtime Environment (build 1.8.0_45-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.45-b02, mixed mode)
我有一个方法调用:
new CSVFile()
.of(new FileInputStream("MyFile.csv"))
.withColumnMapping("name", "fullName", s -> s.toUpperCase())
.withColumnMapping("gender", "gender", s -> s.toUpperCase());
这是我试图调用的方法:
public CSVFile withColumnMapping(final String columnName, final String beanPropertyName, final Function<String, Object> columnTransformFunction) {
columnMappings.add(new ColumnMapping(columnName, beanPropertyName, Optional.of(columnTransformFunction)));
return this;
}
我得到的编译错误是:
[ERROR] /Users/sai/fun/reactivecsv/src/test/java/reactivecsv/CSVFileTest.java:[26,50] cannot find symbol
[ERROR] symbol: method toUpperCase()
[ERROR] location: variable s of type java.lang.Object
奇怪的是,这编译
Function<String, Object> …我工作的项目最近已从Java 7切换到Java 8.我希望能够找到具有单个抽象方法的接口作为将功能接口引入我们的代码库的候选者.(将现有接口注释为@FunctionalInterface,从接口扩展它们java.util.function,或者可能只是替换它们).
为什么方法中的累加器参数是Stream::reducea BiFunction而不是BinaryOperator像combiner参数一样.
为什么是它的类型 BiFunction<U, ? super T, U>？为什么T？应该是BiFunction<U, ? extends U, U>吗？
请考虑这个例子:
import java.util.function.Consumer;
public class Example {
public static void main(String[] args) {
Example example = new Example();
example.setConsumer(test -> System.out.println("passed string is " + test)); //uses MyConsumer, why ?
example.getConsumer().accept("Test 1");
example.setConsumer((MyConsumer<String>)test -> System.out.println("passed string is " + test)); //uses MyConsumer
example.getConsumer().accept("Test 2");
example.setConsumer((Consumer<String>)test -> System.out.println("passed string is " + test)); //uses Consumer
example.getConsumer().accept("Test 3");
}
private Consumer<String> consumer;
public Consumer<String> getConsumer() {
return consumer;
}
public void setConsumer(Consumer<String> consumer) {
this.consumer = consumer;
}
public void setConsumer(MyConsumer<String> consumer) …Ambiguous error当我尝试使用包含带有功能参数的重载方法的代码时,我得到了.
我写了一个小片段,显示了一个模棱两可的行为:
import java.util.function.BiConsumer
import java.util.function.Consumer
class Test {
static void main(String... args) {
execute({ x -> println("Consumer") })
execute({ x, y -> println("BiConsumer") })
}
static void execute(Consumer<Integer> c) {
c.accept(100)
}
static void execute(BiConsumer<Integer, Integer> c) {
c.accept(1, 2)
}
}
输出(2.4.9 groovy):
Exception in thread "main" groovy.lang.GroovyRuntimeException: Ambiguous method overloading for method Test#execute.
Cannot resolve which method to invoke for [class Test$_main_closure1] due to overlapping prototypes between:
[interface java.util.function.BiConsumer]
[interface java.util.function.Consumer]
at groovy.lang.MetaClassImpl.chooseMostSpecificParams(MetaClassImpl.java:3268)
at groovy.lang.MetaClassImpl.chooseMethodInternal(MetaClassImpl.java:3221) …我基本上试图创建一个静态方法,它将作为我传递的任何方法的包装器,并将在方法本身的实际执行之前和之后执行某些操作.我更喜欢使用Java 8新的编码风格.到目前为止,我有一个具有静态方法的类,但我不确定参数类型应该是什么,因此它可以采用任何类型的参数的任何方法,然后执行它.就像我提到的,我希望在方法执行之前和之后做一些事情.
例如:executeAndProcess(anyMethod(anyParam));
我是Java 8的新手,我正试图解决为什么最后一次测试是错误的.
@Test
public void predicateTest() {
Predicate<Boolean> test1 = p -> 1 == 1;
Predicate<Boolean> test2 = p -> p == (1==1);
System.out.println("test1 - true: "+test1.test(true));
System.out.println("test1 - false: "+test1.test(false));
System.out.println("test2 - true: "+test2.test(true));
System.out.println("test2 - false: "+test2.test(false));
}
输出:
test1 - true:true
test1 - false:true
test2 - true:true
test2 - false:false
使用lambda表达式编写了java8程序,它没有被执行而是在lambda表达式中被终止,没有例外
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
public class BiConsumerTest {
public static void main(String[] args) {
try{
List<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");
list1.add("V");
List<String> list2 = new ArrayList<String>();
list2.add("J");
list2.add("G");
list2.add("P");
BiConsumer<List<String> , List<String>> bc = (lista, listb) ->{
lista.stream().forEach( System.out::print);
};
}catch(Exception ex){
ex.printStackTrace();
}
}
}
预计会在列表中打印字符串