Dividir en una cadena vacía devuelve una matriz de tamaño 1:

scala> "".split(',')
res1: Array[String] = Array("")

Considere que esto devuelve una matriz vacía:

scala> ",,,,".split(',')
res2: Array[String] = Array()

Por favor explique :)

Por la misma razón que

",test" split ','

y

",test," split ','

devolverá una matriz de tamaño 2. Todo lo anterior a la primera coincidencia se devuelve como primer elemento.

Si divide una naranja por cero, tiene exactamente una pieza: la naranja.

Los métodos de división de Java y Scala operan en dos pasos como este:

• Primero, divida la cadena por delimitador. La consecuencia natural es que si la cadena no contiene el delimitador, se devuelve una matriz singleton que contiene solo la cadena de entrada,
• En segundo lugar, elimine todas las cadenas vacías más a la derecha. Esta es la razón por la que ",,,".split(",")devuelve una matriz vacía.

De acuerdo con esto, el resultado de "".split(",")debería ser una matriz vacía debido al segundo paso, ¿verdad?

Debería. Desafortunadamente, este es un caso de esquina introducido artificialmente. Y eso es malo, pero al menos está documentado en java.util.regex.Pattern, si recuerdas echarle un vistazo a la documentación:

Para n == 0, el resultado es como para n <0, excepto que no se devolverán cadenas vacías al final. (Tenga en cuenta que el caso en el que la entrada es en sí misma una cadena vacía es especial, como se describe anteriormente, y el parámetro de límite no se aplica allí).

Solución 1: pase siempre -1 como segundo parámetro

Por lo tanto, le aconsejo que siempre pase n == -1como el segundo parámetro (esto omitirá el paso dos anterior), a menos que sepa específicamente lo que desea lograr / esté seguro de que la cadena vacía no es algo que su programa obtendría como entrada.

Solución 2: use la clase Guava Splitter

Si ya está utilizando Guava en su proyecto, puede probar la clase Splitter (documentación) . Tiene una API muy rica y hace que su código sea muy fácil de entender.

Splitter.on(".").split(".a.b.c.") // "", "a", "b", "c", ""
Splitter.on(",").omitEmptyStrings().split("a,,b,,c") // "a", "b", "c"
Splitter.on(CharMatcher.anyOf(",.")).split("a,b.c") // "a", "b", "c"
Splitter.onPattern("=>?").split("a=b=>c") // "a", "b", "c"
Splitter.on(",").limit(2).split("a,b,c") // "a", "b,c"

Dividir una cadena vacía devuelve la cadena vacía como primer elemento. Si no se encuentra un delimitador en la cadena de destino, obtendrá una matriz de tamaño 1 que contiene la cadena original, incluso si está vacía.

"a".split(",")-> "a" por tanto "".split(",")->""

En todos los lenguajes de programación, sé que una cadena en blanco sigue siendo una cadena válida. Entonces, hacer una división usando cualquier delimitador siempre devolverá una matriz de un solo elemento donde ese elemento es la Cadena en blanco. Si fuera una cadena nula (no en blanco), entonces sería un problema diferente.

Este splitcomportamiento se hereda de Java, para bien o para mal ...
Scala no anula la definición de la Stringprimitiva.

Tenga en cuenta que puede usar el limitargumento para modificar el comportamiento :

El parámetro de límite controla el número de veces que se aplica el patrón y, por lo tanto, afecta la longitud de la matriz resultante. Si el límite n es mayor que cero, entonces el patrón se aplicará como máximo n - 1 veces, la longitud de la matriz no será mayor que n, y la última entrada de la matriz contendrá todas las entradas más allá del último delimitador coincidente. Si n no es positivo, el patrón se aplicará tantas veces como sea posible y la matriz puede tener cualquier longitud. Si n es cero, el patrón se aplicará tantas veces como sea posible, la matriz puede tener cualquier longitud y las cadenas vacías finales se descartarán.

es decir, puede configurar el limit=-1para obtener el comportamiento de (¿todos?) otros idiomas:

@ ",a,,b,,".split(",")
res1: Array[String] = Array("", "a", "", "b")

@ ",a,,b,,".split(",", -1)  // limit=-1
res2: Array[String] = Array("", "a", "", "b", "", "")

Parece ser bien sabido que el comportamiento de Java es bastante confuso, pero:

El comportamiento anterior se puede observar desde al menos Java 5 hasta Java 8.

Se intentó cambiar el comportamiento para devolver una matriz vacía al dividir una cadena vacía en JDK-6559590 . Sin embargo, pronto se revirtió en JDK-8028321 cuando causa regresión en varios lugares. El cambio nunca llega a la versión inicial de Java 8.

Nota: El método de división no estaba en Java desde el principio (no está en 1.0.2 ) pero en realidad está ahí desde al menos 1.4 (por ejemplo, ver JSR51 alrededor de 2002). Sigo investigando ...

Lo que no está claro es por qué Java eligió esto en primer lugar (mi sospecha es que originalmente fue un descuido / error en un "caso marginal"), pero ahora irrevocablemente integrado en el lenguaje y así permanece .

La cadena vacía no tiene un estado especial al dividir una cadena. Puedes utilizar:

Some(str)
  .filter(_ != "")
  .map(_.split(","))
  .getOrElse(Array())