Java 8如何使用lambda表达式简化for循环

我的代码中有这个方法，需要使用Java8表达式简化和减少行。 Lambda可以用于此目的，但如果没有列表作为输入，它似乎是不可能的

  public ResourceUsage[] filterResourceUsages(ResourceUsage[] resourceUsages, int role, int includeResourceType)
    throws SpiderException
  {
    ArrayList<ResourceUsage> filteredResourceUsages = new ArrayList<>();

    String[] ids = new String[resourceUsages.length];
    for (int i = 0; i < resourceUsages.length; i++)
    {
      ids[i] = resourceUsages[i].resource;
    }

    ResourceData[] resourceData = resourceToolkitAdapter.getData(ids);

    for (int i = 0; i < resourceData.length; i++)
    {
      if (resourceUsages[i].role == role && resourceData[i].basic.type == includeResourceType)
      {
        filteredResourceUsages.add(resourceUsages[i]);
      }
    }
    return filteredResourceUsages.toArray(new ResourceUsage[filteredResourceUsages.size()]);
  }

public ResourceUsage[]FilterResourceSages（ResourceUsage[]resourceUsages，int角色，int includeResourceType）
抛出SpiderException
{
ArrayList filteredResourceUsages=新建ArrayList（）；
String[]ids=新字符串[resourceUsages.length]；
for（int i=0；i

我试过使用

resourceUsages.forEach（resourceUsages.resource->do something）但是没有列表作为输入似乎是不可能的

有没有办法简化此代码？
最好使用
列表而不是数组

我还将假装可以依次调用每个资源上的
resourceToolkitAdapter.getData（）
，而不是批量调用

结果会是这样：

public List filterResourceSages（列表资源使用、int角色、int includeResourceType）
抛出SpiderException
{
返回resourceUsages.stream（）
.filter（r->r.role==角色）
.filter（r->resourceToolkitAdapter.getData（r.resource）.basic.type==includeResourceType）
.collect（Collectors.toList（））；
}   
您可以使用数组执行此操作

Arrays.stream(resourceUsages) 
            .forEach(e->System.out.print(e));

以下是原始阵列和批处理解决方案：

public ResourceUsage[] filterResourceUsages(ResourceUsage[] resourceUsages, int role, int includeResourceType)
        throws SpiderException {

    String[] ids = Stream.of(resourceUsages)
            .map(ResourceUsage::getResource)
            .toArray(String[]::new);
    Map<String, ResourceData> resourceDataMap = Stream.of(resourceToolkitAdapter.getData(ids))
            .collect(Collectors.toMap(ResourceData::id, Function.identity()));
    return Stream.of(resourceUsages)
            .filter(usage -> usage.role == usage)
            .filter(resourceDataMap::containsKey)
            .filter(usage -> resourceDataMap.get(usage.resource).basic.type == includeResourceType)
            .toArray(ResourceUsage[]::new);
}

public ResourceUsage[]FilterResourceSages（ResourceUsage[]resourceUsages，int角色，int includeResourceType）
抛出SpiderException{
String[]ids=Stream.of（resourceUsages）
.map（ResourceUsage:：getResource）
.toArray（字符串[]：：新建）；
Map resourceDataMap=Stream.of（resourceToolkitAdapter.getData（ids））
.collect（Collectors.toMap（ResourceData:：id，Function.identity（））；
返回流。of（资源使用）
.filter（用法->用法.role==用法）
.filter（resourceDataMap:：containsKey）
.filter（用法->resourceDataMap.get（用法.resource）.basic.type==includeResourceType）
.toArray（ResourceUsage[]：：新建）；
}
与Matthew的答案相反，我假设应使用一批ID调用
resourceToolkitAdapter.getData（）

public ResourceUsage[]FilterResourceSages（ResourceUsage[]resourceUsages，int角色，int includeResourceType）
抛出SpiderException
{
ResourceData[]ResourceData=resourceToolkitAdapter.getData(
Arrays.stream（resourceUsages）
.map（r->r.resource）
.toArray（字符串[]：：新建）
);
返回IntStream
.range（0，resourceData.length）
.filter（i->resourceUsages[i]。角色==角色）
.filter（i->resourceData[i].basic.type==includeResourceType）
.mapToObj（i->resourceUsages[i]）
.toArray（ResourceUsage[]：：新建）；
}
“如果没有列表作为输入，似乎不可能”
Arrays.stream（myArray）
final List id=resourceUsages.stream（）.map（e->e.resource.collect（toList（））；