小编Nam*_*man的帖子

我认为我研究过的所有资源都强调一个流只能被消耗一次,消费是通过所谓的终端操作完成的(这对我来说非常清楚).

出于好奇我试过这个:

import java.util.stream.IntStream;

class App {
    public static void main(String[] args) {
        IntStream is = IntStream.of(1, 2, 3, 4);
        is.map(i -> i + 1);
        int sum = is.sum();
    }
}

最终会抛出一个运行时异常:

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
    at java.util.stream.IntPipeline.reduce(IntPipeline.java:456)
    at java.util.stream.IntPipeline.sum(IntPipeline.java:414)
    at App.main(scratch.java:10)

这是常见的,我遗漏了一些东西,但仍然想问:据我所知,这map是一个中间(和懒惰)操作,并且对Stream本身没有任何作用.只有当sum调用终端操作(这是一个急切的操作)时,才会消耗和操作流.

但为什么我要把它们连在一起呢？

有什么区别

is.map(i -> i + 1);
is.sum();

和

is.map(i -> i + 1).sum();

？

有简单的解决方案可以连接两个String[]或Integer[]在java中Streams.因为int[]经常使用.连接两个有什么简单的方法int[]吗？

这是我的想法:

int[] c = {1, 34};
int[] d = {3, 1, 5};
Integer[] cc = IntStream.of(c).boxed().toArray(Integer[]::new);
Integer[] dd = Arrays.stream(d).boxed().toArray(Integer[]::new);
int[] m = Stream.concat(Stream.of(cc), Stream.of(dd)).mapToInt(Integer::intValue).toArray();
System.out.println(Arrays.toString(m));

>>
[1, 34, 3, 1, 5]

它可以工作,但它实际上转换int[]为Integer[],然后再转换Integer[]回来int[].

Javadoc工具基于可访问性修饰符生成文档.默认情况下,它记录所有public和protected类,字段和方法.可以使用以下选项更改此设置:

-public
仅显示公共类和成员.

-protected
仅显示受保护的公共类和成员.这是默认值.

-package
仅显示包,受保护和公共类和成员.

-private
显示所有类和成员.

Java 9引入了模块的概念,项目Jigsaw将其应用于现有的JDK.一谈马克莱因霍尔德(在一系列有关模块会谈3日)显示了如何public修改目前已拥有不同级别的可访问的,这取决于模块(通过可见性exports):

• 公开给大家
• 公开但仅限于特定模块
• 仅在模块内公开

由于现在并非所有公共成员都可以访问,因此继续使用相同的Javadoc生成方案将没有多大意义.只有那些暴露在"足够"水平的成员才应该被记录下来.

Javadoc模块是否可识别？除了上面的命令选项还有处理额外曝光层的命令选项吗？对于仅暴露给特定模块的公共成员,Javadoc是否列出了这些,如

public <module1, module2> static void getDefaultThing()

？

在stackoverflow上多次提到自动模块,但我找不到自动模块的完整,简洁和自给自足的定义.

那么,什么是自动模块？它是否导出所有包裹？它打开所有包裹吗？它是否读取所有其他模块？

我们正在从本地MongoDB中读取所有来自集合的文档,并且性能不是很高兴.

我们需要转储所有数据,不要担心为什么,只是相信它真的需要并且没有可能的解决方法.

我们有4mio文件看起来像:

{
    "_id":"4d094f58c96767d7a0099d49",
    "exchange":"NASDAQ",
    "stock_symbol":"AACC",
    "date":"2008-03-07",
    "open":8.4,
    "high":8.75,
    "low":8.08,
    "close":8.55,
    "volume":275800,
    "adj close":8.55
}

我们现在使用这个简单的代码来阅读:

MongoClient mongoClient = MongoClients.create();
MongoDatabase database = mongoClient.getDatabase("localhost");
MongoCollection<Document> collection = database.getCollection("test");

MutableInt count = new MutableInt();
long start = System.currentTimeMillis();
collection.find().forEach((Block<Document>) document -> count.increment() /* actually something more complicated */ );
long start = System.currentTimeMillis();

我们正在以16秒(250k行/秒)的速度阅读整个系列,这对于小型文档来说真的不是很令人印象深刻.请记住,我们要加载800十亿行.没有聚合,地图缩小或类似是可能的.

这是否与MongoDB一样快或者是否有其他方法可以更快地加载文档(其他技术,移动Linux,更多RAM,设置......)？

使用JDK/12 EarlyAccess Build 10,JEP-325 Switch Expressions已作为JDK中的预览功能集成.表达式的示例代码(如在JEP中一样):

Scanner scanner = new Scanner(System.in);
Day day = Day.valueOf(scanner.next());
switch (day) {
    case MONDAY, TUESDAY -> System.out.println("Back to work.") ;
    case WEDNESDAY -> System.out.println("Wait for the end of week...") ;
    case THURSDAY,FRIDAY -> System.out.println("Plan for the weekend?");
    case SATURDAY, SUNDAY -> System.out.println("Enjoy the holiday!");
}

在哪里Day作为一个枚举

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

该预览语言和VM特点JEP-12已经阐述了如何功能可以编译和使用运行时期间启用javac和java.

如何使用Maven试用这个功能？

Java 14 引入了记录功能。Record 创建与字段同名的 getter，因此可以编写print(person.name())例如。但是旧的 Java bean 约定规定应该将此方法命名为getName().

在同一个代码库中使用这两种样式看起来不太好。将所有内容迁移到记录是不可能的，因为它们太有限而无法替换所有用例。

是否有任何官方或半官方指南如何在新代码中以 Java 14 命名 getter 和 setter？

功能接口的定义是"功能接口是一个只有一个抽象方法的接口(除了Object的方法),因此代表一个单一的功能契约."

根据这个定义,Comparable<T>它绝对是一个功能界面.

lambda表达式的定义是"lambda表达式就像一个方法:它提供了一个形式参数列表和一个正文 - 一个表达式或块 - 用这些参数表示."

lambda表达式的评估产生功能接口的实例.

因此,lambda表达式的目的是通过实现功能接口的单个​​功能来创建功能接口的实例.即.允许使用单个函数创建实例.

让我们来看看Comparable<T>,这个界面是否设计用作单一功能？即.它是否仅用于创建具有此单一功能的实例？

Comparable<T>以"This接口开头的文档对每个实现它的类的对象施加了一个总排序.这个排序被称为类的自然排序,类的compareTo方法被称为它的自然比较方法."

上面的句子清楚地表明,Comparable<T>它不是设计用作单个函数,而是总是由一个类实现,它通过添加这个单个函数对其实例具有自然顺序.

这意味着它不是设计为使用lambda表达式创建的？

关键是我们不会有任何仅仅是可比较的对象,它意味着要实现,因此用作类的附加功能.

那么,Java语言中是否有一种方法Comparable<T>可以防止创建lambda表达式？接口的设计者是否可以决定该接口是否由类实现,而不是通过使用lambda表达式使用此单一方法创建为实例？

仅仅因为接口恰好有一个抽象方法,它不应该被视为一个功能接口.

也许,如果Java提供像NotFunctional这样的注释,编译器可以检查该接口是否不用于创建lambda表达式,例如.

@NotFunctional
public interface Comparable<T> { public int compareTo(T t); }

如何先分组,然后使用Java流应用过滤？

示例:考虑此类Employee:我希望按部门分组,其中包含薪水大于2000的员工列表.

public class Employee {
    private String department;
    private Integer salary;
    private String name;

    //getter and setter

    public Employee(String department, Integer salary, String name) {
        this.department = department;
        this.salary = salary;
        this.name = name;
    }
}   

这就是我如何做到这一点

List<Employee> list   = new ArrayList<>();
list.add(new Employee("A", 5000, "A1"));
list.add(new Employee("B", 1000, "B1"));
list.add(new Employee("C", 6000, "C1"));
list.add(new Employee("C", 7000, "C2"));

Map<String, List<Employee>> collect = list.stream()
    .filter(e -> e.getSalary() > 2000)
    .collect(Collectors.groupingBy(Employee::getDepartment));  

产量

{A=[Employee [department=A, salary=5000, name=A1]],
 C=[Employee [department=C, …

模块与open关键字之前和之后有什么区别？
例如:

open module foo {
}

module foo {
}