主页 / 问题 / 1305335
Accepted
Elizaveta
Asked:2022-07-15 04:24:37 +0000 UTC2022-07-15 04:24:37 +0000 UTC

Stream.reduce java 类比

  • 772

你好）我在java流api中找不到与reduce方法类似的东西，只有这个类比与main方法相比应该有一个区别——我需要避免将整个流减少为一个对象的操作。也许可以使用收集器（因为我需要一个列表作为输出），但我不知道如何做到这一点（身份参数破坏了一切）

我真正想要实现的一个例子：

假设我有一个字符串列表，我需要将它们映射到一个流操作中的对象中，如果下一个元素满足某些条件，则将其拧到第一个。我在说什么：

class SomeProperty {
String someField;
Srring property;
//allArgsConstructor
} 

//THEN

List<SomeProperty> list = List.of(...elements...).stream()
.reduce((x,y)->{
    if(y.equals("i am property!") {
       return new SomeProperty(x, y) ;
    } else {
       return new SomeProperty(x, "default") ;
    } 
}).collect(Collectors.toList());

像这样的东西）如果您有任何想法，请分享！

java

2 个回答

  1. Best Answer

    上一个答案的发展：

    enum Data {
    FIELD, PROPERTY
}

static class SomeProperty {
    private String someField;
    private List<String> property = new ArrayList<>();

    public SomeProperty(String someField, List<String> property) {
        this.someField = someField;
        this.property = property;
    }

    public SomeProperty(String someField) {
        this.someField = someField;
    }

    @Override
    public String toString() {
        return "SomeProperty{" +
                "someField='" + someField + '\'' +
                ", property=" + String.join(", ", property) +
                '}';
    }
}

public static void main(String[] args) {

    List<SomeProperty> result = List.of(FIELD, PROPERTY, FIELD, FIELD, PROPERTY, PROPERTY, PROPERTY)
            .stream()
            .collect(Collector.of(
                    LinkedList::new,
                    (acc, v) -> {
                        if (v == FIELD) {
                            acc.offer(new SomeProperty(v.name()));
                        } else {
                            Optional.ofNullable(acc.peek()).ifPresent(p -> p.property.add(v.name()));
                        }
                    },
                    (acc1, acc2) -> {
                        acc1.addAll(acc2);
                        return acc1;
                    }));

    System.out.println(result);
}

    reduce 不太适合这种情况，因为它的累加器必须与当前元素的类型相同。因此，我建议在这种情况下使用Collector.of

    逻辑是这样的：如果当前元素是一个 Field，则创建一个具有默认属性的新 SomeProperty（本例中为空集合）并将其排队。否则，取队列的顶部（如果有的话）并向其添加属性

    堵塞：

    (acc1, acc2) -> {
    acc1.addAll(acc2);
    return acc1;
 }

    只有在使用parallelStream合并并行结果时才需要，这种情况下可以忽略。

    • 2

  2. 这是一个工作版本。它看起来很吓人，但功能范式就是它的全部。

    package yourpackage;

import java.util.ArrayList;
import java.util.List;

import static yourpackage.Main.Data.FIELD;
import static yourpackage.Main.Data.PROPERTY;

public class Main {

    enum Data {
        FIELD, PROPERTY
    }
    public static void main(String[] args) {
          List<List<Data>> result =
              List.of(FIELD, PROPERTY, FIELD, FIELD, PROPERTY, PROPERTY, PROPERTY)
              .stream()
              .map(d -> List.of(List.of(d)))
              .reduce(new ArrayList<List<Data>>(),
                  (fieldList, d) -> {
                  if (d.get(0).get(0) == FIELD) {
                      var list = new ArrayList<Data>();
                      list.add(d.get(0).get(0));
                      fieldList.add(list);
                  } else {
                      fieldList
                          .get(fieldList.size() - 1)
                          .add(d.get(0).get(0));
                  }
                  return fieldList;
                  });

          System.out.println(result);
    }
}

    结论如下 [[FIELD, PROPERTY], [FIELD], [FIELD, PROPERTY, PROPERTY, PROPERTY]]

    在下文中，“数组的数组”（响应类型）将被表示为“超数组”

    简而言之：我们想要一个超级数组，其中每个数组的第一个元素是FIELD，下一个是 PROPERTY。为此，我们将每个值包装到两个数组中，只是为了让它们的类型与超数组匹配（Java 中的强类型）。使用reduce，如果新元素是[[FIELD]]，那么我们创建一个新的视图数组[FIELD]并将其添加到超数组的末尾，如果[[PROPERTY]]，那么我们从超数组中取出最后一个数组，它表示最后一个FIELD及其属性，并添加另一个。

    另请注意，如果第一个元素是FIELD ，代码会崩溃。

    这个例子可以很容易地简化为你的任务，制作一张地图就足够了。

    • 1

相关问题