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

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

当使用流时，最好不要修改流的源，而后者迭代前者。例如，请参阅此。）

关于可读性和流操作的惯用用法，您的代码与普通的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，你不会在代码片段中显示它

• 条件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]