Сравните список различных объектов и создайте новый список объектов в java8, используя Stream

Question

Может ли кто-нибудь помочь мне преобразовать приведенный ниже код в стандарты Java 8 с использованием потоков.

Переберите список CustomerRelationship и список клиентов, сравните customerRelationShip firstName с customer firstName. если он совпадает, то создайте объект BusinessCustomer, используя customerRelationShip и объект customer, и добавьте его в businessCustomerList. если совпадений нет, создайте BusinessCustomer с помощью customerRelationShip и добавьте его в businessCustomerList.

List<BusinessCustomer> businessCustomers = new ArrayList<BusinessCustomer>();

List<CustomerRelationship> customerRelationshipList = new ArrayList<CustomerRelationship>();

       List<Customer> customerList = new ArrayList<Customer>();

        for (CustomerRelationship customerRelationship: customerRelationshipList) {
            int temp = 0;
            for (Customer customer:customerList){
                if(customer.getFirstName().equalsIgnoreCase(customerRelationship.getFirstName()))
                {
                    temp++;
                    BusinessCustomer b = new BusinessCustomer();
                    b.setAge(customer.getAge());
                    b.setFirstName(customerRelationship.getFirstName());
                    b.setLastName(customerRelationship.getLastName());
                    businessCustomers.add(b);
                }
            }
            if(temp == 0) {
                BusinessCustomer b = new BusinessCustomer();                
                b.setFirstName(customerRelationship.getFirstName());
                b.setLastName(customerRelationship.getLastName());
                businessCustomers.add(b);
            }
        }

Я разработал что-то вроде этого, используя потоки.

List<CustomerRelationship> customerRelationshipList = Fetch from the Table (CustomerRelationship)
       List<Customer> customerList = Fetch from the Table (Customer)
       List<BusinessCustomer> businessCustomers = customerRelationshipList.stream()
                .flatMap(c -> customerList.stream()
                .filter((d -> (c.getFirstName()
                                .equals(d.getFirstName()))
                        ))
                        .map(d -> new BusinessCustomer(c.getFirstName(),c.getLastName(),d.getAge()))
                .collect(Collectors.toList());

Приведенный выше код создает businessCustomers, только когда customerRelationship firstName совпадает с firstName клиента. Ожидание: я хочу создать businessCustomers, даже если нет совпадений, с помощью объекта customerRelationship (пожалуйста, проверьте приведенный выше код foreach, который делает это).

Answer 1

public List<BusinessCustomer> listBusinessCustomers(List<CustomerRelationship> customerRelationships, List<Customer> customers) {
    return customerRelationships.stream()
        .flatMap(cr -> streamBusinessCustomers(customers, cr.getFirstName(), cr.getLastName()))
        .collect(Collectors.toList());
}

private Stream<BusinessCustomer> streamBusinessCustomers(List<Customer> customers, String firstName, String lastName) {
    List<Customer> sameFirstNameCustomers = customers.stream()
        .filter(customer -> customer.getFirstName().equalsIgnoreCase(firstName))
        .collect(Collectors.toList());

    if (sameFirstNameCustomers.size() == 0) {
        return Stream.of(new BusinessCustomer(firstName, lastName));
    }

    return sameFirstNameCustomers.stream()
        .map(customer -> new BusinessCustomer(firstName, lastName, customer.getAge()));
}

Answer 2

Я считаю, что подойдет любой из следующих двух подходов:

Этот первый использует Stream.concat, что позволяет вам соединить два потока вместе.

    Stream<BusinessCustomer> matches = customerRelationships.stream()
            .flatMap(relationship -> customers.stream()
                    .filter(customer -> customer.getFirstName().equalsIgnoreCase(relationship.getFirstName()))
                    .map(customer -> new BusinessCustomer(relationship.getFirstName(), relationship.getLastName(), customer.getAge())));

    Stream<BusinessCustomer> nonMatches = customerRelationships.stream()
            .filter(relationship -> customers.stream().noneMatch(customer -> customer.getFirstName().equalsIgnoreCase(relationship.getFirstName())))
            .map(relationship -> new BusinessCustomer(relationship.getFirstName(), relationship.getLastName()));

    List<BusinessCustomer> result = Stream.concat(matches, nonMatches)
            .collect(Collectors.toList());

В качестве альтернативы вы можете не создавать два промежуточных объекта matches и nonMatches Stream и просто поместить эти операторы в Stream.concat.

Другой способ, который, я думаю, сработает, следующий:

    customerRelationships.stream()
            .flatMap(relationship -> {
                boolean noneMatch = customers.stream().noneMatch(customer -> customer.getFirstName().equalsIgnoreCase(relationship.getFirstName()));
                if (noneMatch) {
                    return Stream.of(new BusinessCustomer(relationship.getFirstName(), relationship.getLastName()));
                } else {
                    return customers.stream()
                            .filter(customer -> customer.getFirstName().equalsIgnoreCase(relationship.getFirstName()))
                            .map(customer -> new BusinessCustomer(relationship.getFirstName(), relationship.getLastName(), customer.getAge()));
                }
            })
            .collect(Collectors.toList());

Кроме того, мне еще предстоит протестировать эти два подхода, поэтому обязательно выполните их через свой собственный набор тестов.