Question

我有一个数据库调用，如果没有匹配的条件，则可能返回null。如果有记录匹配，则结果是包含嵌入对象列表的Pojo。我想将该Pojo转换为其嵌入对象id的列表。

Foo.class有Bars列表

public class Foo {
    private List<Bar> bars;
    //..setters & getters
}

Bar.class，我想将Foo转换为Bar的Id列表

public class Bar {
    Integer id
    //..setters & getters
}

我累了使用Optional但它总是返回到条形列表

Optional.ofNullable(fooRepo.search("some foo"))
    .map(foo -> foo.getBars()); //How can turn this into list of Bar's Id

Answer 1

我不确定我理解你的问题，但我将其解释为：

数据库查询可以返回包含对另一个对象的引用列表的对象，如果没有返回引用，则返回null。如何将该对象（或null）转换为引用对象的值列表。如果查询返回null，我想要一个空列表。

如果我的问题是正确的，那么我建议：

Optional<Foo> possibleFoo = Optional.ofNullable(dbQuery());
List<Integer> ids = possibleFoo
    .map(f -> f.bars.stream()
        .map(b -> b.id)
        .collect(Collectors.toList()))
    .orElse(Collections.EMPTY_LIST);

Answer 2

你走了：

Optional.ofNullable(foo).map(Foo::getBars).map(y -> y.stream().map(z -> z.id).collect(Collectors.toList()))

完整测试代码：

public class Test {
    public static class Bar {
        public Bar(Integer id) {
            this.id = id;
        }

        Integer id;
    }

    public static class Foo {
        private List<Bar> bars = new ArrayList<>();

        public List<Bar> getBars() {
            return bars;
        }
    }

    public static void main(String[] argb) {
        Foo nullFoo = null;
        Optional<List<Integer>> nullList = convertToIdList(nullFoo);
        System.out.println(nullList); // Optional.empty

        Foo notNullFoo = new Foo();
        notNullFoo.getBars().add(new Bar(3));
        notNullFoo.getBars().add(new Bar(4));
        notNullFoo.getBars().add(new Bar(5));
        Optional<List<Integer>> notNullList = convertToIdList(notNullFoo);
        System.out.println(notNullList); // Optional[[3, 4, 5]]
    }

    private static Optional<List<Integer>> convertToIdList(Foo foo) {
        return Optional.ofNullable(foo).map(Foo::getBars).map(y -> y.stream().map(z -> z.id).collect(Collectors.toList()));
    }
}

关键是将列表本身视为可选，但如果存在将单个列表从一种元素类型转换为另一种元素类型。如果您有任何问题，请与我们联系。

Java 8 - 如何将Pojo转换为其嵌入的Pojo属性列表

2 个答案: