小编Adr*_*r83的帖子

我写这段代码,但我不知道为什么编译.

UnaryOperator接受特定类型参数,并返回与其参数类型相同的结果.

我的问题:如果我把一个if-statement返回null,是不是有编译器错误？

null 不是它的论点的类型(在我的例子中是Doll)？

内置的功能接口(如Consumer,UnaryOperator,Function)是否可以返回null而不是标准返回值？

这是我的代码:

import java.util.function.*;

public class Doll {

    private int layer;

    public Doll(int layer) {
        super();
        this.layer = layer;
    }

    public static void open(UnaryOperator<Doll> task, Doll doll) {
        while ((doll = task.apply(doll)) != null) {
            System.out.println("X");
        }
    }

    public static void main(String[] args) {
        open(s -> {
            if (s.layer <= 0)
                return null;
            else
                return new Doll(s.layer--);
        }, new Doll(5));
    }
}

非常感谢!

在界面Stream中:

中间操作可分为有状态和无状态.它们会影响并行Stream的结果.

只有两个终端操作是非确定性方法:findAny()和forEach(Consumer).它们会影响并行Stream的结果.

中间操作可分类为:

有状态

• 不同()
• 排序()
• 限制(长l)
• 跳过(长l)

无状态

• 地图(功能f)
• flatMap(功能f)
• 过滤器(谓词p)
• 偷看(消费者c)

这是我的两个问题:

1. 如果我在并行流上调用无状态中间方法,我将获得顺序流的相同结果,但顺序不同.如果我在并行流上调用有状态中间方法,我将获得顺序流的相同结果.这些规则是基本的,但这些规则如何在存在非确定性终端方法的情况下发生变化？并存在副作用(对于无状态方法)？

2. Stream元素的顺序是"遇到顺序",除非我调用BaseStream方法:unordered().元素的顺序是否会影响流的结果(存在有状态或无状态方法)？如果有,怎么样？

非常感谢!

一个.

这是我的第一个代码:

public class MethodReference {
    public static void main (String []args) {
        Stream<String> s = Stream.of("brown bear", "grizzly");
        s.sorted(Comparator.reverseOrder()).forEach(System.out::print);
        //...
    }
}

结果:灰熊熊

这是我的第二个代码:

public class MethodReference {
    public static void main (String []args) {
        Stream<String> s = Stream.of("brown bear", "grizzly");
        s.sorted(Comparator::reverseOrder()).forEach(System.out::print);
        //...
    }
}

结果:编译器错误

我的问题:为什么第二个代码中存在编译器错误？我不能将方法参考用于功能接口的静态方法吗？

我知道我不能使用方法引用和函数接口的默认方法.我知道我可以在5种情况下使用类的方法引用:

类

• 类:: STATICMETHOD

• 类:: instanceMethod

• 例如:: instanceMethod

• 类::新

功能界面

• 接口:: abstractMethod

非常感谢!

我知道要实例化一个成员内部类,你有两个不同的构造函数:

第一:

Outer out = new Outer();
Outer.Inner in = out.new Inner();

第二:

Outer.Inner in = new Outer().new Inner();

现在,我不知道为什么这段代码会编译:

public class Outer {

    private String greeting="Hi";

    protected class Inner {
        public int repeat=3;

        public void go() {
            for (int i =0; i<repeat; i++) {
                System.out.println(greeting);
            }
        }
    }

    public void callInner() {
        Inner in = new Inner(); //in my opinion the correct constructor is Outer.Inner in = new Inner()
        in.go();
    }

    public static void main(String[] args) {
        Outer out …