Java 8: Trouver l'indice de la valeur minimale à partir d'une Liste

import static java.util.Comparator.comparingInt;

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

Comme @TagirValeev mentionne dans sa réponse, vous pouvez éviter de boxe en utilisant IntStream#reduce au lieu de Stream#min, mais au prix d'occulter l'intention:

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

Puisque c'est à des fins d'apprentissage, nous allons essayer de trouver une solution qui n'est pas juste en quelque sorte l'utilisation d'un flux, mais en fait, il fonctionne sur le courant de notre liste. Nous ne voulons pas assumer d'accès aléatoire.

Donc, il y a deux façons d'obtenir un non-trivial résultat d'un flux: collect et reduce. Ici est une solution qui utilise un collectionneur:

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();
}
};

L'écriture d'un collectionneurs crée un ennuyeux quantité de code, mais il peut facilement être généralisé à l'appui de toute valeur comparable. Aussi, l'appel de la collector a l'air très idiomatiques:

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

Si l'on change le accept et combine méthodes de toujours renvoyer une nouvelle Minimum instance (ie. si nous faisons Minimum immuable), nous pouvons également utiliser reduce:

int minIndex = list.stream().reduce(new Minimum(), Minimum::accept, Minimum::combine).getIndex();

Je sens un grand potentiel pour la parallélisation dans celui-ci.