A divisão em uma string vazia retorna uma matriz de tamanho 1:

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

Considere que isso retorna uma matriz vazia:

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

Por favor explique :)

Pela mesma razão que

",test" split ','

e

",test," split ','

retornará uma matriz de tamanho 2. Tudo antes da primeira correspondência é retornado como o primeiro elemento.

Se você dividir uma laranja zero vezes, terá exatamente um pedaço - a laranja.

Os métodos de divisão Java e Scala operam em duas etapas como esta:

• Primeiro, divida a string por delimitador. A consequência natural é que, se a string não contém o delimitador, um array de singleton contendo apenas a string de entrada é retornado,
• Em segundo lugar, remova todas as strings vazias mais à direita. Este é o motivo pelo qual ",,,".split(",")retorna um array vazio.

De acordo com isso, o resultado de "".split(",")deve ser um array vazio por causa da segunda etapa, certo?

Deveria. Infelizmente, este é um caso de canto introduzido artificialmente. E isso é ruim, mas pelo menos ele está documentado em java.util.regex.Pattern, se você se lembrar de tomar uma olhada na documentação:

Para n == 0, o resultado é igual a n <0, exceto que as strings vazias finais não serão retornadas. (Observe que o caso em que a própria entrada é uma string vazia é especial, conforme descrito acima, e o parâmetro limit não se aplica lá.)

Solução 1: sempre passe -1 como o segundo parâmetro

Portanto, aconselho você a sempre passar n == -1como o segundo parâmetro (isso pulará a etapa dois acima), a menos que você saiba especificamente o que deseja alcançar / tenha certeza de que a string vazia não é algo que seu programa obteria como entrada.

Solução 2: usar a classe Guava Splitter

Se você já está usando Guava em seu projeto, você pode tentar a classe Divisor (documentação) . Tem uma API muito rica e torna o seu código muito 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"

A divisão de uma string vazia retorna a string vazia como o primeiro elemento. Se nenhum delimitador for encontrado na string de destino, você obterá uma matriz de tamanho 1 que contém a string original, mesmo se estiver vazia.

"a".split(",")-> "a" portanto "".split(",")->""

Em todas as linguagens de programação, sei que uma string em branco ainda é uma String válida. Portanto, fazer uma divisão usando qualquer delimitador sempre retornará uma única matriz de elemento em que esse elemento é a String em branco. Se fosse uma string nula (não em branco), o problema seria diferente.

Este splitcomportamento é herdado do Java, para melhor ou para pior ...
Scala não sobrescreve a definição do Stringprimitivo.

Observe que você pode usar o limitargumento para modificar o comportamento :

O parâmetro limit controla o número de vezes que o padrão é aplicado e, portanto, afeta o comprimento da matriz resultante. Se o limite n for maior que zero, o padrão será aplicado no máximo n - 1 vezes, o comprimento da matriz não será maior do que n e a última entrada da matriz conterá todas as entradas além do último delimitador correspondente. Se n for não positivo, o padrão será aplicado tantas vezes quanto possível e a matriz pode ter qualquer comprimento. Se n for zero, o padrão será aplicado tantas vezes quanto possível, a matriz pode ter qualquer comprimento e as cadeias de caracteres vazias posteriores serão descartadas.

ou seja, você pode definir o limit=-1para obter o comportamento de (todos?) outros idiomas:

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

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

Parece ser bem conhecido que o comportamento do Java é bastante confuso, mas:

O comportamento acima pode ser observado de pelo menos Java 5 a Java 8.

Houve uma tentativa de alterar o comportamento para retornar um array vazio ao dividir uma string vazia em JDK-6559590 . No entanto, logo foi revertido em JDK-8028321 quando causa regressão em vários lugares. A mudança nunca chega ao lançamento inicial do Java 8.

Nota: O método de divisão não estava em Java desde o início (não está em 1.0.2 ), mas na verdade existe a partir de pelo menos 1.4 (por exemplo, consulte JSR51 por volta de 2002). Ainda estou investigando ...

O que não está claro é por que Java escolheu isso em primeiro lugar (minha suspeita é que era originalmente um descuido / bug em um "caso extremo"), mas agora irrevogavelmente embutido na linguagem e assim permanece .

A string vazia não tem nenhum status especial ao dividir uma string. Você pode usar:

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