ArgMinMaxTest.java

package com.pholser.fn;

import org.junit.Before;
import org.junit.Test;

import java.sql.Date;
import java.util.Arrays;
import java.util.List;

import static com.pholser.fn.Functions.*;
import static java.util.Collections.*;
import static org.junit.Assert.*;

public class ArgMinMaxTest {
    private List<String> strings;
    private List<java.sql.Date> dates;

    @Before
    public void setUp() {
        strings = Arrays.asList("a", "bc", "def", "ghij");
        dates = Arrays.asList(new Date(1L), new Date(2L));
    }

    @Test
    public void stringOfMaxLength() {
        assertEquals("ghij", argMax(strings.stream(), String::length).get());
    }

    @Test
    public void indexOfStringOfMaxLength() {
        assertEquals(Integer.valueOf(3), argMax(strings, String::length).get());
    }

    @Test
    public void stringOfMaxReverseLength() {
        assertEquals("a", argMax(strings.stream(), String::length, reverseOrder()).get());
    }

    @Test
    public void indexOfStringOfMaxReverseLength() {
        assertEquals(Integer.valueOf(0), argMax(strings, String::length, reverseOrder()).get());
    }

    @Test
    public void stringOfMinLength() {
        assertEquals("a", argMin(strings.stream(), String::length).get());
    }

    @Test
    public void indexOfStringOfMinLength() {
        assertEquals(Integer.valueOf(0), argMin(strings, String::length).get());
    }

    @Test
    public void stringOfMinReverseLength() {
        assertEquals("ghij", argMin(strings.stream(), String::length, reverseOrder()).get());
    }

    @Test
    public void indexOfStringOfMinReverseLength() {
        assertEquals(Integer.valueOf(3), argMin(strings, String::length, reverseOrder()).get());
    }

    @Test
    public void noArgMaxForEmptyStream() {
        assertFalse(argMax(Arrays.<String> asList().stream(), String::length).isPresent());
    }

    @Test
    public void noIndexOfArgMaxForEmptyStream() {
        assertFalse(argMax(Arrays.<String> asList(), String::length).isPresent());
    }

    @Test
    public void noArgMinForEmptyStream() {
        assertFalse(argMin(Arrays.<String> asList().stream(), String::length).isPresent());
    }

    @Test
    public void noIndexOfArgMinForEmptyStream() {
        assertFalse(argMin(Arrays.<String> asList(), String::length).isPresent());
    }

    @Test
    public void dateOfMaxTime() {
        assertEquals(new Date(2L), argMax(dates.stream(), Date::getTime).get());
    }
}

Functions.java

package com.pholser.fn;

import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static java.util.AbstractMap.*;
import static java.util.Collections.reverseOrder;
import static java.util.Comparator.*;
import static java.util.Optional.*;

public class Functions {
    private Functions() {
        throw new UnsupportedOperationException();
    }

    public static
    <T, R extends Comparable<? super R>>
    Optional<T> argMin(
            Stream<? extends T> s,
            Function<? super T, ? extends R> fn) {

        return argMin(s, fn, naturalOrder());
    }

    public static
    <T, R>
    Optional<T> argMin(
            Stream<? extends T> s,
            Function<? super T, ? extends R> fn,
            Comparator<? super R> c) {

        return argMax(s, fn, reverseOrder(c));
    }

    public static
    <T, R extends Comparable<? super R>>
    Optional<Integer> argMin(
            List<? extends T> s,
            Function<? super T, ? extends R> fn) {

        return argMin(s, fn, naturalOrder());
    }

    public static
    <T, R>
    Optional<Integer> argMin(
            List<? extends T> s,
            Function<? super T, ? extends R> fn,
            Comparator<? super R> c) {

        return argMax(s, fn, reverseOrder(c));
    }

    public static
    <T, R extends Comparable<? super R>>
    Optional<T> argMax(
            Stream<? extends T> s,
            Function<? super T, ? extends R> fn) {

        return argMax(s, fn, naturalOrder());
    }

    public static
    <T, R>
    Optional<T> argMax(
            Stream<? extends T> s,
            Function<? super T, ? extends R> fn,
            Comparator<? super R> c) {

        Optional<SimpleEntry<T, R>> maxPair =
                s.map(item -> new SimpleEntry<>(item, fn.apply(item)))
                        .max((fst, snd) -> c.compare(fst.getValue(), snd.getValue()));
        return maxPair.isPresent() ? Optional.of(maxPair.get().getKey()) : empty();
    }

    public static
    <T, R extends Comparable<? super R>>
    Optional<Integer> argMax(
            List<? extends T> s,
            Function<? super T, ? extends R> fn) {

        return argMax(s, fn, naturalOrder());
    }

    public static
    <T, R>
    Optional<Integer> argMax(
            List<? extends T> s,
            Function<? super T, ? extends R> fn,
            Comparator<? super R> c) {

        Stream<SimpleEntry<Integer, T>> withIndex =
                IntStream.range(0, s.size()).mapToObj(i -> new SimpleEntry<>(i, s.get(i)));
        Function<SimpleEntry<Integer, T>, R> fnPrime = e -> fn.apply(e.getValue());

        Optional<SimpleEntry<Integer, T>> maxWithIndex = argMax(withIndex, fnPrime, c);
        return maxWithIndex.isPresent() ? Optional.of(maxWithIndex.get().getKey()) : empty();
    }
}