Java流：对象属性更新困难

Question

我有一个包含很多字段的列表，需要使用stream在一次传递中创建一个列表。

>

我们需要将列表中的字段current标记为true，以获得输入列表中最小的正整数

输入：

[PT(pn=-1, endDate=2019-01-11, dp=MAR 2019,..),           
PT(pn=4, endDate=null, dp=APR 2019,..),        
PT(pn=6, endDate=2019-05-11, dp=MAY 2019,..)]       

输出：

[OP(pn=11, current=false, dp=MAR 2019),
 OP(pn=4, current=true, dp=APR 2019),
 OP(pn=6, current=false, dp=MAY 2019)]    

class OP{       
   Integer pn;      
   Boolean current;      
   String dp;       
} 

List<OP> filteredList11 = availablePT.get()
    .stream()
    .map(e->new OP(e.getPn(),**,e.getDp()))
    .collect(Collectors.toList());

我有点困惑，如何推导逻辑，将单个循环中最小正整数的当前标志（**）更新为true。

Answer 1

以下是您的要求：

AtomicBoolean isFirst = new AtomicBoolean(true);
    List<OP> filteredList11 = availablePT.get()
        .stream()
        .map(e->new OP(e.getPn(),**,e.getDp()))
        .sorted(Comparator.comparingInt(OP::getPn))
        .peek(e -> {
                        if (e.getPn() % 2 == 0) {
                            e.setCurrent(isFirst.getAndSet(false));
                        }
                    })
        .collect(Collectors.toList());

Answer 2

你可以这样做：

首先找到最不肯定的PT对象。

Optional<PT> latestPositive = availablePT.stream()
                             .filter(pt -> pt.getPn() > 0)
                             .min(Comparator.comparingInt(PT::getPn));

然后通过stream overainablePTlist创建OP对象。

List<OP> filteredList11 = availablePT.stream()
            .map(pt -> new OP(pt.getPn(),
                              pt.equals(latestPositive.orElse(null)), pt.getDp()))
            .collect(Collectors.toList());

如果你有兴趣在使用单流这样做：

首先编写一个自定义比较器。

 Comparator<PT> ptComparator = (o1, o2) -> {
        if (o2.getPn() < 0) {
            if (o1.getPn() > 0)
                return -1;
        } else if (o2.getPn() > 0) {
            if (o1.getPn() < 0)
                return 1;
        }
        return Integer.compare(o1.getPn(), o2.getPn());
    };

然后用你的比较器排序列表

AtomicInteger integer = new AtomicInteger(0);
 List<OP> filteredList11 = availablePT.stream()
          .sorted(ptComparator)
          .map(pt -> new OP(pt.getPn(), integer.incrementAndGet()==1, pt.getDp()))
          .collect(Collectors.toList());  

Answer 3

这是另一种方法。有一个OP构造函数，它接受一个PT并映射所有字段，加上默认设置为false的额外布尔值。

然后做这样的事情：

List<OP> ops = availablePT.stream().map(dp -> {return new OP(dp);})
 .filter(line -> line.getPn()!=null && line.getPn().doubleValue()>=0)
 .sorted(Comparator.comparingInt(OP::getPn))
 .collect(Collectors.toList());
if(ops!=null && !ops.isEmpty()) {
   ops.get(0).setCurrent(true);
}

这基本上是创建新的对象，然后过滤掉负值，然后对可能的对象进行排序，然后保证具有最小dp值的op是第一个，因此将其设置为布尔值为true