Question

说我有一个包含元素(34, 11, 98, 56, 43)的列表。

使用Java 8流，如何找到列表中最小元素的索引（例如，在这种情况下为1）？

我知道这可以使用list.indexOf(Collections.min(list))在Java中轻松完成。但是，我正在寻找类似Scala的解决方案，我们可以简单地说List(34, 11, 98, 56, 43).zipWithIndex.min._2来获取最小值的索引。

是否可以使用流或lambda表达式（比如Java 8特定功能）来实现相同的结果。

注意：这仅用于学习目的。我在使用Collections实用程序方法时没有任何问题。

Answer 1

import static java.util.Comparator.comparingInt;

int minIndex = IntStream.range(0,list.size()).boxed()
            .min(comparingInt(list::get))
            .get();  // or throw if empty list

@TagirValeev在his answer中提及，您可以使用IntStream#reduce代替Stream#min来避免装箱，但代价是模糊意图：

int minIdx = IntStream.range(0,list.size())
            .reduce((i,j) -> list.get(i) > list.get(j) ? j : i)
            .getAsInt();  // or throw

Answer 2

你可以这样做：

int indexMin = IntStream.range(0, list.size())
                .mapToObj(i -> new SimpleEntry<>(i, list.get(i)))
                .min(comparingInt(SimpleEntry::getValue))
                .map(SimpleEntry::getKey)
                .orElse(-1);

如果列表是随机访问列表，get是一个恒定时间操作。 API缺少标准元组类，因此我使用SimpleEntry类中的AbstractMap作为替代。

因此IntStream.range从列表中生成索引流，从中将每个索引映射到其对应的值。然后通过在值（列表中的值）上提供比较器来获得最小元素。从那里，您可以将Optional<SimpleEntry<Integer, Integer>>映射到从中获取索引的Optional<Integer>（如果可选项为空，则为-1）。

顺便说一下，我可能会使用一个简单的for循环来获取最小值的索引，因为min / indexOf的组合会在列表上传递2个。

您可能还有兴趣查看Zipping streams using JDK8 with lambda (java.util.stream.Streams.zip)

Answer 3

由于这是出于学习目的，让我们尝试找到一个解决方案，它不仅仅以某种方式使用流，而且实际上在我们列表的流上工作。我们也不想假设随机访问。

因此，有两种方法可以从流中获取非平凡的结果：collect和reduce。 Here是一个使用收集器的解决方案：

class Minimum {
    int index = -1; 
    int range = 0;
    int value;

    public void accept(int value) {
        if (range == 0 || value < this.value) {
            index = range;
            this.value = value;
        }
        range++;
    }

    public Minimum combine(Minimum other) {
        if (value > other.value) {
            index = range + other.index;
            value = other.value;
        }
        range += other.range;
        return this;
    }

    public int getIndex() {
        return index;
    }
}

static Collector<Integer, Minimum, Integer> MIN_INDEX = new Collector<Integer, Minimum, Integer>() {
        @Override
        public Supplier<Minimum> supplier() {
            return Minimum::new;
        }
        @Override
        public BiConsumer<Minimum, Integer> accumulator() {
            return Minimum::accept;
        }
        @Override
        public BinaryOperator<Minimum> combiner() {
           return Minimum::combine;
        }
        @Override
        public Function<Minimum, Integer> finisher() {
            return Minimum::getIndex;
        }
        @Override
        public Set<Collector.Characteristics> characteristics() {
            return Collections.emptySet();
        }
    };

编写收集器会产生令人讨厌的代码量，但可以很容易地推广它以支持任何可比较的值。此外，调用收藏家看起来非常惯用：

List<Integer> list = Arrays.asList(4,3,7,1,5,2,9);
int minIndex = list.stream().collect(MIN_INDEX);

如果我们更改accept和combine方法以始终返回新的Minimum实例（即如果我们使Minimum不可变），我们也可以使用{{ 1}}：

reduce

我觉得这个并行化的潜力很大。

Answer 4

以下是使用我的StreamEx库的两种可能的解决方案：

int idx = IntStreamEx.ofIndices(list).minBy(list::get).getAsInt();

或者：

int idx = EntryStream.of(list).minBy(Entry::getValue).get().getKey();

内部的第二个解决方案非常接近@AlexisC提出的解决方案。第一个可能是最快的，因为它不使用拳击（internally它是一个减少操作。）

不使用第三方代码@ Misha的回答对我来说是最好的。

Java 8：从List中查找最小值索引

4 个答案: