有什么方法可以让这个流更有效率吗？

Question

如何在不向新的 ArrayList 中添加价值而只更新原始列表的情况下优化这一点？

 String filterval = filter.toLowerCase();
 ArrayList<String> filtredArr = new ArrayList<String>();

                        listArray.forEach(
                                valueText -> {
                                        String val = valueText.toLowerCase();
                                    if (val.startsWith(filterval) || val.contains(filterval))
                                        filtredArr.add(valueText);
                                    else {
                                        Arrays.stream(valueText.split(" ")).forEach(
                                                singleWord -> {
                                                    String word = singleWord.toLowerCase();
                                                    if(word.startsWith(filterval) || word.contains(filterval))
                                                        filtredArr.add(valueText);
                                                }
                                        );
                                    }
                                });

Answer 1

在使用流时，最好不要修改流的来源，而后者会迭代前者。 （例如，参见this。）

关于可读性和惯用流操作，您的代码与普通的旧 for 循环几乎没有区别（如果您只使用流来执行 forEach，我建议您将其更改为该循环，但您可以修改它以使用更短且更“原子”的流操作链，如下例所示。

• 获取至少包含一个词包含的字符串列表filterval：

  List<String> filtered = listArray.stream()
                                 .filter(str -> str.toLowerCase().contains(filterval))
                                 .collect(Collectors.toList());
  

• 获取至少有一个单词以开头的字符串列表filterval：

  List<String> filtered =
        listArray.stream()
                 .filter(str -> Arrays.stream(str.split(" "))
                                      .map(String::toLowerCase)
                                      .anyMatch(word -> word.startsWith(filterval)))
                 .collect(Collectors.toList());
  

• 获取包含过滤器值的单词列表（在任何字符串中）：

  List<String> filteredWords = listArray.stream()
                                      .map(String::toLowerCase)
                                      .flatMap(str -> Arrays.stream(str.split(" ")))
                                      .filter(word -> word.contains(filterval))
                                      .collect(Collectors.toList());
  

（我假设listArray 是List<String>，你没有在你的代码sn-p 中显示。）

注意事项

• 条件val.startsWith(filterval) || val.contains(filterval) 完全等价于val.contains(filterval)。原因是，如果一个字符串以filterval开头，它也一定意味着它包含它；一个暗示另一个。
• 无需计算单个单词的小写版本，因为您已经将整个字符串小写（因此其中的任何单词也都是小写的）。
• 我们可以将split 应用于所有单词，然后使用filterMap“连接”单词序列，而不是单独处理单个单词和空格分隔的字符串。

---

最小的、完整的、可验证的例子

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


public class Main {
    public static void main(String[] args) {
        String filterval = "ba";
        List<String> listArray = List.of("foo", "BAR", "spam EGGS ham bAt", "xxbazz");


        List<String> filtered1 = listArray.stream()
                                          .filter(str -> str.toLowerCase().contains(filterval))
                                          .collect(Collectors.toList());

        List<String> filtered2 =
                listArray.stream()
                         .filter(str -> Arrays.stream(str.split(" "))
                                              .map(String::toLowerCase)
                                              .anyMatch(word -> word.startsWith(filterval)))
                         .collect(Collectors.toList());

        List<String> filtered3 = listArray.stream()
                                          .map(String::toLowerCase)
                                          .flatMap(str -> Arrays.stream(str.split(" ")))
                                          .filter(word -> word.contains(filterval))
                                          .collect(Collectors.toList());

        System.out.println(Arrays.toString(filtered1.toArray()));
        System.out.println(Arrays.toString(filtered2.toArray()));
        System.out.println(Arrays.toString(filtered3.toArray()));
    }
}

输出：

[BAR, spam EGGS ham bAt, xxbazz]
[BAR, spam EGGS ham bAt]
[bar, bat, xxbazz]