标签: java-8

Java 8是否支持像Scala和其他功能程序一样的模式匹配？我正在一起介绍Java 8的Lambda功能.我在这个特定的功能编程概念上找不到任何东西.

我记得让我对函数式编程感兴趣的是quicksort实现,特别是与命令式编程的实现相比.

在什么情况下,在Java 8流中调用'reduce'的第三个参数？

下面的代码尝试遍历字符串列表并添加每个字符串的第一个字符的代码点值.似乎永远不会使用最终lambda返回的值,如果插入println,它似乎永远不会被调用.该文档将其描述为"组合器",但我无法找到更多细节......

int result =
  data.stream().reduce(0, (total,s) -> total + s.codePointAt(0), (a,b) -> 1000000); 

我正在尝试在我的应用程序中使用LocalDate和LocalDateTime与Java 8.我正在使用Hibernate 4.3.5和Spring.我在这里关注了这个有趣的教程,但是当我使用DATE()构造时,我遇到了一个问题.

当我尝试做的时候:

SELECT * FROM TABLE WHERE DATE(data)=DATE(:data)

如果我手动创建的查询(复制和过去的查询Hibernate打印)工作正常,我总是一个空列表.我认为问题是Hibernate在内部进行的转换; 它尝试将LocalDate转换为java.util.Date.我告诉这个,因为如果我以这种方式更改查询:

SELECT * FROM TABLE WHERE DATE(data)=:data

我有这个例外:

java.lang.IllegalArgumentException: Parameter value [2014-05-27T00:00] did not match expected type [java.util.Date (n/a)]
at org.hibernate.jpa.spi.BaseQueryImpl.validateBinding(BaseQueryImpl.java:885)
at org.hibernate.jpa.internal.QueryImpl.access$000(QueryImpl.java:80)
at org.hibernate.jpa.internal.QueryImpl$ParameterRegistrationImpl.bindValue(QueryImpl.java:248)
at org.hibernate.jpa.spi.BaseQueryImpl.setParameter(BaseQueryImpl.java:631)
at org.hibernate.jpa.spi.AbstractQueryImpl.setParameter(AbstractQueryImpl.java:180)
at org.hibernate.jpa.spi.AbstractQueryImpl.setParameter(AbstractQueryImpl.java:49)
at it.AppuntamentoCustomRepositoryImpl.findAppuntamenti(AppuntamentoCustomRepositoryImpl.java:95)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:483)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:317)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.security.access.intercept.aopalliance.MethodSecurityInterceptor.invoke(MethodSecurityInterceptor.java:64)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:98)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:262)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:95)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:207)
at com.sun.proxy.$Proxy91.findAppuntamenti(Unknown Source)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native …

我运行Eclipse 4.3了Java 7 JRE.当我升级到a时Java 8 JRE,Eclipse会突然消耗更多内存.如果我JRE 7直接将Eclipse启动到我的工作区,它会根据任务管理器分配600 MB的RAM.当我使用时JRE 8,此值为750 MB.

更糟糕的是,如果我运行一个大型Java程序,通常会分配大约10 GB的RAM JRE 7,切换到JRE 8它会分配12 GB的RAM.

有人知道是什么原因导致额外的RAM分配吗？我已经测试了调整不同的选项,但没有成功:

-XX:ReservedCodeCacheSize=
-XX:MaxMetaspaceSize=
-XX:MetaspaceSize=
...

这与如何在Stream上短路减少基本相同？.但是,由于这个问题集中在一个布尔值流,并且其答案不能推广到其他类型并减少操作,我想问更一般的问题.

我们如何在流上进行减少,以便在遇到减少操作的吸收元件时发生短路？

乘法的典型数学例子是0.这个Stream:

int product = IntStream.of(2, 3, 4, 5, 0, 7, 8)
        .reduce(1, (a, b) -> a * b);

将消耗最后两个元素(7和8),无论一旦0遇到产品已知的事实.

我正在讨论来自http://www.concretepage.com/java/jdk-8/java-8-unaryoperator-binaryoperator-example的例子.

我发现真正令人困惑的是,当我在形成收集器时错误地将错误的类型放入泛型中时,java编译器给了我一个非常误导性的消息:

