标签: java-8

我有一个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) …

我正在尝试使用以下格式获取完整LocalDate的周数:

dd.MM.yyy

我还没有在Java 8 Date API中找到一个返回Week Number的函数,我试图创建一个算法,但它没有用.

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

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

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

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

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

2. lambda违反了OOP概念吗？

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

出于某种原因,我常想,java.util.Random是线程安全的,一拉HashMap或BitSet,并且Math.random()被实现为包装访问Random与synchronized块,或ThreadLocalRandom.current().nextDouble().

实际上事实证明它java.util.Random是线程安全的(通过原子).因此需要注意的是:即使我需要在单个线程中使用一些随机输入,使用ThreadLocalRandom也是有意义的,因为内部没有原子读写,编译为锁定指令并发出内存屏障.

而且,由于Java 8 ThreadLocalRandom本质上是一个单例,它的状态保存在某些java.lang.Thread类的字段中.因此,方法ThreadLocalRandom.current()不是访问ThreadLocalMap,而只是静态字段读取,即非常便宜.

我有两个问题:

1. 从计算机科学的角度来看,几个线性同余随机生成器(以ThreadLocalRandoms 的方式初始化)的输出是否与单个线性同余随机生成器(java.util.Random实例)的输出相同"随机" ？

2. 如果回答的第一个问题是肯定的,是否有任何理由写的建设new Random()(不含种子)来代替ThreadLocalRandom.current(),永远不会消失？

更新.我应该调用像ThreadLocalRandom.current().ints().parallel().collect(...)可能是不正确的,因为线程的随机数生成器的状态可能中未初始化ForkJoinPool的工作线程,但看起来,ThreadLocalRandom覆盖方法ints(),longs()以及doubles(),使得上述结构正确.

我在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？

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

    public void test(){
       String x;
       List<String> list=Arrays.asList("a","b","c","d");

       list.forEach(n->{
          if(n.equals("d"))
            x="match the value";
       });
    }

1.像上面的代码一样,我想在foreach块旁边设置一个变量的值,它可以工作吗？

2.为什么？

3. foreach迭代器是有序的还是无序的？

4.我认为lamdas foreach块对于迭代器来说很酷且很简单,但这实际上是一件很复杂的事情,而不是java 7或之前的相同工作.

我在这个论坛和谷歌搜索后发布我的查询,但无法解决相同问题.例如: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)
...

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

我的POJO如下

class EventUser {
  private id;
  private userId;
  private eventId;
}

我按如下方式检索EventUser对象:

List<EventUser> eventUsers = eventUserRepository.findByUserId(userId);

说'eventUsers'如下:

[
{"id":"id200","userId":"001","eventId":"1010"},
{"id":"id101","userId":"001","eventId":"4212"},
{"id":"id402","userId":"001","eventId":"1221"},
{"id":"id301","userId":"001","eventId":"2423"},
{"id":"id701","userId":"001","eventId":"5423"},
{"id":"id601","userId":"001","eventId":"7423"}
]

使用流式传输,而不使用任何中间变量,如何在给定的EventUser.id之后过滤和收集事件:ex:

List<EventUser> filteredByOffSet = eventUsers.stream.SOMEFILTER_AND_COLLECT("id301");

结果应该是:

[{"id":"id301","userId":"001","eventId":"2423"},
{"id":"id701","userId":"001","eventId":"5423"},
{"id":"id601","userId":"001","eventId":"7423"}]