Warum ist String.chars () ein Stream von Ints in Java 8?

In Java 8 gibt es eine neue Methode, String.chars()die einen Stream von ints ( IntStream) zurückgibt , der die Zeichencodes darstellt. Ich denke, viele Leute würden charhier stattdessen einen Strom von s erwarten . Was war die Motivation, die API so zu gestalten?

Wie bereits erwähnt, bestand die Entwurfsentscheidung dahinter darin, die Explosion von Methoden und Klassen zu verhindern.

Persönlich denke ich jedoch, dass dies eine sehr schlechte Entscheidung war, und es sollte, da sie keine CharStreamvernünftigen, anderen Methoden treffen wollen chars(), als ich denken würde:

• Stream<Character> chars(), das gibt einen Strom von Box-Zeichen, die einige leichte Leistungseinbußen haben.
• IntStream unboxedChars(), die für den Leistungscode verwendet werden würde.

Jedoch , anstatt sich auf , warum es auf diese Weise zur Zeit geschehen ist, ich glaube , diese Antwort auf zeigt eine Art und Weise konzentrieren sollte es mit der API zu tun , dass wir mit Java 8 bekommen haben.

In Java 7 hätte ich es so gemacht:

for (int i = 0; i < hello.length(); i++) {
    System.out.println(hello.charAt(i));
}

Und ich denke, eine vernünftige Methode, dies in Java 8 zu tun, ist die folgende:

hello.chars()
        .mapToObj(i -> (char)i)
        .forEach(System.out::println);

Hier erhalte ich eine IntStreamund ordne sie über das Lambda einem Objekt zu. Dadurch i -> (char)iwird sie automatisch in eine Box verpackt. Stream<Character>Dann können wir tun, was wir wollen, und weiterhin Methodenreferenzen als Plus verwenden.

Sei dir aber bewusst, dass du jedoch mapToObj, dass Sie mapnichts tun müssen , wenn Sie vergessen und verwenden , dann wird sich nichts beschweren, aber Sie werden trotzdem mit einem enden IntStream, und Sie werden sich möglicherweise nicht mehr fragen, warum die ganzzahligen Werte anstelle der Zeichenfolgen gedruckt werden, die die Zeichen darstellen.

Andere hässliche Alternativen für Java 8:

Wenn Sie in einer IntStreamDatei bleiben und diese letztendlich drucken möchten, können Sie keine Methodenreferenzen mehr zum Drucken verwenden:

hello.chars()
        .forEach(i -> System.out.println((char)i));

Darüber hinaus funktioniert die Verwendung von Methodenreferenzen auf Ihre eigene Methode nicht mehr! Folgendes berücksichtigen:

private void print(char c) {
    System.out.println(c);
}

und dann

hello.chars()
        .forEach(this::print);

Dies führt zu einem Kompilierungsfehler, da möglicherweise eine verlustbehaftete Konvertierung vorliegt.

Fazit:

Die API wurde auf diese Weise entwickelt, weil sie nicht hinzugefügt werden CharStreamsoll. Ich persönlich denke, dass die Methode a zurückgeben sollte Stream<Character>, und die Problemumgehung besteht derzeit darin, mapToObj(i -> (char)i)auf a IntStreamzu arbeiten, um ordnungsgemäß mit ihnen arbeiten zu können.

Die Antwort von Skiwi deckte bereits viele wichtige Punkte ab. Ich werde etwas mehr Hintergrundinformationen ausfüllen.

Das Design einer API besteht aus einer Reihe von Kompromissen. In Java besteht eines der schwierigen Probleme darin, sich mit Entwurfsentscheidungen zu befassen, die vor langer Zeit getroffen wurden.

Primitive sind seit 1.0 in Java. Sie machen Java zu einer "unreinen" objektorientierten Sprache, da die Grundelemente keine Objekte sind. Das Hinzufügen von Grundelementen war meines Erachtens eine pragmatische Entscheidung, die Leistung auf Kosten der objektorientierten Reinheit zu verbessern.

Dies ist ein Kompromiss, mit dem wir heute, fast 20 Jahre später, noch leben. Die in Java 5 hinzugefügte Autoboxing-Funktion beseitigte größtenteils die Notwendigkeit, den Quellcode mit Box- und Unboxing-Methodenaufrufen zu überladen, aber der Overhead ist immer noch vorhanden. In vielen Fällen fällt es nicht auf. Wenn Sie jedoch das Boxen oder Entpacken innerhalb einer inneren Schleife durchführen, werden Sie feststellen, dass dies einen erheblichen Aufwand für die CPU- und Speicherbereinigung bedeuten kann.

Beim Entwerfen der Streams-API war klar, dass wir Grundelemente unterstützen mussten. Der Overhead beim Boxen / Unboxen würde jeden Leistungsvorteil durch Parallelität zunichte machen. Wir wollten jedoch nicht alle Grundelemente unterstützen, da dies der API eine Menge Unordnung hinzugefügt hätte. (Können Sie wirklich eine Verwendung für a sehen ShortStream?) "Alle" oder "Keine" sind bequeme Orte für ein Design, aber keines war akzeptabel. Also mussten wir einen vernünftigen Wert von "einigen" finden. Am Ende haben wir mit primitiven Spezialisierungen für int, longund double. (Persönlich hätte ich ausgelassen, intaber das bin nur ich.)

Denn CharSequence.chars()wir haben überlegt zurückzukehren Stream<Character>(ein früher Prototyp könnte dies implementiert haben), aber es wurde wegen des Boxaufwands abgelehnt. Wenn man bedenkt, dass ein String hatchar Werte als Grundelemente enthält, scheint es ein Fehler zu sein, das Boxen bedingungslos aufzuerlegen, wenn der Aufrufer den Wert wahrscheinlich nur ein wenig verarbeitet und ihn sofort wieder in eine Zeichenfolge entpackt.

Wir haben auch eine CharStreamprimitive Spezialisierung in Betracht gezogen , aber ihre Verwendung scheint im Vergleich zu der Menge an Masse, die sie der API hinzufügen würde, ziemlich eng zu sein. Es schien sich nicht zu lohnen, es hinzuzufügen.

Die Strafe, die dies für Anrufer bedeutet, ist, dass sie wissen müssen, dass die IntStreamenthaltenen charWerte als dargestellt sind intsund dass das Casting an der richtigen Stelle durchgeführt werden muss. Dies ist verwirrend , weil es doppelt API - Aufrufe wie überlastet sind PrintStream.print(char)und PrintStream.print(int)dadurch unterscheiden , dass deutlich in ihrem Verhalten. Ein zusätzlicher Punkt der Verwirrung entsteht möglicherweise, weil der codePoints()Aufruf auch ein zurückgibt IntStream, die darin enthaltenen Werte jedoch sehr unterschiedlich sind.

Dies läuft darauf hinaus, pragmatisch zwischen mehreren Alternativen zu wählen:

1. Wir konnten keine primitiven Spezialisierungen bereitstellen, was zu einer einfachen, eleganten und konsistenten API führte, die jedoch eine hohe Leistung und einen hohen GC-Overhead erfordert.

2. Wir könnten einen vollständigen Satz primitiver Spezialisierungen bereitstellen, was die API überladen und den JDK-Entwicklern einen Wartungsaufwand auferlegen würde. oder

3. Wir könnten eine Teilmenge primitiver Spezialisierungen bereitstellen und eine mittelgroße, leistungsstarke API bereitstellen, die Anrufern in einem relativ engen Bereich von Anwendungsfällen eine relativ geringe Belastung auferlegt (Zeichenverarbeitung).

Wir haben den letzten gewählt.