如何使用 lambdas 或流从包含另一个对象列表的对象列表中迭代和获取对象

Question

假设数据收集对象如下所示

当引擎匹配时，我需要尝试使用 java lambda 函数来获取匹配的品牌对象。

Vehicles Class
   - list of Brand
            - List of cars
                    - List of engine

Vehicles
   - Honda
         - Civic
              - Engine1
              - Engine2
         - Accord 
              - Engine11
              - Engine12
   - Toyota 
         - corolla 
              - Engine21

如果引擎类型匹配，现在我需要获取品牌名称。 例如，如果我搜索 Engine1，则需要返回 Honda 对象。

以下是代码示例： 类车：

import java.util.List;
public class Vehicle {
    private List<Brands> brands;
    public List<Brands> getBrands() {
        return brands;
    }
    public void setBrands(List<Brands> brands) {
        this.brands = brands;
    }
}

类品牌：

import java.util.List;
public class Brands {
    private String brandname;
    private List<Cars> cars;
    public String getBrandname() {
        return brandname;
    }
    public void setBrandname(String brandname) {
        this.brandname = brandname;
    }
    public List<Cars> getCars() {
        return cars;
    }
    public void setCars(List<Cars> cars) {
        this.cars = cars;
    }
}

类车：

import java.util.List;
public class Cars {
    private List<Engines> engines;
    public List<Engines> getEngines() {
        return engines;
    }
    public void setEngines(List<Engines> engines) {
        this.engines = engines;
    }
}

类引擎：

import java.util.List;
public class Engines {
    private List<String> names;
    public List<String> getNames() {
        return names;
    }
    public void setNames(List<String> names) {
        this.names = names;
    }
}

主类：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class StreamDemoMain {
    public static void main(String args[]){


        Vehicle vh = new Vehicle();

        List<Brands> brandslist =  new ArrayList<>();
        Brands brand = new Brands();
        Cars car = new Cars();
        Engines engine = new Engines();
        List<Engines> engineList = new ArrayList<>();
        List<String> engineNames = new ArrayList<>();
        List<Cars> carList = new ArrayList<>();
        brand.setBrandname("toyota");

        engineNames.add(brand.getBrandname()+"1");
        engineNames.add(brand.getBrandname()+"2");
        engine.setNames(engineNames);
        engineList.add(engine);
        car.setEngines(engineList);
        carList.add(car);
        brand.setCars(carList);
        brandslist.add(brand);

         brand = new Brands();
         car = new Cars();
         engine = new Engines();
         engineList = new ArrayList<>();
         engineNames = new ArrayList<>();
        carList = new ArrayList<>();
        brand.setBrandname("honda");

        engineNames.add(brand.getBrandname()+"1");
        engineNames.add(brand.getBrandname()+"2");
        engine.setNames(engineNames);
        engineList.add(engine);
        car.setEngines(engineList);
        carList.add(car);
        brand.setCars(carList);
        brandslist.add(brand);
        vh.setBrands(brandslist);

        Map<String,Brands> result = new HashMap<>();
             vh.getBrands().stream()
            .forEach(eachcars->{eachcars.getCars().stream()
                                .map(Cars::getEngines)
                                .flatMap(List::stream)
                                .peek(a->{System.out.println("before:: "+a.getNames().toString());})
                                .map(Engines::getNames)
                                .flatMap(List::stream)
                                .forEach(engineName -> {
                                    result.put(engineName, eachcars);
                                });
                }
                );

             //print results and validate the output object
             List<Brands> listofBrands = new ArrayList<>();
             result.entrySet().stream().forEach(values->{
                 System.out.println(values.getKey() + "  = "+ values.getValue().getBrandname());
                 if(!listofBrands.contains(values.getValue())){
                     listofBrands.add(values.getValue());
                 }
             });

             System.out.println(listofBrands.size());
    }
}

---

以上是我尝试过的代码。 早些时候我的目标是使用授权子对象列表中的键进行过滤。

现在我用它作为键来形成一个以父对象或品牌对象为值的映射。 它适用于我的数据集。没有进行空检查。

欢迎提出改进建议。

Answer 1

你遗漏了很多细节，所以我假设你有一个List<Brand> brands，并且Brand 有一个方法List<Car> getCars()，而Car 有一个方法List<Engine> getEngines()，而你已经实现了Engine.equals()。

此方法将返回具有匹配引擎的任何品牌（如果存在）：

Optional<Brand> findBrandByEngine(Engine engine) {
    return brands.stream()
            .filter(b -> b.getCars()
                    .stream()
                    .map(Car::getEngines)
                    .flatMap(List::stream)
                    .anyMatch(engine::equals))
            .findAny();
}