标签: java-8

我听说lambdas即将到达你附近的Java(J8).我在一些博客上找到了一个例子:

SoccerService soccerService = (teamA, teamB) -> {
    SoccerResult result = null;
    if (teamA == teamB) {
        result = SoccerResult.DRAW;
    }
    else if(teamA < teamB) {
        result = SoccerResult.LOST;
    }
    else {
        result = SoccerResult.WON;
    }

    return result;
};

所以马上就开始了:

• 在哪里teamA和teamB类型？或者不是它们(就像一些奇怪的泛型)？
• lambda是一种闭包,还是相反？
• 这会给我一个典型的匿名函数带来什么好处？

有没有办法强制Thread在Java 8下停止,现在Thread.stop已被删除？这包括强制等待锁/同步/睡眠/等待/无限循环的线程停止.

这是作为应用程序的监视程序的一部分,它可以检测它是否具有死锁/冻结,强制终止线程然后保存当前状态以避免丢失信息 - 同时由于强制执行此信息而导致此信息损坏的可能性很高线程停止,最好有一个可能不正确的信息的副本,而不是失去它.

尝试在不停止锁定线程的情况下保存此信息是不可能的,因为保存它将需要获取锁.

这似乎可以使用Java 7和任何版本的Scala库进行编译:

public static void main(String[] args) {
    scala.collection.immutable.Set<String> set = new scala.collection.immutable.HashSet<String>();
    Iterator<String> iterator = set.iterator();
}

它还可以编译Java 8和Scala 2.11.5+.但是使用Java 8和Scala 2.11.4,Eclipse抱怨:

The method iterator() is ambiguous for the type Set<String>

我不明白这一点.您可能会对在某些上下文中选择哪个重载方法感到不明确,但如果您没有传递任何参数,肯定不会？

真奇怪的是,如果我像这样重铸:

public static void main(String[] args) {
    Iterator<String> iterator = new scala.collection.immutable.HashSet<String>().iterator();
}

投诉消失了.在我看来,这与上面的版本完全相同.那为什么它现在编译好了？

我试图理解CompletableFutureJava 8 如何与Java内存模型交互.在我看来,对于程序员的理智,理想情况下应该成立:

1. 完成任务的线程中的操作CompletableFuture - 在执行任何完成相关的阶段之前
2. 在该线程操作注册完成创建依赖阶段发生,之前的完成执行依赖阶段

java.util.concurrent文档中有一条说明:

在提交Runnable到执行之前的线程中的操作Executor - 在执行开始之前.同样的Callables提交给ExecutorService.

这表明第一个属性为true,只要完成未来的线程执行完成依赖阶段或将其提交给Executor.另一方面,在阅读CompletableFuture文档后,我不太确定:

为非异步方法的依赖完成提供的动作可以由完成当前的线程执行CompletableFuture,或者由完成方法的任何其他调用者执行.

这让我想到了我的问题:

1. 这两个假设属性是否真实？
2. 在使用时,是否有任何关于存在或缺乏内存可见性保证的特定文档CompletableFuture？

附录:

在具体示例中,请考虑以下代码:

List<String> list1 = new ArrayList<>();
list1.add("foo");

CompletableFuture<List<String>> future =
        CompletableFuture.supplyAsync(() -> {
            List<String> list2 = new ArrayList<>();
            list2.addAll(list1);
            return list2;
        });

能够保证所有的加入"foo"到list1是可见的lambda函数？是否保证添加 …

我尝试命名一个lambda参数_,例如(一个减少版本):

Consumer<Object> c = _ -> {};

因为我想表示一个参数被忽略,但我得到了以下编译器错误:

对于lambda参数禁止使用'_'作为标识符

这对我来说是一个惊喜.有趣的是,两个下划线是可以的:

Consumer<Object> c = __ -> {}; // no compile error

因此,它不是一般的下划线字符,而是单个字符.

为什么单下划线名称是专门禁止的？

IntelliJ正在向我显示此错误

我刚刚建立了我的新电脑,我的java东西都没有工作......我的常规Intellij在我第一次尝试时正在工作,但我的android工作室无法安装,因为它无法找到jdk的路径.这是我问过的问题.由于那不起作用,我不得不多次重新安装java,现在我的IntelliJ无法正常工作.这是一个错误的图片(我收到一个错误,告诉我在这个语言级别不支持for-each循环).

我试图在我的D:驱动器上安装JDK,但是没有用.我目前正在尝试使用java 1.8u71(尝试过u65和1.7u47),但没有一个有效.

似乎在Java 8中,在子像素坐标上的划动被打破了.

我有三组案例,屏幕截图显示(列表示案例,行表示不同的笔画宽度):

Java 7u51(400%规模)

Java 8u60(400%规模)

1. 在相同坐标上填充和描边.按预期工作,描边区域大于填充区域.
2. 抚摸(通过笔划宽度)缩小并且居中(宽度的一半)为填充区域的内边界.这部分在Java 8中用于1px笔划,其中绘制发生在子像素坐标(第一行)上; 3px笔划没有这个问题(第三行).对于1px笔划,似乎0.5被四舍五入.
3. 填充矩形以与案例2相同的方式收缩.我需要在支持子像素绘制的图形上使用,以便在单元格重叠时进行非重叠填充.在这里你可以看到填充操作向下舍入0.5到0,所以它只是抚摸问题.

代码如下:

import static java.awt.BasicStroke.*;

import java.awt.*;
import java.awt.geom.*;

import javax.swing.*;

public class TestCase
{
    public static void main(String[] args)
    {
        JFrame frame = new JFrame("Test case");
        frame.setSize(115, 115);
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        frame.getContentPane().add(new TestPanel());

        frame.setVisible(true);
    }

    private static class TestPanel extends JPanel
    {
        TestPanel()
        {
            setOpaque(true);
        }

        @Override
        protected void paintComponent(Graphics g)
        {
            Graphics2D g2 = (Graphics2D) g;
            g2.setColor(Color.white);
            g2.fill(getBounds());

            Rectangle2D rect = new Rectangle2D.Double();
            Color background = new Color(0, 255, …

InputStream在构造函数中打开一个然后将其传递给超级构造函数时,有没有什么好的方法可以使用try-with-resources ？

基本上我想要做的是:

public class A {
    public A(InputStream stream) {
        // Do something with the stream but don't close it since we didn't open it
    }
}

public class B {
    public B(File file) {
        // We open the stream so we need to ensure it's properly closed
        try (FileInputStream stream = new FileInputStream(file)) {
            super(new FileInputStream(file));
        }
    }
}

但是,当然,因为super必须是构造函数中的第一个语句,所以这是不允许的.有没有什么好办法实现这个目标？

使用Stream.of创建通用流非常方便,但是如果我想创建一个Stream<String[]>只有一个元素呢？

比方说我有:

String[] tropicalFruits = new String[] {"pineapple", "banana", "mango"};
String[] fruits = new String[] {"melon", "peach", "apple"};

然后Stream.of(tropicalFruits, fruits)产生Stream<String[]>两个元素.如何为单个元素的流实现相同的功能？如果我尝试:

Stream<String[]> fruityStream = Stream.of(tropicalFruits);

我明白了:

错误:不兼容的类型:推理变量T具有不兼容的边界
相等约束:java.lang.String[]
下限:java.lang.String

Stream<String[]> fruityStream = Stream.of(fruits);
                                 ^---------------^

Run Code Online (Sandbox Code Playgroud)

我用Google搜索并搜索了但是我什么也没得到.在我看来,这不是一个非常不寻常的或esoeteric问题,所以有点令人惊讶我没有得到任何答案(或者我没有用正确的关键词搜索).

我偶然发现了以下片段：

public class ParamTest {
    public static void printSum(int a, double b) {
        System.out.println("In intDBL " + (a + b));
    }

    public static void printSum(long a, long b) {
        System.out.println("In long " + (a + b));
    }

    public static void printSum(double a, long b) {
        System.out.println("In doubleLONG " + (a + b));
    }

    public static void main(String[] args) {
        printSum(1, 2);
    }
}

这将导致编译错误：

错误：（15，9）java：对printSum的引用不明确，在ParamTest中的方法printSum（int，double）和在ParamTest中的方法printSum（long，long）都匹配

这是如何模棱两可的？因为第一个参数已经是一个int，在这种情况下不应该仅提升第二个参数吗？在这种情况下，不需要推广第一个参数，对吗？

如果我更新代码以添加另一个方法，则编译成功：

public static void printSum(int a, long b) {
    System.out.println(String.format("%s, %s ", a, b)); …