Question

我有如下代码：

List<UserDTO> result = new ArrayList<>();
UserDTO userDTO;
for (User user : users) {
    for (Individual individual : individuals) {
        if (individual.getKey().equals(user.getIndividualId())) {
            userDTO = new UserDTO();
            userDTO.setUserId(user.getUserId());
            userDTO.setFirstName(individual.getFirstName());
            userDTO.setLastName(individual.getLastName());
            result.add(utilisateurDTO);
            break;
        }
    }
}

如何使用Java 8流编写此代码？

Answer 1

未经测试，但您可以尝试类似的方法：

List<UserDTO> userDtos = 
            users.stream()
                 .map(u -> individuals.stream()
                                       .filter(indiv -> indiv.getKey()
                                                             .equals(u.getIndividualId()))
                                       .findFirst()                                                        
                                       .map(indiv -> new UserDTO(u.getUserId(), indiv.getFirstName(), indiv.getLastName()))
                                       .orElse(null))
                 .filter(Objects::nonNull)                                                         
                 .collect(Collectors.toList());

findFirst()将允许在检测到个人和用户之间的匹配时将内部迭代短路。
我在UserDTO()中引入了arg构造函数以简化其初始化。

Answer 2

将键和值存储到地图中：

Map<T, Individual> individualsMap =
                individuals.stream()
                        .collect(Collectors.toMap(Individual::getKey,
                                Function.identity(),
                                (l, r) -> l));

其中T是Individual::getKey的任何类型。

Java-8解决方案：

List<UserDTO> resultSet = 
       users.stream()
            .map(user -> Optional.ofNullable(individualsMap.get(user.getIndividualId()))
                    .map(i -> new AbstractMap.SimpleEntry<>(i, user.getUserId())).orElse(null))
            .filter(Objects::nonNull)
            .map(e -> new UserDTO(e.getValue(), e.getKey().getFirstName(), e.getKey().getLastName()))
            .collect(Collectors.toList());

java-9解决方案：

List<UserDTO> resultSet = 
        users.stream()
             .flatMap(user -> Optional.ofNullable(individualsMap.get(user.getIndividualId()))
                        .map(i -> Map.entry(i, user.getUserId())).stream())
             .map(e -> new UserDTO(e.getValue(), e.getKey().getFirstName(), e.getKey().getLastName()))
             .collect(Collectors.toList());

这假定您具有这样的构造函数：

public UserDTO(T userId, String firstName, String lastName) { ... }

其中T应该用任何类型的userId代替。

Answer 3

正如@JB Nizet的评论中所建议的那样，不要与O(n^2)一起使用，我想分两个步骤解决问题：

Map<Long, Individual> individualsMap =
        individual.stream()
                .collect(Collectors.toMap(Individual::getKey, Function.identity()));

List<UserDTO> result = users.stream()
        .filter(user -> individualsMap.containsKey(user.getKey()))
        .map(user -> {
            UserDTO userDTO = new UserDTO();
            Individual indivd = individualsMap.get(user.getKey());
            userDTO.setUserId(user.getUserId());
            userDTO.setFirstName(indivd.getFirstName());
            userDTO.setLastName(indivd.getLastName());
            return userDTO;
        }).collect(Collectors.toList());

使用流从两个数组创建一个数组

3 个答案: