小编ski*_*iwi的帖子

在Java 8中,这适用于:

Stream<Class> stream = Stream.of(ArrayList.class);
HashMap<Class, List<Class>> map = (HashMap)stream.collect(Collectors.groupingBy(Class::getSuperclass));

但这不是:

Stream<Class> stream = Stream.of(List.class);
HashMap<Class, List<Class>> map = (HashMap)stream.collect(Collectors.groupingBy(Class::getSuperclass));

Maps允许null键,List.class.getSuperclass()返回null.但Collectors.grouping可以在Collectors.java第907行发出NPE:

K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key"); 

如果我创建自己的收集器,它的工作原理改为:

K key = classifier.apply(t);  

我的问题是:

1)Collectors的Javadoc.GroupingBy并没有说它不应该映射一个空键.出于某种原因这种行为是否必要？

2)是否有另一种更简单的方法来接受一个空键,而不必创建我自己的收集器？

正如你们许多人所知,有一个经典的Operation枚举示例(现在使用Java 8标准接口),如下所示:

enum Operation implements DoubleBinaryOperator {
    PLUS("+") {
        @Override
        public double applyAsDouble(final double left, final double right) {
            return left + right;
        }
    },
    MINUS("-") {
        @Override
        public double applyAsDouble(final double left, final double right) {
            return left - right;
        }
    },
    MULTIPLY("*") {
        @Override
        public double applyAsDouble(final double left, final double right) {
            return left * right;
        }
    },
    DIVIDE("/") {
        @Override
        public double applyAsDouble(final double left, final double right) {
            return left / right;
        } …

我想了一下并提出了一个有趣的问题,假设我们有一个配置(输入)文件:

x -> x + 1
x -> x * 2
x -> x * x
x -> -x

此外,我们有一个Integers 列表:

List<Integer> list = new ArrayList<>();
list.addAll(Arrays.toList(1, 2, 3, 4, 5));

有没有办法将Strings(x -> x + 1等)转换为Object代表lambda表达式的s？然后可以用作:

Object lambda = getLambdaFromString("x -> x + 1");
if (lambda.getClass().equals(IntFunction.class) {
    list.stream().forEach()
        .mapToInt(x -> x)
        .map(x -> ((IntFunction)lambda).applyAsInt(x))
        .forEach(System.out::println);
}

我怎么写这样的方法getLambdaFromString？

• 我可以从JDK/JRE中重用一些东西吗？
• 我需要自己写这些吗？
• 是否有可能缩小Object lambda到仅捕获lambda的其他东西？

有没有更好的方法来计算Java8的出现次数

int[] monthCounter = new int[12];
persons.stream().forEach(person -> monthCounter[person.getBirthday().getMonthValue() - 1]++);

学习Java 8 Lambdas,只是想知道编译器如何知道Comparator中哪个方法用于lambda表达式？它似乎不是SAM接口？它有2个抽象方法:

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

我一直使用类似的界面通过collection.sort为我的班级提供自然顺序.

基本上如果我有一个人类,我会得到它来实现Comparable接口,并将提供compareTo的实现.但是在javadocs中Collections.sort的定义中,我看到了这个签名

public static <T extends Comparable<? super T>> void sort(List<T> list)

我根本不理解这个泛型定义？不应该只是说

<T implements Comparable<T>>

有人可以帮我弄这个吗？

我们知道,默认情况下迭代并发集合不是线程安全的,所以不能使用:

Set<E> set = Collections.synchronizedSet(new HashSet<>());
//fill with data
for (E e : set) {
    process(e);
}

这是因为在迭代期间可能会添加数据,因为没有排他锁set.

这在javadoc中描述Collections.synchronizedSet:

public static Set synchronizedSet(Set s)

返回由指定集支持的同步(线程安全)集.为了保证串行访问,必须通过返回的集完成对后备集的所有访问.

当迭代它时,用户必须手动同步返回的集合:

Set s = Collections.synchronizedSet(new HashSet());
...
synchronized (s) { Iterator i = s.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }

不遵循此建议可能会导致非确定性行为.

然而,这并不适用于Set.forEach,它继承了默认的方法forEach从Iterable.forEach.

现在我查看了源代码,在这里我们可以看到我们有以下结构:

1. 我们要求一个Collections.synchronizedSet().

2. 我们得到一个:

   public static <T> Set<T> synchronizedSet(Set<T> s) {
       return new SynchronizedSet<>(s); …

   Run Code Online (Sandbox Code Playgroud)

我使用 Java 8的功能还是滥用它？

请参阅下面的代码和说明,了解为什么选择它是这样的.

public interface Drawable {
    public void compileProgram();

    public Program getProgram();

    default public boolean isTessellated() {
        return false;
    }

    default public boolean isInstanced() {
        return false;
    }

    default public int getInstancesCount() {
        return 0;
    }

    public int getDataSize();

    public FloatBuffer putData(final FloatBuffer dataBuffer);

    public int getDataMode();

    public boolean isShadowReceiver();

    public boolean isShadowCaster();    //TODO use for AABB calculations

    default public void drawDepthPass(final int offset, final Program depthNormalProgram, final Program depthTessellationProgram) {
        Program depthProgram = (isTessellated()) …

我是Java新手.我想知道在私有类中使用公共构造函数是什么.类中的私有类可以从同一个类初始化然后将私有类的构造函数公开的用途是什么？

public class MainActivity extends Activity {
     private class AcceptThread extends Thread {
        public AcceptThread() {

        }
    }
}

我在下面的代码中收到错误,我认为不应该存在...使用JDK 8u40编译此代码.

public class Ambiguous {
    public static void main(String[] args) {
        consumerIntFunctionTest(data -> {
            Arrays.sort(data);
        }, int[]::new);

        consumerIntFunctionTest(Arrays::sort, int[]::new);
    }

    private static <T> void consumerIntFunctionTest(final Consumer<T> consumer, final IntFunction<T> generator) {

    }

    private static <T> void consumerIntFunctionTest(final Function<T, ?> consumer, final IntFunction<T> generator) {

    }
}

错误如下:

错误:(17,9)java:对consumerIntFunctionTest的引用与net.tuis.ubench.Ambiguous中的方法consumerIntFunctionTest(java.util.function.Consumer,java.util.function.IntFunction)和方法consumerIntFunctionTest(java.util.)都不明确. net.tuis.ubench.Ambiguous匹配中的function.Function,java.util.function.IntFunction)

错误发生在以下行:

consumerIntFunctionTest(Arrays::sort, int[]::new);

我相信应该没有错误,因为所有Arrays::sort引用都是类型的void,并且它们都没有返回值.正如您所看到的,当我明确扩展lambda 时它确实有效Consumer<T>.

这真的是javac中的错误,还是JLS声明lambda在这种情况下无法自动扩展？如果是后者,我仍然认为这很奇怪,consumerIntFunctionTest因为第一个参数Function<T, ?>不应该匹配.