使用stream清除List<String>中的空串

可以使用 Java 8 中的 Stream 对 List<String> 进行处理，实现清除其中的空串。具体代码如下：

List<String> list = Arrays.asList("a", "", "b", "", "c", "");
List<String> result = list.stream()
                         .filter(str -> !str.isEmpty())
                         .collect(Collectors.toList());
System.out.println(result);

输出结果为：`[a, b, c]`

首先将 List 转换成 Stream，然后使用 `filter` 方法过滤掉空串，最后使用 `collect` 方法将过滤后的结果转换成 List。

相关问题

//1.获取最新两期日期 List<String> lastTwoDate = industryScoreInfoRepository.getLastTwoDate(); // List<String> lastTwoDate = new ArrayList<>(); // lastTwoDate.add("2023-02-28"); // lastTwoDate.add("2023-01-31"); log.info("当前观点较上期变化日期："+new Gson().toJson(lastTwoDate)); //2.根据日期获取数据 List<IndustryScoreInfo> industryScoreInfoByDate = industryScoreInfoRepository.getIndustryLastScoreInfos(lastTwoDate); Map<String, List<IndustryScoreInfo>> groups = industryScoreInfoByDate.stream().collect(Collectors.groupingBy(IndustryScoreInfo::getTrackDate)); // 遍历groups中的每个List<IndustryScoreInfo> List<IndustryScoreResult> industryScoreResults = new ArrayList<>(); //获取当前最新日期综合得分 List<IndustryScoreInfo> industryScoreInfos = groups.get(lastTwoDate.get(0)); //获取上一日期综合得分 List<IndustryScoreInfo> last = groups.get(lastTwoDate.get(1)); for(IndustryScoreInfo industry: industryScoreInfos){ IndustryScoreResult result = new IndustryScoreResult(); result.setTrackDate(industry.getTrackDate()); result.setTrackName(industry.getTrackName()); //当前日期观点分数 result.setComprehensiveScore(industry.getComprehensiveScore()); //对上一日期遍历获取track_name相同时，的综合得分，赋值 如果上一日期不存在，则为空串（""）返回 for(IndustryScoreInfo lastIndustryScoreInfo: last){ if(result.getTrackName().equals(lastIndustryScoreInfo.getTrackName())){ result.setLastComprehensiveScore(lastIndustryScoreInfo.getComprehensiveScore()); } } industryScoreResults.add(result); } 代码优化

可以将获取最新两期日期和根据日期获取数据的部分合并成一个流水线，这样可以避免重复的遍历和循环，代码如下：

List<IndustryScoreResult> industryScoreResults = industryScoreInfoRepository.getLastTwoDate().stream()
        .map(date -> industryScoreInfoRepository.getIndustryLastScoreInfos(date))
        .collect(Collectors.groupingBy(IndustryScoreInfo::getTrackDate))
        .entrySet()
        .stream()
        .flatMap(entry -> {
            List<IndustryScoreInfo> current = entry.getValue().stream().filter(info -> info.getTrackDate().equals(entry.getKey())).collect(Collectors.toList());
            List<IndustryScoreInfo> last = entry.getValue().stream().filter(info -> !info.getTrackDate().equals(entry.getKey())).collect(Collectors.toList());

            return current.stream().map(industry -> {
                IndustryScoreResult result = new IndustryScoreResult();
                result.setTrackDate(industry.getTrackDate());
                result.setTrackName(industry.getTrackName());
                result.setComprehensiveScore(industry.getComprehensiveScore());

                Optional<IndustryScoreInfo> lastIndustryScoreInfo = last.stream().filter(info -> info.getTrackName().equals(industry.getTrackName())).findFirst();
                result.setLastComprehensiveScore(lastIndustryScoreInfo.isPresent() ? lastIndustryScoreInfo.get().getComprehensiveScore() : "");

                return result;
            });
        })
        .collect(Collectors.toList());

这样代码更加简洁，并且利用了流式处理的优势，使得代码更加易于维护和扩展。

#include <iostream>#include <vector>#include <map>#include <set>#include <string>using namespace std;map<string, set<string>> first;void compute_first(string non_terminal, vector<vector<string>> productions) { for (auto production : productions) { if (production[0] == non_terminal) { if (production[1] == "epsilon") { first[non_terminal].insert("epsilon"); } else if (islower(production[1][0])) { first[non_terminal].insert(production[1]); } else { compute_first(production[1], productions); for (auto element : first[production[1]]) { first[non_terminal].insert(element); } } } }}int main() { vector<vector<string>> productions = { {"S", "AB"}, {"A", "aA"}, {"A", "epsilon"}, {"B", "bB"}, {"B", "epsilon"} }; for (auto production : productions) { compute_first(production[0], productions); } for (auto element : first) { cout << "First(" << element.first << ") = { "; for (auto value : element.second) { cout << value << " "; } cout << "}" << endl; } return 0;}

这段代码是一个用于计算文法中每个非终结符的 First 集的程序。

首先定义了一个名为 `first` 的 map，用于存储每个非终结符的 First 集合。然后定义了一个名为 `compute_first` 的函数，用于计算每个非终结符的 First 集合。该函数接受两个参数，一个是当前非终结符的名称，另一个是文法中所有产生式的向量。

在函数中，遍历每个产生式，如果产生式的第一个符号与当前非终结符匹配，则分三种情况进行处理：

1. 如果产生式右部第二个符号是 ε（空串），则将 ε 加入当前非终结符的 First 集中。
2. 如果产生式右部第二个符号是小写字母，则直接将该字母加入当前非终结符的 First 集中。
3. 如果产生式右部第二个符号是非终结符，则递归调用 `compute_first` 函数计算该非终结符的 First 集，然后将其加入当前非终结符的 First 集中。

最后，在 `main` 函数中，定义了文法中的所有产生式，然后遍历每个产生式，调用 `compute_first` 函数计算每个非终结符的 First 集合，并将结果输出到控制台上。