映射（带操作）流java 8，嵌套列表

我在方法

getOptimizedTreeNodeResample（TreeNodeSample in，List listSampleRateFinal）中寻找
minimumlistPerValueOld
工作翻译到
minimumlistPerValueNew

或映射（到同一对象类型）

另一个
NodeResample
class

public class NodeResample {

  private int incrementL;
  private int decrementM;
  private int sampleRateSource;
  private int sampleRateTarget;
  private double maxPassFreq;
  private Integer filterSize;
  private Integer numResampleOperations;

  public NodeResample(int incrementL, int decrementM, int sampleRateSource, int sampleRateTarget, double maxPassFreq, Integer filterSize, Integer numResampleOperations) {
    this.incrementL = incrementL;
    this.decrementM = decrementM;
    this.sampleRateSource = sampleRateSource;
    this.sampleRateTarget = sampleRateTarget;
    this.maxPassFreq = maxPassFreq;
    this.filterSize = filterSize;
    this.numResampleOperations = numResampleOperations;
  }

  public int getIncrementL() {
    return incrementL;
  }

  public void setIncrementL(int incrementL) {
    this.incrementL = incrementL;
  }

  public int getDecrementM() {
    return decrementM;
  }

  public void setDecrementM(int decrementM) {
    this.decrementM = decrementM;
  }

  public int getSampleRateSource() {
    return sampleRateSource;
  }

  public void setSampleRateSource(int sampleRateSource) {
    this.sampleRateSource = sampleRateSource;
  }

  public int getSampleRateTarget() {
    return sampleRateTarget;
  }

  public void setSampleRateTarget(int sampleRateTarget) {
    this.sampleRateTarget = sampleRateTarget;
  }

  public double getMaxPassFreq() {
    return maxPassFreq;
  }

  public void setMaxPassFreq(double maxPassFreq) {
    this.maxPassFreq = maxPassFreq;
  }

  public Integer getFilterSize() {
    return filterSize;
  }

  public void setFilterSize(Integer filterSize) {
    this.filterSize = filterSize;
  }

  public Integer getNumResampleOperations() {
    return numResampleOperations;
  }

  public void setNumResampleOperations(Integer numResampleOperations) {
    this.numResampleOperations = numResampleOperations;
  }

  @Override
  public String toString() {
    return "NodeResample{" + "L=" + incrementL + ", M=" + decrementM
        + ", Source=" + sampleRateSource + ", Target=" + sampleRateTarget
        + ", filterSize=" + filterSize + ", numResampleOperations=" + numResampleOperations 
        + "}   ";
  }

  public String getCreator() {
    return "new NodeResample(" + incrementL + "," + decrementM + "," + sampleRateSource + "," + sampleRateTarget + "," + "0.0" + "," + filterSize + "," + numResampleOperations
        + ")";
  }

  @Override
  public int hashCode() {
    int hash = 3;
    return hash;
  }

  @Override
  public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final NodeResample other = (NodeResample) obj;
    if (this.incrementL != other.incrementL) {
      return false;
    }
    if (this.decrementM != other.decrementM) {
      return false;
    }
    if (this.sampleRateSource != other.sampleRateSource) {
      return false;
    }
    if (this.sampleRateTarget != other.sampleRateTarget) {
      return false;
    }
    if (!Objects.equals(this.filterSize, other.filterSize)) {
      return false;
    }
    return true;
  }

}

我想使用Java流进行翻译

但是，我很沮丧

  List<NodeResample> minimumlistPerValueNew = nestedListPerValue.stream()
      .min(
          Comparator.comparingLong(map(listPerValue -> {
            TreeNodeResample temp = new TreeNodeResample(null);
            temp.setNestedListsValue(out.getNestedListsValue());
            temp.addListValue(listPerValue);
            return temp.getListNodes();
          })
              //.map(node -> node::getValue)
              .filter(nodeResample -> nodeResample != null)
              .mapToLong(NodeResample::getNumResampleOperations).sum())
      )
      .orElse(Collections.emptyList());

List minimumlistprovaluenew=nestedlistprovalue.stream（）
闵先生(
Comparator.comparingLong（映射（listPerValue->{
TreeNodeResample temp=新的TreeNodeResample（空）；
temp.setNestedListsValue（out.getNestedListsValue（））；
临时addListValue（listPerValue）；
返回temp.getListNodes（）；
})
//.map（节点->节点：：getValue）
.filter（nodeResample->nodeResample！=null）
.mapToLong（NodeResample:：getNumResampleOperations）.sum（）
)
.orElse（Collections.emptyList（））；

恢复状态

public CustomObject wrapperMethod(List<CustomObject> listCustomObjects) {
  Long lastMinimum = Long.MAX_VALUE;
  CustomObject minCustomObject;
  for (CustomObject customObject : listCustomObjects) {
    Long returnedValue = anyMethodReturningLong(customObject);
    if (returnedValue < lastMinimum) {
      lastMinimum = returnedValue;
      minCustomObject = customObject;
    }
  }
  return minCustomObject;
}

//Using .reduce() method 

Optional<CustomObject> minCustomObjectList = listCustomObjects.stream()
            .reduce((lastMinimum, returnedValue) -> anyMethodReturningLong(returnedValue) < anyMethodReturningLong(lastMinimum) ? returnedValue : lastMinimum);
minCustomObjectList.ifPresent(e -> System.out.println("Minimum Object using reduce method "+e.toString()));

//Using .min() method

CustomObject minCustomObject = listCustomObjects.stream()
            .min(Comparator.comparingLong(e -> anyMethodReturningLong(e))).get();
