Konvertieren Stream IntStream

Merke ich, Sie versuchen zu vermeiden, einen Komparator, aber Sie könnte verwenden der built-in für diese durch die Bezugnahme auf Integer.compareTo:

private static int getHighestValue(Map<Character, Integer> countMap) {
    return countMap.values().stream().max(Integer::compareTo).get();
}

Oder wie @fge schlägt vor, mit ::compare:

private static int getHighestValue(Map<Character, Integer> countMap) {
    return countMap.values().stream().max(Integer::compare).get();
}

Wenn die Frage ist "Kann ich vermeiden, durch converter während der Konvertierung von Stream<T> zu IntStream?" eine mögliche Antwort wäre "Es gibt keine Möglichkeit in Java zu machen, wie conversion-Typ-sicher und machen es Teil der Stream - Schnittstelle zur gleichen Zeit".

In der Tat-Methode wandelt Stream<T> zu IntStream ohne Konverter könnte so ausgesehen:

public interface Stream<T> {
    //other methods

    default IntStream mapToInt() {
        Stream<Integer> intStream = (Stream<Integer>)this;
        return intStream.mapToInt(Integer::intValue);
    }
}

So wird es wohl genannt werden, auf Stream<Integer> und nicht andere Arten von streams. Aber da die streams sind lazy ausgewertet und aufgrund der type erasure (denken Sie daran, dass Stream<T> ist generisch) code wird nicht an der Stelle, wo Strom verbraucht wird, die möglicherweise weit von der mapToInt() nennen. Und es wird nicht in einer Weise, die äußerst schwierig zu lokalisieren die Quelle des Problems.

Angenommen, Sie haben code:

public class IntStreamTest {

    public static void main(String[] args) {
        IntStream intStream = produceIntStream();
        consumeIntStream(intStream);
    }

    private static IntStream produceIntStream() {
        Stream<String> stream = Arrays.asList("1", "2", "3").stream();
        return mapToInt(stream);
    }

    public static <T> IntStream mapToInt(Stream<T> stream) {
        Stream<Integer> intStream = (Stream<Integer>)stream;
        return intStream.mapToInt(Integer::intValue);
    }

    private static void consumeIntStream(IntStream intStream) {
        intStream.filter(i -> i >= 2)
                .forEach(System.out::println);
    }
}

Wird es scheitern, auf consumeIntStream() Anruf mit:

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at java.util.stream.ReferencePipeline$4$1.accept(ReferencePipeline.java:210)
    at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)
    at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
    at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
    at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)
    at java.util.stream.ForEachOps$ForEachOp$OfInt.evaluateSequential(ForEachOps.java:189)
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
    at java.util.stream.IntPipeline.forEach(IntPipeline.java:404)
    at streams.IntStreamTest.consumeIntStream(IntStreamTest.java:25)
    at streams.IntStreamTest.main(IntStreamTest.java:10)

Mit diesem stacktrace sind Sie in der Lage, schnell zu identifizieren, dass das problem in produceIntStream() weil mapToInt() genannt wurde auf den stream von der falschen Art?

Natürlich kann man schreiben, die Umwandlung Methode, die geben Sie sicher, weil Sie akzeptiert Beton Stream<Integer>:

public static IntStream mapToInt(Stream<Integer> stream) {
    return stream.mapToInt(Integer::intValue);
}

//usage
IntStream intStream = mapToInt(Arrays.asList(1, 2, 3).stream())

aber es ist nicht sehr bequem, weil es bricht fluent interface Art des streams.

BTW:

Kotlin-Erweiterung-Funktionen ermöglichen das aufrufen, einige code, wie es ist ein Teil der Klasse " - Schnittstelle. So sind Sie in der Lage, um diese Art-die sichere Methode als Stream<java.lang.Integer>'s Methode:

//"adds" mapToInt() to Stream<java.lang.Integer>
fun Stream<java.lang.Integer>.mapToInt(): IntStream {
    return this.mapToInt { it.toInt() }
}

@Test
fun test() {
    Arrays.asList<java.lang.Integer>(java.lang.Integer(1), java.lang.Integer(2))
            .stream()
            .mapToInt()
            .forEach { println(it) }
}