标签: java-8

这似乎可以使用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();
}

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

似乎在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必须是构造函数中的第一个语句,所以这是不允许的.有没有什么好办法实现这个目标？

如何将 LocalDateTime 转换为 OffsetDateTime？

private OffsetDateTime getEntryDate(Payment payment){
    return Optional.ofNullable(payment).map(Payment::getEntryDate).map(SHOULD RETURN OffsetDateTime)
            .orElse(null);
}

Payment::getEntryDate 将返回 LocalDateTime

我有一些 Java 代码从items. 它基于以下条件限制它们maxNumber：

items.stream()
     .map(this::myMapper)
     .filter(item -> item != null)
     .limit(maxNumber)
     .collect(Collectors.toList());

它工作正常，但问题是：有没有办法跳过限制maxNumber == 0？

我知道我可以这样做：

if (maxNumber == 0) {
    items.stream()
         .map(this::myMapper)
         .filter(item -> item != null)
         .collect(Collectors.toList());
} else {
    items.stream()
         .map(this::myMapper)
         .filter(item -> item != null)
         .limit(maxNumber)
         .collect(Collectors.toList());
}

但也许有更好的方法，您有什么想法吗？

我想流式传输文件中包含的行，但在处理后将每个文件移动到另一个文件夹。

目前的流程是这样的：

解释：

1. 我创建Stream的File小号
2. 我BufferedReader为他们每个人创建一个
3. 我flatMap到Stream了BufferedReader
4. 我打印每一行。

代码（为简单起见省略了例外）：

(1)    Stream.generate(localFileProvider::getNextFile)
(2)       .map(file -> new BufferedReader(new InputStreamReader(new FileInputStream(file))))
(3)       .flatMap(BufferedReader::lines)
(4)       .map(System.out::println)
          .MOVE_EACH_FILE_FROM_INPUT_FOLDER_TO_SOME_OTHER_FOLDER;

一旦完全读取每个文件并继续处理流中的其他文件，是否可以移动每个文件？

EnumSet,就像enum它自身一样古老(自Java 5开始),应该是比特场的用例的非妥协替代品:像位域一样快速和精简(好吧,除了不是原始类型),以及类型安全的启动.另一方面,最新和多年来最受期待的Java API-Streams API - 毫不掩饰地使用了bitfields Spliterator的特性.

我是否应该认为上述内容是核心Java专家的明确承认,EnumSet毕竟不是那么好？我是否应该重新考虑从不使用位域的常见最佳实践建议？

我常常发现使用pre-java-8设置实现构建器模式很繁琐.总是有很多几乎重复的代码.构建器本身可以被视为样板.

事实上,有代码重复检测器,几乎可以考虑使用pre-java-8工具制作的构建器的每个方法作为每个其他方法的副本.

所以考虑下面的类和它的pre-java-8构建器:

public class Person {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class PersonBuilder {

    private static class PersonState {
        public String name;
        public int age;
    }

    private PersonState  state = new PersonState();

    public PersonBuilder withName(String name) {
        state.name = name;
        return this; …

我只是在学习Java,所以我很难获得可能的替代方案以及这样的设计决策的影响.

Java 8 为接口添加了默认方法功能,允许接口具有实现.这允许使用新方法扩展现有接口,而不会破坏客户端,以向后兼容的方式随时间演变接口.但是,给定默认实现,此类扩展有些限制,并且可能使用接口或库方法的现有接口方法来实现.所以我的问题是

• 为什么要引入这种语言功能？
• 它支持哪些关键的新功能？(例如分裂器)
• 还有哪些其他替代方案可以支持这些语言功能？例如,为什么不创建一个扩展Iterable的新接口SplitIterable？
• 实施这些替代方案会产生什么影响(接口的宣传？)
• 当可以将其作为其他方法的组合实现时,我是否应该为第一版接口中的方法提供默认实现？

我正在编写一个函数,它接受一个keyExtractor函数列表来生成一个Comparator(想象我们有一个具有许多属性的对象,并希望能够以任意顺序任意比较大量属性).

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

class Test {
    public static <T, S extends Comparable<S>> Comparator<T> parseKeysAscending(List<Function<T, S>> keyExtractors) {
        if (keyExtractors.isEmpty()) {
            return (a, b) -> 0;
        } else {
            Function<T, S> firstSortKey = keyExtractors.get(0);
            List<Function<T, S>> restOfSortKeys = keyExtractors.subList(1, keyExtractors.size());
            return Comparator.comparing(firstSortKey).thenComparing(parseKeysAscending(restOfSortKeys));
        }
    }

    public static void main(String[] args) {
        List<Extractor<Data, ?>> extractors = new ArrayList<>();
        extractors.add(new Extractor<>(Data::getA));
        extractors.add(new Extractor<>(Data::getB));

        Comparator<Data> test = parseKeysAscending(
                extractors.stream()
                        .map(e -> e)
                        .collect(Collectors.toList()));
    }

}


class Extractor<T, …