无法从静态上下文引用非静态方法

我的错误与现实中的静态vs实例上下文无关:

Map<String, Map<Integer, Integer>> mapOfStudents = list.stream().collect(Collectors.groupingBy(Student::getClassName,
            Collectors.toMap(Student::getName, Student::getAge)));

我的错误在于泛型返回类型.当我纠正它并把:

Map<String, Map<String, Integer>> mapOfStudents

一切都恢复正常.

有人可以解释这种令人困惑的错误信息背后的原因吗？我确信这是一个很好的,但我没有抓住它.

编辑:

~$ java -version
openjdk version "1.8.0_121"
OpenJDK Runtime Environment (build 1.8.0_121-8u121-b13-0ubuntu1.16.04.2-b13)
OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode)

以下陈述是真的吗？

(来源和来源 - 他们似乎互相复制或来自同一来源.)

该sorted()操作是"有状态的中间操作",这意味着后续操作不再对后备集合进行操作,而是对内部状态进行操作.

我已经测试Stream::sorted过以上来源的片段:

final List<Integer> list = IntStream.range(0, 10).boxed().collect(Collectors.toList());

list.stream()
    .filter(i -> i > 5)
    .sorted()
    .forEach(list::remove);

System.out.println(list);            // Prints [0, 1, 2, 3, 4, 5]

有用.我替换Stream::sorted为Stream::distinct,Stream::limit和Stream::skip:

final List<Integer> list = IntStream.range(0, 10).boxed().collect(Collectors.toList());

list.stream()
    .filter(i -> i > 5)
    .distinct()
    .forEach(list::remove);          // Throws NullPointerException

令我惊讶的NullPointerException是,它被扔了.

所有测试方法都遵循有状态中间操作特性.然而,Stream::sorted没有记录这种独特的行为,Stream操作和管道部分解释了有状态中间操作是否真正保证了新的源集合.

我的困惑来自何处以及上述行为的解释是什么？

我有一个方法如下，它已经正常运行了很长时间：

private String loadFromFile(){

    RandomAccessFile inFile = null;
    FileChannel inChannel = null;
    StringBuilder sb = new StringBuilder();
    try {

        inFile = new RandomAccessFile(this.latestImageFile, "r");
        inChannel = inFile.getChannel();

        ByteBuffer bb = ByteBuffer.allocate(2046);
        while( inChannel.read(bb) != -1){
            bb.flip();

            while(bb.hasRemaining()){
                char c = (char) bb.get();   // read character at current position and set the pointer to current position + 1
                sb.append(c);
            }

            bb.clear();
        }

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (inChannel != null) try {inChannel.close(); } catch (IOException e){} …

我有以下集合类型:

Map<String, Collection<String>> map;

我想map.size()从每个Key的集合中的单个值创建每个组的唯一组合.

例如,假设地图如下所示:

A, {a1, a2, a3, ..., an}
B, {b1, b2, b3, ..., bn}
C, {c1, c2, c3, ..., cn}

我希望获得的List<Set<String>>结果是一个结果,看起来类似于(排序并不重要,它只需要是一个由所有可能的组合组成的'完整'结果):

{a1, b1, c1},
{a1, b1, c2},
{a1, b1, c3},
{a1, b2, c1},
{a1, b2, c2},
{a1, b2, c3},
...
{a2, b1, c1},
{a2, b1, c2},
...
{a3, b1, c1},
{a3, b1, c2},
...
{an, bn, cn}

这基本上是一个计数问题,但我想看看是否可以使用Java 8流解决方案.

比较StreamJava 8中的两个实例并找出它们是否具有相同的元素,特别是出于单元测试的目的,有什么好方法？

我现在得到的是:

@Test
void testSomething() {
  Stream<Integer> expected;
  Stream<Integer> thingUnderTest;
  // (...)
  Assert.assertArrayEquals(expected.toArray(), thingUnderTest.toArray());
}

或者:

Assert.assertEquals(
    expected.collect(Collectors.toList()),
    thingUnderTest.collect(Collectors.toList()));

但这意味着我正在构建两个集合并丢弃它们.考虑到我的测试流的大小,这不是性能问题,但我想知道是否有一种规范的方法来比较两个流.