Recebendo erro tipos incompatíveis ao tentar mapear uma lista

Martin:

Eu tenho uma lista FeeAccount que eu gostaria de preencher. Eu quero usar .stream.map () para fazê-lo. O que eu consegui fazer é fazer um método que iria mapear minha lista e devolvê-lo. Eu escrevi este código usando alguns outros exemplos que eu encontrei online. Meu problema é que de alguma forma ele retorna uma lista que é incompatível com List.

Estou recebendo um erro: tipos incompatíveis. Lista necessários mas 'mapa' foi inferida a Stream: nenhuma instância (s) do tipo de variável (s) R existem para que conforma fluxo para Lista

Como eu entendo o problema é com a parte onde eu usar a cobrar (Collectors.toList ()) . Mas eu não tenho certeza. Eu não entendo ainda claramente o que os meios de mensagens de erro.

Talvez alguém pode explicar o que estou fazendo de errado? É com o .stream.map ()? Porque eu nunca usei antes. Ou talvez o problema está em outro lugar.

Method(List<contract> contractList){
 List<FeeAccount> feeAccounts = new ArrayList<>();

    feeAccounts = contractList
            .stream()
            .map(contract -> {

                List<Fee> monthlyFees=...;

                return monthlyFees.stream()
                        .map(monthlyFee -> {
                            FeeAccount account = new FeeAccount();
                            account.setFeeCode(monthlyFee.getFeeCode());
                            account.setDebtorAccount(contract.getDebtorAccount());
                            return account;
                        }).collect(Collectors.toList());
            });}

Eles foram:

Você tem duas aninhadas mapoperações. As transformadas exteriores um contractpara um List<FeeAccount>, e as transformações interiores um Feepara um FeeAccount.

Assim, seu pipeline resulta em uma Stream<List<FeeAccount>>sem uma operação de terminal.

Se você adicionar um .collect(Collectors.toList())no final, você vai ter um List<List<FeeAccount>>.

Se você deseja mesclar todas as listas internas em uma única lista de saída, você deve usar flatMap.

Para obter uma superfície plana List:

List<FeeAccount> feeAccounts = 
    contractList.stream()
                .flatMap(contract -> {
                    List<Fee> monthlyFees=...;
                    return monthlyFees.stream()
                                      .map(monthlyFee -> {
                                          FeeAccount account = new FeeAccount();
                                          account.setFeeCode(monthlyFee.getFeeCode());
                                          account.setDebtorAccount(contract.getDebtorAccount());
                                          return account;
                                      });
                })
                .collect(Collectors.toList();