标签: functional-interface

我不确定如何确定功能接口的相等/不变性.我想在java 8中使用这个语法糖时可能无法保证平等,如果你有任何提示,请告诉我任何提示.

我为我的问题制作了一个简短的代码片段.

public interface Element {
    void doSomething(int a);
}

我试图以功能方式添加此接口的实例

public class FunctionSet {

    public void doubleUp(int a) {
        System.out.println(a*2);
    }

    public void square(int a) {
        System.out.println(a*a);
    }

    public static void main(String[] args) {
        HashSet<Element> set = new HashSet<>();
        FunctionSet functionSet = new FunctionSet();

        set.add(functionSet::doubleUp);
        set.add(functionSet::square);

        System.out.println(set.add(functionSet::doubleUp));
    }

}

它打印为true,这意味着没有任何相等检查,并且我添加它后也无法从Set中删除任何实例.

如果我使用功能接口作为参数,有什么方法可以以某种方式比较这些实例？

将提供任何帮助,谢谢!

public interface MyFunc<T> {

    boolean func(T v1, T v2);

}

public class HighTemp {

    private int hTemp;

    HighTemp(){

    }
    public HighTemp(int ht) {
        this.hTemp = ht;
    }

    boolean sameTemp(HighTemp ht2){
         return hTemp == ht2.hTemp;
    }

     boolean lessThanTemp(HighTemp ht2){
        return hTemp < ht2.hTemp;
    }
}

class InstMethWithObjRef {

    static <T> int counter(T[] vals, MyFunc<T> f, T v){
        int count = 0;

        for (int i = 0; i < vals.length; i++) {
            if(f.func(vals[i], v)) count++;
        }
        return count;
    }
    public static void …

在Java8的Function.class中,我们有:

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));
}

撰写接受:

Function<? super V, ? extends T> before

而不是:

Function<V, ? extends T> before

是否有任何合理的情况,其中"V"是有限的事实？

我正在使用Java11.学习一种新的方法Predicate.not,我发现我目前的代码只找到猫科:

List<String> animals = List.of("cat", "leopard", "dog", "lion", "horse");
Predicate<String> cats = a -> !a.equals("dog") && !a.equals("horse");
Set<String> filterCat = animals.stream().filter(cats).collect(Collectors.toSet());
System.out.println(filterCat);

输出是:

豹,猫,狮子

现在我正在尝试使用新方法,输出结果不正确.我该如何纠正？我做错了什么？

我后来的代码:

Predicate<String> updatedCatFilter = Predicate.not(a -> a.equals("dog") && a.equals("horse"));
Set<String> catFamily = animals.stream().filter(updatedCatFilter).collect(Collectors.toSet());
System.out.println(filterCat);

但是现在输出我的所有列表.

马,豹,猫,狗,狮子

我有Java enum:

public enum ConflictResolutionStrategy {
    softResolve,
    hardResolve,
}

我想称之为ConflictResolutionStrategy.hardResolve.apply(case1, case2).

两者case1和case2相同类型的对象.apply在我的情况下应该什么也不返回

这个设计背后的基本思想.Strategy根据设定enum值创建设计模式并解决冲突.

我在StackOveflow上找不到任何类似的问题,即使简单的搜索也给了我很多类似的案例,这些案例并没有直接解决我的问题.

我尝试了以下内容:

public enum ConflictResolutionStrategy {
    softResolve ((CaseType case1, CaseType case2) -> case1.update(case2)),
    hardResolve,
}

上面的这个版本不编译.

我试过另一个解决方案

public enum ConflictResolutionStrategy {
    softResolve,
    hardResolve {
        public void apply(CaseType case1, CaseType case2) {
            case1.update(case2);
        }
    },
}

第二种解决方案,运行正常但需要太多代码.

我在Eclipse中开发了一些代码，对其进行了成功的测试，将其推送到我们的Jenkins CI服务器上，并收到了一封电子邮件，指出Maven由于Java编译错误而感到窒息。随后，我隔离了该问题，并创建了以下显示该问题的最小示例：

import java.util.List;
import java.util.function.Function;

class MinimalTypeFailureExample {
    public static void main(String[] args) {
        List<String> originalList = null;  // irrelevant
        List<IntToByteFunction> resultList = transform(originalList,
                outer -> inner -> doStuff(inner, outer));
        System.out.println(resultList);
    }

    static <F, T> List<T> transform(List<F> originalList,
            MyFunction<? super F, ? extends T> function) {
        return null;  // irrelevant
    }

    static Byte doStuff(Integer inner, String outer) {
        return null;  // irrelevant
    }
}

@FunctionalInterface
interface MyFunction<F, T> extends Function<F, T> {
    @Override
    T apply(F input);
}

@FunctionalInterface
interface …

是否有针对消费者的内置或强大的第三方抽象在Java 8+中返回了价值？

PS对于延迟执行，它也可能返回Future。

更新。 函数接口在语法上有完美的匹配，但是在语义方面存在一些考虑。在这种情况下使用Function显然会破坏不更改外部状态的合同。怎么处理呢？

例如,

List<Product> productsList = new ArrayList<Product>();  
productsList.add(new Product(1,"HP Laptop",25000f));  
productsList.add(new Product(2,"Dell Laptop",30000f));  
productsList.add(new Product(3,"Lenevo Laptop",28000f));  
productsList.add(new Product(4,"Sony Laptop",28000f));  
productsList.add(new Product(5,"Apple Laptop",90000f));  

Float totalPrice = productsList.stream()  
                               .map(product->product.price)  
                               .reduce(0.0f,(sum, price)->sum+price);   
System.out.println(totalPrice); 

这是哪个功能界面,(sum, price)->sum+price是指？

我有两种生产“消费者”的工厂方法使用不同的方法 lambda 和方法引用：

@SuppressWarnings("Convert2MethodRef")
public Consumer<String> lambdaPrintStringConsumer(){
    return x -> System.out.println(x);
}

public Consumer<String> methodRefPrintStringConsumer(){
    return System.out::println;
}

我发现在第一种情况 ( lambdaPrintStringConsumer()) 中，方法返回对同一对象的引用

@Test
public void shouldSameFromFactoryMethod_lambda() {
    Consumer<String> consumerA = lambdaPrintStringConsumer();
    Consumer<String> consumerB = lambdaPrintStringConsumer();
    
    Assert.assertSame(consumerA, consumerB);//consumerA == consumerB --> true
}

但是在第二个 ( methodRefPrintStringConsumer()) 中，对象是不同的

@Test
public void shouldNotSameFromFactoryMethod_methodRef() {
    Consumer<String> consumerA = methodRefPrintStringConsumer();
    Consumer<String> consumerB = methodRefPrintStringConsumer();

    Assert.assertNotSame(consumerA, consumerB);//consumerA == consumerB --> false
}

直接方法返回与以下相同的结果shouldNotSameFromFactoryMethod_methodRef()：

@SuppressWarnings("Convert2MethodRef")
@Test
public void shouldNotSameFromLambda() {
    Consumer<String> …

此功能即将推出Kotlin 1.4。这是摘录自KotlinConf'19.

fun interface Action {
    fun run()
}

fun runAction(a: Action) = a.run()

runAction{
    println("Hello")
}

看起来不错，但我仍然不知道它有什么作用。

什么是函数接口？它的实用价值是什么？它可以用于哪些具体场景？