Question

我正在尝试使用`stream将以下代码重构为lambda表达式，尤其是嵌套的foreach循环：

public static Result match (Response rsp) {
    Exception lastex = null;

    for (FirstNode firstNode : rsp.getFirstNodes()) {
        for (SndNode sndNode : firstNode.getSndNodes()) {
            try {
                if (sndNode.isValid())
                return parse(sndNode); //return the first match, retry if fails with ParseException
            } catch (ParseException e) {
                lastex = e;
            }
        }
    }

    //throw the exception if all elements failed
    if (lastex != null) {
        throw lastex;
    }

    return null;
}

我开始时：

rsp.getFirstNodes().forEach().?? // how to iterate the nested 2ndNodes?

Answer 1

看看flatMap：

flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
返回由替换每个元素的结果组成的流此流的内容是由生成的映射流的内容将提供的映射函数应用于每个元素。

代码示例假设isValid()没有抛出

Optional<SndNode> sndNode = rsp.getFirstNodes()
  .stream()
  .flatMap(firstNode -> firstNode.getSndNodes().stream())  //This is the key line for merging the nested streams
  .filter(sndNode -> sndNode.isValid())
  .findFirst();

if (sndNode.isPresent()) {
    try {
        parse(sndNode.get());
    } catch (ParseException e) {
        lastex = e;
    }
}

Answer 2

我担心使用溪流和lambdas，你的表现可能会受到影响。您当前的解决方案返回第一个有效且可解析的节点，但是无法中断流上的操作，例如for-each（source）。

此外，因为您可以有两个不同的输出（返回结果或抛出异常），所以单行表达式无法执行此操作。

这是我想出的。它可能会给你一些想法：

public static Result match(Response rsp) throws Exception {
    Map<Boolean, List<Object>> collect = rsp.getFirstNodes().stream()
            .flatMap(firstNode -> firstNode.getSndNodes().stream()) // create stream of SndNodes
            .filter(SndNode::isValid) // filter so we only have valid nodes
            .map(node -> {
                // try to parse each node and return either the result or the exception
                try {
                    return parse(node);
                } catch (ParseException e) {
                    return e;
                }
            }) // at this point we have stream of objects which may be either Result or ParseException
            .collect(Collectors.partitioningBy(o -> o instanceof Result)); // split the stream into two lists - one containing Results, the other containing ParseExceptions

    if (!collect.get(true).isEmpty()) {
        return (Result) collect.get(true).get(0);
    }
    if (!collect.get(false).isEmpty()) {
        throw (Exception) collect.get(false).get(0); // throws first exception instead of last!
    }
    return null;
}

如开头所述，可能存在性能问题，因为会尝试解析每个有效节点。

修改

为了避免解析所有节点，可以使用reduce，但它更复杂和丑陋（需要额外的类）。这也显示了所有ParseException而不是最后一个。

private static class IntermediateResult { private final SndNode node; private final Result result; private final List<ParseException> exceptions; private IntermediateResult(SndNode node, Result result, List<ParseException> exceptions) { this.node = node; this.result = result; this.exceptions = exceptions; } private Result getResult() throws ParseException { if (result != null) { return result; } if (exceptions.isEmpty()) { return null; } // this will show all ParseExceptions instead of just last one ParseException exception = new ParseException(String.format("None of %s valid nodes could be parsed", exceptions.size())); exceptions.stream().forEach(exception::addSuppressed); throw exception; } } public static Result match(Response rsp) throws Exception { return Stream.concat( Arrays.stream(new SndNode[] {null}), // adding null at the beginning of the stream to get an empty "aggregatedResult" at the beginning of the stream rsp.getFirstNodes().stream() .flatMap(firstNode -> firstNode.getSndNodes().stream()) .filter(SndNode::isValid) ) .map(node -> new IntermediateResult(node, null, Collections.<ParseException>emptyList())) .reduce((aggregatedResult, next) -> { if (aggregatedResult.result != null) { return aggregatedResult; } try { return new IntermediateResult(null, parse(next.node), null); } catch (ParseException e) { List<ParseException> exceptions = new ArrayList<>(aggregatedResult.exceptions); exceptions.add(e); return new IntermediateResult(null, null, Collections.unmodifiableList(exceptions)); } }) .get() // aggregatedResult after going through the whole stream, there will always be at least one because we added one at the beginning .getResult(); // return Result, null (if no valid nodes) or throw ParseException }

<强> EDIT2：

通常，在使用findFirst()等终端运算符时，也可以使用延迟求值。因此，只需稍微更改一下需求（即返回null而不是抛出异常），就应该可以执行以下操作。但是，flatMap findFirst并不使用延迟评估（source），因此此代码会尝试解析所有节点。

private static class ParsedNode { private final Result result; private ParsedNode(Result result) { this.result = result; } } public static Result match(Response rsp) throws Exception { return rsp.getFirstNodes().stream() .flatMap(firstNode -> firstNode.getSndNodes().stream()) .filter(SndNode::isValid) .map(node -> { try { // will parse all nodes because of flatMap return new ParsedNode(parse(node)); } catch (ParseException e ) { return new ParsedNode(null); } }) .filter(parsedNode -> parsedNode.result != null) .findFirst().orElse(new ParsedNode(null)).result; }

Answer 3

尝试使用map转换原始来源。

   rsp.getFirstNodes().stream().map(FirstNode::getSndNodes)
               .filter(sndNode-> sndNode.isValid())
               .forEach(sndNode->{
   // No do the sndNode parsing operation Here.
   })

Answer 4

您可以迭代嵌套循环，如下所示

sed '0,/\PIDFILE=\/var\/run\/Naming_Service.pid/ s//\PIDFILE_1234=\/var\/run\/Naming_Service_1234.pid\n\PIDFILE_1235=\/var\/run\/Naming_Service_1235.pid\n\PIDFILE_1236=\/var\/run\/Naming_Service_1236.pid\n /' script > newscript
sed '0,/\OPTIONS="-p ${PIDFILE}"/ s//\OPTIONS_1234="-p ${PIDFILE_1234} -ORBEndpoint iiop:\/\/10.12.23.34:1234"\n\OPTIONS_1235="-p ${PIDFILE_1235} -ORBEndpoint iiop:\/\/10.12.23.34:1235"\n\OPTIONS_1236="-p ${PIDFILE_1236} -ORBEndpoint iiop:\/\/10.12.23.34:1236"\n /' newscript > script

Answer 5

有点晚了，但这是一种可读的方法：

use strict;
use warnings;
use Text::CSV_XS;
my $csv = Text::CSV_XS->new ({ binary => 1, auto_diag => 1, sep_char => ',', allow_whitespace => 1, allow_loose_quotes => 1});
open my $fh, "<", 'test.csv' or die "Unable to open test.csv: $!";
while (my $row = $csv->getline ($fh)) {
    foreach my $filed (@$row) {
        print "[$filed]";
    }
    print "\n";
}
close $fh;

解释：您可以获得Result = rsp.getFirstNodes() .stream() .flatMap(firstNode -> firstNode.getSndNodes.stream()) .filter(secondNode::isValid)) .findFirst() .map(node -> this.parseNode(node)).orElse(null);和firstNodes所有内容。在每个firstNode中输出n stream()。您检查每个SndNodes以查看有效的第一个。如果没有有效的SndNode，那么我们将得到一个空值。如果有，则会将其解析为SndNodes

parseMethod（）不会改变原文：

Result

Answer 6

您可以使用StreamSupport提供stream方法的事实，Spliterator和Iterable采用spliterator方法。

然后，您只需要一种机制将您的结构展平为Iterable - 就像这样。

class IterableIterable<T> implements Iterable<T> {

    private final Iterable<? extends Iterable<T>> i;

    public IterableIterable(Iterable<? extends Iterable<T>> i) {
        this.i = i;
    }

    @Override
    public Iterator<T> iterator() {
        return new IIT();
    }

    private class IIT implements Iterator<T> {

        // Pull an iterator.
        final Iterator<? extends Iterable<T>> iit = i.iterator();
        // The current Iterator<T>
        Iterator<T> it = null;
        // The current T.
        T next = null;

        @Override
        public boolean hasNext() {
            boolean finished = false;
            while (next == null && !finished) {
                if (it == null || !it.hasNext()) {
                    if (iit.hasNext()) {
                        it = iit.next().iterator();
                    } else {
                        finished = true;
                    }
                }
                if (it != null && it.hasNext()) {
                    next = it.next();
                }
            }
            return next != null;
        }

        @Override
        public T next() {
            T n = next;
            next = null;
            return n;
        }
    }

}

public void test() {
    List<List<String>> list = new ArrayList<>();
    List<String> first = new ArrayList<>();
    first.add("First One");
    first.add("First Two");
    List<String> second = new ArrayList<>();
    second.add("Second One");
    second.add("Second Two");
    list.add(first);
    list.add(second);
    // Check it works.
    IterableIterable<String> l = new IterableIterable<>(list);
    for (String s : l) {
        System.out.println(s);
    }
    // Stream it like this.
    Stream<String> stream = StreamSupport.stream(l.spliterator(), false);
}

您现在可以直接从Iterable流式传输。

最初的研究表明，这应该用flatMap完成，但无论如何。

如何使用lambda流迭代嵌套列表？

6 个答案: