Java 用lambdaj映射两个ArrayList？

我有两节课

public class User {
    private int _Id;
    private String _FirstName;
    private String _LastName;}

及

我有一组

用户[]

和

卡[]

。我想创造

---

HashMap

其中

User.\u Id==Card.\u UserId

和字符串（在HashMap中）是来自Cards的

\u Serial

。。。我想我可以使用lambdaj，但我不知道如何使用..

不幸的是，我不知道lambdaj，因此我无法提供使用lambdaj的解决方案。 但我认为，使用纯Java可以通过两个步骤合理、优雅、有效地解决这个问题

• 第一步将User.\u Id映射到User
• 第二步使用第一个映射到映射卡。\u Serial to User

我没有测试代码，但我非常乐观它能工作；-）

因为我不喜欢数组，所以我使用用户列表和卡片作为输入

希望这有帮助

public class CardToUserMapper {

public Map<String, User> mapCardsToUser(
        final List<User> users,
        final List<Card> cards) {

    Map<Integer, User> idToUser = 
            users.stream()
            .collect(Collectors.toMap(
                    u -> u.getId(), 
                    u -> u));

    Map<String, User> serialToUser = 
            cards.stream()
            .collect(Collectors.toMap(
                    c -> c.getSerial(),
                    c -> idToUser.get(c.getUserId())));

    return serialToUser;
}

公共类CardToUserMapper{
公共地图映射卡用户(
最终用户名单，
最终名单（卡）{
映射idToUser=
users.stream（）
.collect（collector.toMap）(
u->u.getId（），
u->u）；
映射序列化器=
卡片流（）
.collect（collector.toMap）(
c->c.getSerial（），
c->idToUser.get（c.getUserId（））；
返回序列化器；
}

}

如果你喜欢它更浓缩，你可以这样做：

public class CardToUserMapper {

public Map<String, User> mapCardsToUser(final List<User> users,
        final List<Card> cards) {

    return mapSerialToUser(cards, mapUserIdToUser(users));
}

private Map<String, User> mapSerialToUser(final List<Card> cards,
        final Map<Integer, User> idToUser) {

    return map(cards, c -> c.getSerial(), c -> idToUser.get(c.getUserId()));

}

private Map<Integer, User> mapUserIdToUser(final List<User> users) {

    return map(users, u -> u.getId(), u -> u);
}

private <S, T, U> Map<T, U> map(final List<S> listOfS, final Function<S, T> funcStoT,
        final Function<S, U> funcStoU) {

    return listOfS.stream().collect(Collectors.toMap(funcStoT, funcStoU));

}

公共类CardToUserMapper{
公共地图mapCardsToUser（最终用户列表，
最终名单（卡）{
返回mapSerialToUser（卡片，mapUserIdToUser（用户））；
}
专用地图序列器（最终列表卡，
最终地图（idToUser）{
返回映射（cards，c->c.getSerial（），c->idToUser.get（c.getUserId（））；
}
私有地图mapUserIdToUser（最终用户列表）{
返回映射（用户，u->u.getId（），u->u）；
}
私有映射图（最终列表列表、最终函数functstot、，
最终函数（funcStoU）{
返回listOfS.stream（）.collect（Collectors.toMap（funcStoT，funcStoU））；
}

---

}不幸的是，我不知道lambdaj，所以我无法提供使用lambdaj的解决方案。 但我认为，使用纯Java可以通过两个步骤合理、优雅、有效地解决这个问题

• 第一步将User.\u Id映射到User
• 第二步使用第一个映射到映射卡。\u Serial to User

我没有测试代码，但我非常乐观它能工作；-）

因为我不喜欢数组，所以我使用用户列表和卡片作为输入

希望这有帮助

public class CardToUserMapper {

public Map<String, User> mapCardsToUser(
        final List<User> users,
        final List<Card> cards) {

    Map<Integer, User> idToUser = 
            users.stream()
            .collect(Collectors.toMap(
                    u -> u.getId(), 
                    u -> u));

    Map<String, User> serialToUser = 
            cards.stream()
            .collect(Collectors.toMap(
                    c -> c.getSerial(),
                    c -> idToUser.get(c.getUserId())));

    return serialToUser;
}

公共类CardToUserMapper{
公共地图映射卡用户(
最终用户名单，
最终名单（卡）{
映射idToUser=
users.stream（）
.collect（collector.toMap）(
u->u.getId（），
u->u）；
映射序列化器=
卡片流（）
.collect（collector.toMap）(
c->c.getSerial（），
c->idToUser.get（c.getUserId（））；
返回序列化器；
}

}

如果你喜欢它更浓缩，你可以这样做：

public class CardToUserMapper {

public Map<String, User> mapCardsToUser(final List<User> users,
        final List<Card> cards) {

    return mapSerialToUser(cards, mapUserIdToUser(users));
}

private Map<String, User> mapSerialToUser(final List<Card> cards,
        final Map<Integer, User> idToUser) {

    return map(cards, c -> c.getSerial(), c -> idToUser.get(c.getUserId()));

}

private Map<Integer, User> mapUserIdToUser(final List<User> users) {

    return map(users, u -> u.getId(), u -> u);
}

private <S, T, U> Map<T, U> map(final List<S> listOfS, final Function<S, T> funcStoT,
        final Function<S, U> funcStoU) {

    return listOfS.stream().collect(Collectors.toMap(funcStoT, funcStoU));

}

公共类CardToUserMapper{
公共地图mapCardsToUser（最终用户列表，
最终名单（卡）{
返回mapSerialToUser（卡片，mapUserIdToUser（用户））；
}
专用地图序列器（最终列表卡，
最终地图（idToUser）{
返回映射（cards，c->c.getSerial（），c->idToUser.get（c.getUserId（））；
}
私有地图mapUserIdToUser（最终用户列表）{
返回映射（用户，u->u.getId（），u->u）；
}
私有映射图（最终列表列表、最终函数functstot、，
最终函数（funcStoU）{
返回listOfS.stream（）.collect（Collectors.toMap（funcStoT，funcStoU））；
}

---

}

将两个列表压缩在一起，然后映射到压缩后的列表上。我相信90%的站点Java能够压缩列表。可能是两个列表的重复压缩，然后映射到压缩列表上。我相信90%的网站Java都有压缩列表的能力。可能是重复的事实上，我在发布这个答案时没有看到android标签：-S我不确定这是否适用于android。。。但我相信，很快就会有人告诉我！事实上，当我发布这个答案时，我没有看到android标签：-S我不确定这是否适用于android。。。但我相信，很快就会有人告诉我！