相关疑难解决方法(0)

我有一个ListA,B,C.

C reduce A reduce B != A reduce B reduce C (但是,减少(B减少C)是可以的).

换句话说,我的还原操作是关联的,但不是可交换的.

java是否对有序顺序流(例如列表中的默认流)执行减少将始终根据遭遇顺序进行减少？也就是说,java会重新排序减少(这样B减少A而不是A减少B)？

(希望这很清楚).

编辑添加一个小演示,也许有助于澄清

Stream.of(" cats ", " eat ", " bats ")
  .reduce("", (a, b) -> a + b); // cats eat bats

有了上述,输出可能是"蝙蝠猫吃"​​或"吃蝙蝠猫"？是否在规范的某处保证了？

我有以下几点：

LinkedList<Integer> ints = new LinkedList();
//fill it with some ints
Stream<Integer> stream = ints.stream();
//process the stream in some way

我的问题是，是否可以保证流的处理顺序与底层相同LinkedList？我阅读了文档，但没有关于订购的任何信息。

就我而言，保留订单至关重要。

因此，在当前场景中，我们有一组 API，如下所示：

Consumer<T> start();
Consumer<T> performDailyAggregates();
Consumer<T> performLastNDaysAggregates();
Consumer<T> repopulateScores();
Consumer<T> updateDataStore();

通过这些，我们的调度程序之一执行任务，例如

private void performAllTasks(T data) {
    start().andThen(performDailyAggregates())
            .andThen(performLastNDaysAggregates())
            .andThen(repopulateScores())
            .andThen(updateDataStore())
            .accept(data);
}

在回顾这一点时，我想到了一个更灵活的实现¹来执行如下任务：

// NOOP in the context further stands for  'anything -> {}'
private void performAllTasks(Stream<Consumer<T>> consumerList, T data) {
    consumerList.reduce(NOOP, Consumer::andThen).accept(data);
}

现在让我想到的一点是 Javadoc 清楚地指出

accumulator - 用于组合两个值的关联的、无干扰的、无状态的函数

接下来我在想如何确保 java8 流中的处理顺序？要订购（处理顺序是一样的遭遇顺序）！

好的，流产生了 List将被排序，除非在以下实现parallel之前创建流reduce。²

private void performAllTasks(List<Consumer<T>> consumerList, T data) {
    consumerList.stream().reduce(NOOP, Consumer::andThen).accept(data); …

我想使用Java 8技巧在一行中执行以下操作.

鉴于此对象定义:

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class MyObj {
    private String id;
    private Double value;
}

和a List<MyObj> objects,我想获得一个List<String> objectIds是第一个列表中所有id对象的列表 - 以相同的顺序.

我可以使用Java中的循环来做到这一点,但我相信在Java8中应该有一个单行的lambda可以做到这一点.我无法在网上找到解决方案.也许我没有使用正确的搜索词.

有人可以为这个变换建议一个lambda或另一个单行程吗？

对于我的例子,有汽车对象,并发现基于模型的最小和最大价格值(分组依据).

List<Car> carsDetails = UserDB.getCarsDetails();
Map<String, DoubleSummaryStatistics> collect4 = carsDetails.stream()
                .collect(Collectors.groupingBy(Car::getMake, Collectors.summarizingDouble(Car::getPrice)));
collect4.entrySet().forEach(e->System.out.println(e.getKey()+" "+e.getValue().getMax()+" "+e.getValue().getMin()));

output :
Lexus 94837.79 17569.59
Subaru 96583.25 8498.41
Chevrolet 99892.59 6861.85

但我找不到哪个车对象有最高和最低价格.我怎样才能做到这一点？

我试图了解parallelStream()java 8 中的行为。这是我的示例代码。

List<Person> javaProgrammers = new ArrayList<Person>() {
    {
        add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));
        add(new Person("Tamsen", "Brittany", "Java programmer", "female", 33, 1500));
        add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));
        add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));
        add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));
        add(new Person("Maude", "Jaimie", "Java programmer", "female", 33, 1900));
        add(new Person("Shawn", "Randall", "Java programmer", "male", 33, 2300));
        add(new Person("Jayden", "Corrina", "Java programmer", "female", 33, 1700));
        add(new Person("Palmer", "Dene", "Java …

我已经订购了 LocalDateTime 列表，我需要在特定日期的午夜将其拆分。两个新列表中元素的顺序不应更改。

List<LocalDateTime> l = Arrays.asList(LocalDateTime.of(2017,10,24,7,0,0),LocalDateTime.of(2017,10,24,8,0,0),LocalDateTime.of(2017,10,25,7,0,0),LocalDateTime.of(2017,10,25,9,0,0));

Collectors.partitioningBy 是否保证订单将被保留？

l.stream().collect(Collectors.partitioningBy(t-> t.isAfter(LocalDateTime.of(2017,10,25,0,0,0))))

输出：

{false=[2017-10-24T07:00, 2017-10-24T08:00], true=[2017-10-25T07:00, 2017-10-25T09:00]}

我已经解决了相关问题，例如如何确保 java8 流中的处理顺序？，我仍然不完全清楚输出元素的顺序。因此，请澄清我的以下疑问。

 Integer[] intArray = {1, 2, 3, 4, 5, 6, 7, 8 };
            List<Integer> listOfIntegers =
                new ArrayList<>(Arrays.asList(intArray));
       listOfIntegers
            .parallelStream()
             .unordered()
            .forEachOrdered(e -> System.out.print(e + " "));

我认为至少在理论上（或根据 java 规范）它可以按比 1、2、3、4、5、6、7、8 的随机顺序打印。我说得对吗？

还有一个相关的问题——相遇顺序保留的决定是在什么执行点做出的？更准确地说 - 整个流管道 ORDER 特性的评估是否在执行开始之前通过源、中间操作和终端操作的特性完成？

我有一个Stream作为方法的参数.我不知道它是否平行.我怎样才能保证顺序执行呢？

(没有if/else/pls的实例)

谢谢

我有一个名为 Instance 的对象，它有 2 个字段，一个特征数组（这是另一个对象），表示数据集中的列，例如年龄、性别、类别等；和它们的值（即一个数字）。我还实现了一个自定义比较器，它可以根据实例的特定功能对这些对象的列表进行排序，如下所示：

Comparator<Instance> comparator = Comparator.comparing(c -> c.get(feature));
Instance[] sorted = instList.stream().sorted(comparator).toArray(Instance[]::new);

现在，这段代码工作正常，但是，在很多情况下，我排序的特征与另一个实例具有相同的值。在这种情况下，Java如何决定如何继续对列表进行排序？