在Java 8中,以下哪项更好？

Java 8:

joins.forEach(join -> mIrc.join(mSession, join));

Java 7:

for (String join : joins) {
    mIrc.join(mSession, join);
}

我有很多可以用lambdas"简化"的for循环,但使用它们真的有什么好处吗？它会改善他们的性能和可读性吗？

编辑

我还将这个问题扩展到更长的方法.我知道你不能从lambda中返回或破坏父函数,在比较它们时也应该考虑到这一点,但还有什么需要考虑的吗？

我想处理XMLjava对象中的列表.我必须确保按顺序处理所有元素.

因此sequential,stream我应该每次使用我吗？ list.stream().sequential().filter().forEach()

或者只要我不使用并行性就足以使用流？ list.stream().filter().forEach()

我有一个数组,我想分成更小的n个数组,并对每个数组执行操作.我目前的做法是

用Java中的ArrayLists实现(任何伪代码都可以)

    for (int i = 1; i <= Math.floor((A.size() / n)); i++) {
            ArrayList temp = subArray(A, ((i * n) - n),
                    (i * n) - 1);
            // do stuff with temp
        }

    private ArrayList<Comparable> subArray(ArrayList A, int start,
                int end) {
            ArrayList toReturn = new ArrayList();
            for (int i = start; i <= end; i++) {
                toReturn.add(A.get(i));
            }
            return toReturn;
        }

其中A是列表,n是所需列表的大小

我相信这种方式在处理相当大的列表(大小高达100万)时花费了太多时间,所以我试图弄清楚什么会更有效率.

鉴于我有一个字符串列表List<String> toProcess.结果必须按原始线的顺序排列.我想利用新的并行流.

以下代码是否保证结果与原始列表中的顺序相同？

// ["a", "b", "c"]
List<String> toProcess;

// should be ["a", "b", "c"]
List<String> results = toProcess.parallelStream()
                                .map(s -> s)
                                .collect(Collectors.toList());

用例

通过Katas在工作中发布的一些编码,我偶然发现了这个问题,我不知道如何解决.

使用Java 8 Streams,给定正整数列表,生成一个整数列表,其中整数前面有一个更大的值.

[10, 1, 15, 30, 2, 6]

Run Code Online (Sandbox Code Playgroud)

以上输入将产生:

[1, 15, 2]

Run Code Online (Sandbox Code Playgroud)

因为1在15之前,15在30之前,2在6之前.

非流解决方案

public List<Integer> findSmallPrecedingValues(final List<Integer> values) {

    List<Integer> result = new ArrayList<Integer>();
    for (int i = 0; i < values.size(); i++) {
        Integer next = (i + 1 < values.size() ? values.get(i + 1) : -1);
        Integer current = values.get(i);
        if (current < next) {
            result.push(current);
        }
    }
    return result;
}

我试过的

我遇到的问题是我无法弄清楚如何在lambda中访问下一个.

return values.stream().filter(v -> v < next).collect(Collectors.toList());

题

• 是否可以检索流中的下一个值？
• 我应该使用map并映射到a …

我正在尝试将for循环转换为功能代码.我需要向前看一个值,并且还要看一个值.是否可以使用流？以下代码是将罗马文本转换为数值.不确定带有两个/三个参数的reduce方法是否有帮助.

int previousCharValue = 0;
int total = 0;

for (int i = 0; i < input.length(); i++) {
    char current = input.charAt(i);

    RomanNumeral romanNum = RomanNumeral.valueOf(Character.toString(current));

    if (previousCharValue > 0) { 
        total += (romanNum.getNumericValue() - previousCharValue);
        previousCharValue = 0;
    } else {
        if (i < input.length() - 1) {

            char next = input.charAt(i + 1);
            RomanNumeral nextNum = RomanNumeral.valueOf(Character.toString(next));
            if (romanNum.getNumericValue() < nextNum.getNumericValue()) {
                previousCharValue = romanNum.getNumericValue();
            }
        }
        if (previousCharValue == 0) {
            total += romanNum.getNumericValue();
        }

    } …

标题可能有点模糊,但这是我所拥有的(在私有化代码中):

包含一些字段的类,包括BigDecimal和Date:

class MyObj{
  private java.math.BigDecimal percentage;
  private java.util.Date date;
  // Some more irrelevant fields

  // Getters and Setters
}

在另一个类中,我有一个这些对象的列表(即java.util.List<MyObj> myList).我现在想要的是一个Java 8流来检查列表是否符合我的验证器的日期和百分比的正确顺序.

例如,以下列表将是真实的:

[ MyObj { percentage = 25, date = 01-01-2018 },
  MyObj { percentage = 50, date = 01-02-2018 },
  MyObj { percentage = 100, date = 15-04-2019 } ]

但是这个列表是假的,因为百分比的顺序不正确:

[ MyObj { percentage = 25, date = 01-01-2018 },
  MyObj { percentage = 20, date = 01-02-2018 },
  MyObj { percentage = 100, …

我有一个像这样的对象流:

"0", "1", "2", "3", "4", "5",

如何将其转换为对的流:

{ new Pair("0", "1"), new Pair("2", "3"), new Pair("4", "5")}.

流大小未知.我正在从一个可能很大的文件中读取数据.我只有收集器的迭代器,我使用spliterator将此迭代器转换为流.我知道这是使用StreamEx处理相邻对的答案: 从流中收集连续对 可以在java或StreamEx中完成吗？谢谢

将流转换为滑动窗口的推荐方法是什么？

例如,在Ruby中你可以使用each_cons:

irb(main):020:0> [1,2,3,4].each_cons(2) { |x| puts x.inspect }
[1, 2]
[2, 3]
[3, 4]
=> nil
irb(main):021:0> [1,2,3,4].each_cons(3) { |x| puts x.inspect }
[1, 2, 3]
[2, 3, 4]
=> nil

在Guava中,我发现只有Iterators#partition,它是相关的但没有滑动窗口:

final Iterator<List<Integer>> partition =
   Iterators.partition(IntStream.range(1, 5).iterator(), 3);
partition.forEachRemaining(System.out::println);
-->
[1, 2, 3]
[4]

有了Iterable<T>,很容易:

T last = null;
for (T t : iterable) {
    if (last != null && last.compareTo(t) > 0) {
        return false;
    }
    last = t;
}
return true;

但我想不出一个干净的方法来做同样的事情Stream<T>,避免消耗所有元素,而不必.