¿Por qué String.chars () es una secuencia de entradas en Java 8?

En Java 8, hay un nuevo método String.chars()que devuelve una secuencia de ints ( IntStream) que representa los códigos de caracteres. Supongo que mucha gente esperaría una corriente de chars aquí en su lugar. ¿Cuál fue la motivación para diseñar la API de esta manera?

Como otros ya han mencionado, la decisión de diseño detrás de esto fue evitar la explosión de métodos y clases.

Aún así, personalmente creo que esta fue una decisión muy mala, y debería, dado que no quieren tomar CharStream, lo cual es razonable, métodos diferentes en lugar de chars(), pensaría en:

• Stream<Character> chars(), que proporciona una secuencia de caracteres de cuadros, que tendrá una ligera penalización de rendimiento.
• IntStream unboxedChars(), que se utilizaría para el código de rendimiento.

Sin embargo , en lugar de centrarnos en por qué se hace de esta manera actualmente, creo que esta respuesta debería centrarse en mostrar una manera de hacerlo con la API que obtuvimos con Java 8.

En Java 7 lo habría hecho así:

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

Y creo que un método razonable para hacerlo en Java 8 es el siguiente:

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

Aquí obtengo un IntStreamy lo mapeo a un objeto a través de la lambda i -> (char)i, esto automáticamente lo encuadrará en un Stream<Character>, y luego podemos hacer lo que queramos, y aún usar referencias de métodos como un plus.

Sin embargo, tenga en cuenta que debe hacerlo mapToObj, si olvida y usa map, entonces nada se quejará, pero aún terminará con un IntStream, y es posible que se pregunte por qué imprime los valores enteros en lugar de las cadenas que representan los caracteres.

Otras alternativas feas para Java 8:

Al permanecer en un IntStreamy querer imprimirlos en última instancia, ya no puede usar referencias de métodos para imprimir:

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

Además, ¡usar referencias de método a su propio método ya no funciona! Considera lo siguiente:

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

y entonces

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

Esto generará un error de compilación, ya que posiblemente haya una conversión con pérdida.

Conclusión:

La API se diseñó de esta manera por no querer agregar CharStream, personalmente creo que el método debería devolver un Stream<Character>, y la solución actual es usar mapToObj(i -> (char)i)en un IntStreampara poder trabajar correctamente con ellos.

La respuesta de skiwi cubrió muchos de los puntos más importantes. Completaré un poco más de antecedentes.

El diseño de cualquier API es una serie de compensaciones. En Java, uno de los problemas difíciles es lidiar con las decisiones de diseño que se tomaron hace mucho tiempo.

Las primitivas han estado en Java desde 1.0. Hacen de Java un lenguaje orientado a objetos "impuro", ya que las primitivas no son objetos. La adición de primitivas fue, creo, una decisión pragmática para mejorar el rendimiento a expensas de la pureza orientada a objetos.

Esta es una compensación con la que todavía vivimos hoy, casi 20 años después. La característica de autoboxing agregada en Java 5 eliminó principalmente la necesidad de desordenar el código fuente con llamadas al método de boxing y unboxing, pero la sobrecarga sigue ahí. En muchos casos no se nota. Sin embargo, si realizara un boxeo o unboxing dentro de un bucle interno, vería que puede imponer una sobrecarga considerable de CPU y recolección de basura.

Al diseñar la API de Streams, estaba claro que teníamos que soportar primitivas. La sobrecarga de boxing / unboxing mataría cualquier beneficio de rendimiento del paralelismo. Sin embargo, no queríamos admitir todas las primitivas, ya que eso habría agregado una gran cantidad de desorden a la API. (¿Realmente puede ver el uso de a ShortStream?) "Todos" o "ninguno" son lugares cómodos para un diseño, pero ninguno era aceptable. Así que tuvimos que encontrar un valor razonable de "algunos". Terminamos con especializaciones primitivas para int, longy double. (Personalmente, me hubiera dejado fuera, intpero solo soy yo).

Porque CharSequence.chars()consideramos regresar Stream<Character>(un prototipo temprano podría haber implementado esto) pero fue rechazado debido a la sobrecarga del boxeo. Teniendo en cuenta que una Cadena tiene charvalores como primitivos, parecería un error imponer el boxeo incondicionalmente cuando la persona que llama probablemente solo procesará un poco el valor y lo desempaquetará nuevamente en una cadena.

También consideramos una CharStreamespecialización primitiva, pero su uso parece ser bastante limitado en comparación con la cantidad de volumen que agregaría a la API. No valía la pena agregarlo.

La penalidad que esto impone a las personas que llaman es que deben saber que IntStreamcontiene charvalores representados como intsy que el lanzamiento debe realizarse en el lugar adecuado. Esto es doblemente confuso porque hay llamadas API sobrecargadas como PrintStream.print(char)y PrintStream.print(int)que difieren notablemente en su comportamiento. Posiblemente surja un punto de confusión adicional porque la codePoints()llamada también devuelve un, IntStreampero los valores que contiene son bastante diferentes.

Entonces, esto se reduce a elegir pragmáticamente entre varias alternativas:

1. No podríamos proporcionar especializaciones primitivas, lo que da como resultado una API simple, elegante y consistente, pero que impone un alto rendimiento y una sobrecarga de GC;

2. podríamos proporcionar un conjunto completo de especializaciones primitivas, a costa de saturar la API e imponer una carga de mantenimiento a los desarrolladores de JDK; o

3. podríamos proporcionar un subconjunto de especializaciones primitivas, proporcionando una API de tamaño moderado y alto rendimiento que impone una carga relativamente pequeña a las personas que llaman en un rango bastante limitado de casos de uso (procesamiento de caracteres).

Elegimos el último.