La conversión de la funcionalidad de dominio de país a Java8 Lambda

Alex Hombre:

Tengo el siguiente código que recibe toda la lista de dominios basado en los países entrantes detalles que consigo de una API REST

private static List<Domain> testDataInPlain() {
    List<Domain> allDomains = new ArrayList<>();
    List<Country> countries = buildIncomingCountries();
    List<Country> availableCountries = availableCountries();

    for (Country availableCountry : availableCountries) {
        if(countries.contains(availableCountry)) {
            List<Domain> availableDomains = getBusinessCountryDomains(availableCountry);
            if(availableDomains == null) {
                return new ArrayList<>();
            } else {
                for (Domain availableDomain : availableDomains) {
                    if(availableCountry.getName().equals(availableDomain.getCountry())) {
                        allDomains.add(availableDomain);
                    }
                }
            }
        }
    }
    return allDomains;
}

Estoy tratando de convertir el código anterior para la función Java8 Lambda, el código que he convertido hasta ahora se muestra a continuación, pero no es correcto

private static List<?> testDataInLambda() {
    List<Domain> allDomains = new ArrayList<>();
    List<Country> countries = buildIncomingCountries();
    List<Country> availableCountries = availableCountries();

    return availableCountries.stream()
            .filter(countries::contains)
            .map(country -> {
                List<Domain> availableDomains = getBusinessCountryDomains(country);
                return availableDomains;
            })
            .filter(allDomains::contains)
            .collect(Collectors.toList());
}

No soy capaz de llevar la conversión completa a Lambda ya que estoy Stucked especialmente en llevar función lambda para

if(availableCountry.getName().equals(availableDomain.getCountry()))

¿Puede alguien por favor me ayude con esto?

Mi código fuente completo se muestra a continuación

package com.example.demo;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        System.out.println(testDataInPlain());
        System.out.println(testDataInLambda());
    }

    private static List<Domain> testDataInPlain() {
        List<Domain> allDomains = new ArrayList<>();
        List<Country> countries = buildIncomingCountries();
        List<Country> availableCountries = availableCountries();

        for (Country availableCountry : availableCountries) {
            if(countries.contains(availableCountry)) {
                List<Domain> availableDomains = getBusinessCountryDomains(availableCountry);
                if(availableDomains == null) {
                    return new ArrayList<>();
                } else {
                    for (Domain availableDomain : availableDomains) {
                        if(availableCountry.getName().equals(availableDomain.getCountry())) {
                            allDomains.add(availableDomain);
                        }
                    }
                }
            }
        }
        return allDomains;
    }

    private static List<?> testDataInLambda() {
        List<Domain> allDomains = new ArrayList<>();
        List<Country> countries = buildIncomingCountries();
        List<Country> availableCountries = availableCountries();

        return availableCountries.stream()
                .filter(countries::contains)
                .map(country -> {
                    List<Domain> availableDomains = getBusinessCountryDomains(country);
                    return availableDomains;
                })
                .filter(allDomains::contains)
                .collect(Collectors.toList());
    }

    private static List<Country> buildIncomingCountries() {
        // I am mocking the below details
        List<Country> countries = new ArrayList<>();
        countries.add(new Country("IND",1));
        countries.add(new Country("USA",2));
        countries.add(new Country("GER",3));
        return countries;
    }

    private static List<Country> availableCountries() {
        // I am mocking the below details
        List<Country> countries = new ArrayList<>();
        countries.add(new Country("IND",1));
        countries.add(new Country("KEN",2));
        countries.add(new Country("GER",3));
        countries.add(new Country("FRA",4));
        countries.add(new Country("JPN",5));
        countries.add(new Country("CHN",6));
        countries.add(new Country("UAE",7));
        countries.add(new Country("IRE",8));
        return countries;
    }

    private static List<Domain> getBusinessCountryDomains(Country country) {
        // I am mocking the below details based on the country
        List<Domain> domains = new ArrayList<>();
        domains.add(new Domain(".in","IND"));
        domains.add(new Domain(".zim","ZIM"));
        domains.add(new Domain(".den","DEN"));
        domains.add(new Domain(".fra","FRA"));
        return domains;
    }
}

@Data
@AllArgsConstructor
class Country {
    private String name;
    private Integer code;
}

@Data
@AllArgsConstructor
class Domain {
    private String name;
    private String country;
}

Nikolas:

Este trabajo podría:

availableCountries.stream()
    .filter(availableCountries::contains)       // Stream<Country> of qualified countries
    .map(country -> Optional                    // attempt to map each Cuntry to Domain
        .ofNullable(availableDomains)           // Optional<List<Domain>>
        .orElse(Collections.emptyList())        // or else an empty List
        .stream()
        .filter(availableDomain -> availableDomain.getName().equals(country.getCountry()))
        .findAny()
        .orElse(null))                          // if the name doesn't match, then null
    .filter(Objects::nonNull)                   // filter the nulls out
    .collect(Collectors.toList());              // and produce a List<Domain>

La línea orElse(Collections.emptyList())asegura la totalidad Streamproduce un vacío List<Domain>ya que no Countryhabría calificado si se compara a un vacío List<Domain>.