System.out.printf("Minimum Object using min method"+minCustomObject.toString());

公共CustomObject包装器方法（列出listCustomObjects）{
Long lastmimum=Long.MAX_值；
CustomObject minCustomObject；
用于（CustomObject CustomObject:listCustomObjects）{
Long returnedValue=anyMethodReturningLong（customObject）；
if（返回值<最小值）{
lastMinimum=返回的值；
minCustomObject=customObject；
}
}
返回minCustomObject；
}
您也可以尝试解决您的问题

我从您的问题中了解到的是，有一个嵌套列表，在这些内部列表中，您希望返回符合最低标准的列表。
例如，假设我们有这样的嵌套列表
[[1,2,4]，[5,6,7,8,9,10]，[11,12]
，现在您希望返回具有最小list.size（）的列表。请尝试以下代码：

import java.util.*;
import java.util.stream.*;
public class Main
{
   public static void main(String[] args) {
    List<List<Integer>> nestedList = Arrays.asList(
      Arrays.asList(1,2,4), 
      Arrays.asList(5,6,7,8,9,2,5), 
      Arrays.asList(10,11,12,13,0));
      Optional<List<Integer>> oplist = nestedList.stream()
      .reduce((list1, list2) -> list1.size() < list2.size() ? list1 : list2);
      oplist.ifPresent(System.out::println); 
}
}

import java.util.*；
导入java.util.stream.*；
公共班机
{
公共静态void main（字符串[]args）{
List nestedList=Arrays.asList(
数组。asList（1,2,4），
数组。asList（5,6,7,8,9,2,5），
asList（10,11,12,13,0）；
可选oplist=nestedList.stream（）
.reduce（（list1，list2）->list1.size（）

输出：[1,2,4]

希望你能理解这个方法背后的想法。现在，您可以在reduce方法中尝试比较检查，并检查它是否适合您

恢复状态的解决方案

public CustomObject wrapperMethod(List<CustomObject> listCustomObjects) {
  Long lastMinimum = Long.MAX_VALUE;
  CustomObject minCustomObject;
  for (CustomObject customObject : listCustomObjects) {
    Long returnedValue = anyMethodReturningLong(customObject);
    if (returnedValue < lastMinimum) {
      lastMinimum = returnedValue;
      minCustomObject = customObject;
    }
  }
  return minCustomObject;
}

//Using .reduce() method 

Optional<CustomObject> minCustomObjectList = listCustomObjects.stream()
            .reduce((lastMinimum, returnedValue) -> anyMethodReturningLong(returnedValue) < anyMethodReturningLong(lastMinimum) ? returnedValue : lastMinimum);
minCustomObjectList.ifPresent(e -> System.out.println("Minimum Object using reduce method "+e.toString()));

//Using .min() method

CustomObject minCustomObject = listCustomObjects.stream()
            .min(Comparator.comparingLong(e -> anyMethodReturningLong(e))).get();
System.out.printf("Minimum Object using min method"+minCustomObject.toString());

//使用.reduce（）方法
可选minCustomObjectList=listCustomObjects.stream（）
.reduce（（lastMinimum，returnedValue）->anyMethodReturningLong（returnedValue）System.out.println（“使用reduce方法的最小对象”+e.toString（））；
//使用.min（）方法
CustomObject minCustomObject=listCustomObjects.stream（）
.min（Comparator.comparingLong（e->anyMethodReturningLong（e））.get（）；
System.out.printf（“使用最小方法的最小对象”+minCustomObject.toString（））；
太多无法自我理解的片段。e、 g.
.getListNodes（）
，
out.getNestedListValue（）
。。。你能分享这里使用的POJO和方法的签名吗？从外观上看，我可能过于简化了，看起来像这样
List minimumlistPerValueNew=nestedListPerValue.stream（）.min（Comparator.comparingLong（a->a.stream（）.map（node->node.getValue（））.stream（）.filter（Objects:：nonNull）.map（nodeResample->（long）nodeResample.getNumResampleOperations（））.mapToLong（long:：longValue.sum（））.orElse（Collections.emptyList（））
当您编辑代码以共享它时，您可能可以编译的代码与您在问题中共享的代码不一致，而问题中的代码没有编译。可能需要解决此问题以将问题标记为清楚。请检查恢复的情况请检查恢复的情况SITUATION@Anita现在检查，非常非常感谢。非常感谢您的时间和回复。明天我将进行测试（不幸的是，我现在无法测试，因为我的主代码已更改），但看起来这是一个不错的解决方案。
import java.util.*;
import java.util.stream.*;
public class Main
{
   public static void main(String[] args) {
    List<List<Integer>> nestedList = Arrays.asList(
      Arrays.asList(1,2,4), 
      Arrays.asList(5,6,7,8,9,2,5), 
      Arrays.asList(10,11,12,13,0));
      Optional<List<Integer>> oplist = nestedList.stream()
      .reduce((list1, list2) -> list1.size() < list2.size() ? list1 : list2);
      oplist.ifPresent(System.out::println); 
}
}

//Using .reduce() method 

Optional<CustomObject> minCustomObjectList = listCustomObjects.stream()
            .reduce((lastMinimum, returnedValue) -> anyMethodReturningLong(returnedValue) < anyMethodReturningLong(lastMinimum) ? returnedValue : lastMinimum);
minCustomObjectList.ifPresent(e -> System.out.println("Minimum Object using reduce method "+e.toString()));

//Using .min() method

CustomObject minCustomObject = listCustomObjects.stream()
            .min(Comparator.comparingLong(e -> anyMethodReturningLong(e))).get();
System.out.printf("Minimum Object using min method"+minCustomObject.toString());