Java 如何检测我何时处于最后一个循环中？（拉姆达）

我写道：

Arrays
            .stream(docIDs.split(","))
            .parallel()
            .forEachOrdered(i -> {
                        try {
                            System.out.print(
                                    Files.lines(Paths.get(spamDir +"\\cw12-" + i.substring(10,16) + ".txt"))
                                            .filter(j -> j.matches("^(\\d\\d)\\s" + i)) 
                                            .map(line -> line.substring(0, line.indexOf(" "))) 
                                            .findFirst()    
                                            .orElse("-1")
                            );
                        } catch (Exception e1) {
                            System.out.print("-1");
                        }
                    }
            );

我正在打印字符串的一部分，如上面所示

我需要在每个元素（数字）之间加上“，”逗号。 { 我要检查我是否在最后一个元素中，并根据它加上“，”逗号。这就是为什么我需要知道我是否在最后一个元素中。 }

我想了这么多，但找不到解决办法。我该怎么做呢？

有几件事：

• parallel

  和

  forEachOrdered

  基本上是相互抵消的
• 并行无论如何都不是个好主意
• 您无法检测是否在最后一个元素中
• 无论如何，有一个更好的解决方案

  System.out.println(
      Arrays.stream(docIDs.split(","))
      .parallel() // included because OP included it
      .map(i -> {
          // this is how you should use Files.lines anyway
          try (Stream<String> lines = Files.lines(Paths.get(spamDir +"\\cw12-" + i.substring(10,16) + ".txt"))) {
             return lines
                         .filter(j -> j.matches("^(\\d\\d)\\s" + i)) 
                                      .map(line -> line.substring(0, line.indexOf(" "))) 
                         .findFirst()    
                         .orElse("-1");
          } catch (IOException e1) {
              return "-1";
          }
      })
      .collect(Collectors.joining(",")));
  

  System.out.println(
  Arrays.stream（docid.split（“，”））
  .parallel（）//包含，因为OP包含它
  .map（i->{
  //这就是您应该如何使用Files.lines
  尝试（streamlines=Files.lines（path.get（spamDir+“\\cw12-”+i.substring（10,16）+“.txt）））{
  回程线
  .filter（j->j.matches（“^（\\d\\d）\\s”+i））
  .map（line->line.substring（0，line.indexOf（“”））
  .findFirst（）
  .orElse（“-1”）；
  }捕获（IOE1异常）{
  返回“-1”；
  }
  })
  .collect（收集器。连接（“，”）；
  

…您最初问题的主要答案是使用

收集器。首先加入
而不是尝试进行顺序循环。
以下几点：


parallel
和
forEachOrdered
基本上是相互抵消的
并行
无论如何都不是个好主意
您无法检测是否在最后一个元素中
无论如何，有一个更好的解决方案

System.out.println(
    Arrays.stream(docIDs.split(","))
    .parallel() // included because OP included it
    .map(i -> {
        // this is how you should use Files.lines anyway
        try (Stream<String> lines = Files.lines(Paths.get(spamDir +"\\cw12-" + i.substring(10,16) + ".txt"))) {
           return lines
                       .filter(j -> j.matches("^(\\d\\d)\\s" + i)) 
                                    .map(line -> line.substring(0, line.indexOf(" "))) 
                       .findFirst()    
                       .orElse("-1");
        } catch (IOException e1) {
            return "-1";
        }
    })
    .collect(Collectors.joining(",")));

System.out.println(
Arrays.stream（docid.split（“，”））
.parallel（）//包含，因为OP包含它
.map（i->{
//这就是您应该如何使用Files.lines
尝试（streamlines=Files.lines（path.get（spamDir+“\\cw12-”+i.substring（10,16）+“.txt）））{
回程线
.filter（j->j.matches（“^（\\d\\d）\\s”+i））
.map（line->line.substring（0，line.indexOf（“”））
.findFirst（）
.orElse（“-1”）；
}捕获（IOE1异常）{
返回“-1”；
}
})
.collect（收集器。连接（“，”）；


…您最初问题的主要答案是使用
收集器。首先加入
而不是尝试执行顺序循环。
streams API是java函数式编程功能的一部分。函数式编程的基本概念是元素操作之间没有关系。因此，如果您需要这种关系，您应该更改回
for
带有索引的循环
addcomma=false；对于（…）{if addcomma print“，”print；addcomma=true；}
…伪代码是我在手机上能做的最好的了。在第一次迭代中，标志为false，因此不打印逗号，打印值并将标志更改为true，对于每一次迭代，标志将为true，然后在值之前打印逗号。我需要使用lambdat执行此操作。streams API是java函数式编程功能的一部分。函数式编程的基本概念是元素操作之间没有关系。因此，如果您需要这种关系，您应该更改回
for
带有索引的循环
addcomma=false；对于（…）{if addcomma print“，”print；addcomma=true；}
…伪代码是我在手机上能做的最好的了。在第一次迭代中，标志为false，因此不打印逗号，打印值并将标志更改为true，对于每一次迭代，标志将为true，在值之前打印逗号。我需要这样做，lambdaYou说：“并行和forEachOrdered基本上相互抵消。”，但我需要用最快的方式做，而且必须订购。你有什么建议吗？@Aliİ。你完全按照我写的那样做。但是，可能会删除
.parallel（）
。
parallel
和
forEachOrdered
基本上相互抵消。只是因为这中间没有操作，对吧？@shmosel没有。他们总是互相抵消。你不能让一个操作有些是并行的，有些是顺序的；这不是流的工作方式。如果您想并行执行某些操作，或者按顺序执行某些操作，则必须显式地收集到中间集合或类似集合，并将其分解为单独的流操作。您是否建议并行流不能保留相遇顺序？我认为那是不对的。你还说：“平行线和平行线基本上是相互抵消的。”，但我需要以最快的方式完成，而且必须订购。你有什么建议？@Aliİ。你完全按照我写的那样做。但是，可能会删除
.parallel（）
。
parallel
和
forEachOrdered
基本上相互抵消。只是因为这中间没有操作，对吧？@shmosel没有。他们总是互相抵消。你不能让一个操作有些是并行的，有些是顺序的；这不是流的工作方式。如果您想并行执行某些操作，或者按顺序执行某些操作，则必须显式地收集到中间集合或类似集合，并将其分解为单独的流操作。您是否建议并行流不能保留相遇顺序？我认为那是不对的。另见