我有一个Java 7项目,它使用Javascript来编写各种功能的脚本.到目前为止,我使用Rhino作为脚本引擎.我现在想转向Java 8,这也意味着我将取代Nashorn的Rhino.

Nashorn与Rhino的兼容性如何？我是否可以将其用作替代品,或者我是否可以预期我的某些脚本将不再工作并且需要移植到新引擎？是否有Nashorn不支持的Rhino常用功能？

我有一个java 8流循环,其中包含以下内容:

    void matchSellOrder(Market market, Order sellOrder) {
        System.out.println("selling " + market.pair() + " : " + sellOrder);

        market.buyOrders()
                .stream()
                .filter(buyOrder -> buyOrder.price >= sellOrder.price)
                .sorted(BY_ASCENDING_PRICE)
                .forEach((buyOrder) -> {
                    double tradeVolume = Math.min(buyOrder.quantity, sellOrder.quantity);
                    double price = buyOrder.price;

                    buyOrder.quantity -= tradeVolume;
                    sellOrder.quantity -= tradeVolume;

                    Trade trade = new Trade.Builder(market, price, tradeVolume, Trade.Type.SELL).build();
                    CommonUtil.convertToJSON(trade);

                    if (sellOrder.quantity == 0) {
                        System.out.println("order fulfilled");
                        // break loop there
                    }
                });
    }

当满足某些条件时,如何摆脱循环？什么是正确的关闭流的方式？

UPDATE

我误用了流tecnique,假设它是一个循环,它不是为此而设计的.这是我最终使用以下答案提供的代码:

        List<Order> applicableSortedBuyOrders = market.buyOrders()
                .stream()
                .filter(buyOrder -> buyOrder.price >= sellOrder.price) …

给出以下代码:

package com.gmail.oksandum.test;

import java.util.ArrayList;
import java.util.List;

public class Test {

    public static void main(String[] args) {
    }

    public void foo() {
        class LocalFoo {

            LocalFoo(String in) {
                //Some logic
            }

        }

        List<String> ls = new ArrayList<>();
        ls.stream().map(LocalFoo::new); //Line 21
    }

}

我的IDE没有给我任何错误.也就是说,直到我尝试构建项目并运行它.当我这样做它给我一个编译器错误,如下所示:

Error:(21, 24) java: incompatible types: cannot infer type-variable(s) R
    (argument mismatch; invalid constructor reference
      cannot access constructor LocalFoo(java.lang.String)
        an enclosing instance of type com.gmail.oksandum.test.Test is not in scope)

现在,我想,给出错误消息,如果foo()是静态的,这不会发生.而且非常正确,只有当foo()是实例方法时才会发生这种情况.只有当LocalFoo是实例方法中的本地类时才会发生,并且只有在使用构造函数引用时才会发生(即从不是常规方法引用).

更重要的是,如果我将第21行改为

ls.stream().map(str -> new LocalFoo(str));

编译器突然没有错误.

所以回顾一下.如果我尝试在实例方法中声明的本地类上使用构造函数引用,编译器会抱怨无法访问构造函数,我很困惑.

如果有人能够阐明为什么会发生这种情况,我们将不胜感激.谢谢.

我决定尝试一些实验,看看我能发现堆栈帧的大小,以及当前执行代码在堆栈中的距离.我们可能会在这里调查两个有趣的问题:

1. 当前代码的堆栈深度是多少？
2. 当前方法在到达之前可以达到多少级别的递归StackOverflowError？

堆栈当前执行代码的深度

这是我能想到的最好的:

public static int levelsDeep() {
    try {
        throw new SomeKindOfException();
    } catch (SomeKindOfException e) {
        return e.getStackTrace().length;
    }
}

这看起来有点黑客.它生成并捕获异常,然后查看堆栈跟踪的长度.

不幸的是,它似乎也有一个致命的限制,即返回的堆栈跟踪的最大长度为1024.除此之外的任何内容都被削减,因此此方法可以返回的最大值为1024.

题:

有没有更好的方法做到这一点,不是那么hacky并没有这个限制？

对于它的价值,我的猜测是没有:Throwable.getStackTraceDepth()是本机调用,它暗示(但不能证明)它不能用纯Java完成.

确定我们剩下多少递归深度

我们可以达到的等级数量将由(a)堆栈帧的大小和(b)剩余堆栈量确定.让我们不要担心堆栈框架的大小,只需看看我们达到之前可以达到多少级别StackOverflowError.

这是我执行此操作的代码:

public static int stackLeft() {
    try {
        return 1+stackLeft();
    } catch (StackOverflowError e) {
        return 0;
    }
}

它的工作令人钦佩,即使它在堆栈剩余量方面是线性的.但这是非常非常奇怪的部分.在64位Java 7(OpenJDK 1.7.0_65)上,结果完全一致:9,923,在我的机器上(Ubuntu 14.04 64位).但Oracle的Java 8(1.8.0_25)给出了非确定性结果:我的记录深度在18,500到20,700之间.

现在为什么它是非确定性的呢？应该有一个固定的堆栈大小,不是吗？并且所有代码对我来说都是确定性的.

我想知道错误捕获是否奇怪,所以我尝试了这个:

public static long badSum(int n) {
    if (n==0)
        return 0;
    else
        return 1+badSum(n-1);
} …

我有一种感觉,我在这里遗漏了一些东西.我发现自己做了以下事情

private static int getHighestValue(Map<Character, Integer> countMap) {
    return countMap.values().stream().mapToInt(Integer::intValue).max().getAsInt();
}

我的问题是从愚蠢的转换Stream到 IntStream通过mapToInt(Integer::intValue)

有没有更好的转换方式？这一切都是为了避免使用max()从Stream,这需要传递一个Comparator但问题是专门对的皈依Stream到IntStream

例如,在匿名内部类的情况下,传递(匿名)对象引用并执行该对象的方法.

Lambdas是将在需要时执行的代码块.

遇到lambdas时JVM中会发生什么？JVM在哪里存储与lambdas相关的代码块(Heap:Young,Old或Permanent Generation)？

我尝试搜索,我得到了使用lambdas的语法但是无法理解JVM中发生的事情,因为在JAVA中,一切都是基于对象的.

1. 所以在OOP的背景下,lambda是如何工作的？

2. lambda违反了OOP概念吗？

3. Lambda是否适合垃圾收集器,因为没有创建对象因此不用担心内存问题和清​​除内存？

我在Java 7循环和Java 8 forEach循环中迭代数组列表.Java 8循环希望循环内的变量是最终的.例如,

List<String> testList = Arrays.asList( "apple", "banana", "cat", "dog" );
int count = 0;

testList.forEach(test -> {
  count++; // Compilation error: Local variable count defined in an enclosing scope must be final or effectively final
});

for (String test : testList) {
  count++; // Code runs fine
}

有人可以解释为什么会这样吗？这是Java 8的缺点吗？

假设我们有一个Iterator<Integer> iterator.因为Iterable是一个功能界面,我们可以写:

Iterable<Integer> iterable = () -> iterator;

那么我们当然可以iterable用作增强的for循环表达式:

for (Integer i : iterable) foo(i);

那么为什么呢

for (Integer i : () -> iterator) foo(i);

不允许？(导致以下编译器错误:)

error: lambda expression not expected here
    for (Integer i : () -> iterator) foo(i);
                     ^

使目标类型显式为

for (Integer i : (Iterable<Integer>) () -> iterator) foo(i);

显然有效,但为什么编译器不能推断出λ-expression的目标类型？从表达式是λ表示法的事实来看,编译器不应该清楚目标类型不能是一个Array,因此必须是Iterable？

这只是语言设计师的疏忽,还是我还缺少其他的东西？

我在这个论坛和谷歌搜索后发布我的查询,但无法解决相同问题.例如:Link1 Link2 Link3

我试图根据列表1中的值过滤列表2(多列).

List1:
 - [Datsun]
 - [Volvo]
 - [BMW]
 - [Mercedes]

List2: 
 - [1-Jun-1995, Audi, 25.3, 500.4, 300]
 - [7-Apr-1996, BMW, 35.3, 250.2, 500]
 - [3-May-1996, Porsche, 45.3, 750.8, 200]
 - [2-Nov-1998, Volvo, 75.3, 150.2, 100]
 - [7-Dec-1999, BMW, 95.3, 850.2, 900]

expected o/p:
 - [7-Apr-1996, BMW, 35.3, 250.2, 500]
 - [2-Nov-1998, Volvo, 75.3, 150.2, 100]
 - [7-Dec-1999, BMW, 95.3, 850.2, 900]

码

// List 1 in above eg
List<dataCarName> listCarName = new ArrayList<>(); 
// List 2 …

我Stream处理了几百万个元素.它背后的Map-Reduce算法需要几毫秒,因此任务完成大约需要20分钟.

Stream<MyData> myStream = readData();
MyResult result = myStream
    .map(row -> process(row))
    .peek(stat -> System.out.println("Hi, I processed another item"))
    .reduce(MyStat::aggregate);

我想要一种显示整体进度的方法,而不是每个元素打印一行(这导致每秒数千行,需要时间,并且不提供有关整体进度的任何有用信息).我想展示类似于:

 5% (08s)
10% (14s)
15% (20s)
...

最好(和/或最简单)的方法是什么？