如何使用Java 8 Stream实现字符串处理及Request与Response的id匹配筛选

核心实现思路 #

1. 先提取Response中所有Item的id字段，存入Set集合降低匹配时的查询复杂度
2. 遍历Request的requestIds列表，提取每个字符串第一个/后的子串，和Set中的值匹配，匹配成功则保留原始字符串

完整代码实现 #

首先补全类的合法定义（修正原代码的拼写错误、补充getter方法）：

import java.util.ArrayList;
import java.util.List;

class Item {
    private String id;
    public Item(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
}

class Request {
    private List<String> requestIds;
    public Request() {
        requestIds = new ArrayList<>();
        requestIds.add("xyz:one/first/same");
        requestIds.add("zzz:five/match/same");
        requestIds.add("xyz:different/second/different");
    }
    public List<String> getRequestIds() {
        return requestIds;
    }
}

class Response {
    private List<Item> responseIds;
    public Response() {
        responseIds = new ArrayList<>();
        Item one = new Item("xyz:ten/first/same");
        Item two = new Item("zzz:three/match/same");
        Item three = new Item("xyz:one/third/second");
        responseIds.add(one);
        responseIds.add(two);
        responseIds.add(three);
    }
    public List<Item> getResponseIds() {
        return responseIds;
    }
}

Stream 实现逻辑：

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

public class StreamDemo {
    public static void main(String[] args) {
        Request request = new Request();
        Response response = new Response();
        
        // 第一步：预提取所有响应id存入Set，匹配复杂度从O(m)降到O(1)
        Set<String> respIdSet = response.getResponseIds().stream()
                .map(Item::getId)
                .collect(Collectors.toSet());
        
        // 第二步：处理请求id列表，过滤匹配项
        List<String> result = request.getRequestIds().stream()
                .filter(requestId -> {
                    int slashIndex = requestId.indexOf("/");
                    // 兼容无/的异常场景，避免substring报错
                    if (slashIndex < 0) {
                        return false;
                    }
                    String suffix = requestId.substring(slashIndex);
                    return respIdSet.contains(suffix);
                })
                .collect(Collectors.toList());
        
        // 输出验证：结果为 [xyz:one/first/same, zzz:five/match/same]
        System.out.println("Result - " + result);
    }
}

可选优化点 #

• 如果数据量很小不需要优化性能，也可以不提前转Set，直接在filter中遍历响应列表匹配，但是效率更低，写法如下：

List<String> result = request.getRequestIds().stream()
        .filter(requestId -> {
            int slashIndex = requestId.indexOf("/");
            if (slashIndex < 0) return false;
            String suffix = requestId.substring(slashIndex);
            return response.getResponseIds().stream()
                    .anyMatch(item -> item.getId().equals(suffix));
        })
        .collect(Collectors.toList());

• 不需要并行流的场景优先用普通stream，并行流适合大数量级的场景，小数据量反而会有线程调度的额外开销。

内容的提问来源于stack exchange，提问作者Alex