Como converter um Int em uma String de um determinado comprimento com zeros à esquerda para alinhar?

97

Como posso converter um Intem um de 7 caracteres String, para que 123seja transformado em "0000123"?

— Ivan
fonte

220

A biblioteca Java tem um suporte de formatação de número muito bom (como excelente) que é acessível a partir da classe String enriquecida com StringOps :

scala> "%07d".format(123)
res5: String = 0000123

scala> "%07d".formatLocal(java.util.Locale.US, 123)
res6: String = 0000123

Editar pós Scala 2.10 : conforme sugerido por fommil, a partir de 2.10, também existe um interpolador de string de formatação (não suporta localização):

val expr = 123
f"$expr%07d"
f"${expr}%07d"

Editar abril de 2019:

Se você quiser espaços iniciais, e não zero, apenas deixe de fora o 0do especificador de formato. No caso acima, seria f"$expr%7d".Testado em 2.12.8 REPL. Não há necessidade de fazer a substituição da string como sugerido em um comentário, ou mesmo colocar um espaço explícito na frente de 7como sugerido em outro comentário.
Se o comprimento for variável, s"%${len}d".format("123")

— Huynhjl
fonte

6

Ben, dhg, obrigado pelos votos positivos, vocês são uma multidão difícil! Acho que ainda podemos aprender algo com as outras respostas, e o sistema de votação cuida de qual delas é relevante.

— Huynhjl

8

você não precisa ser tão explícito, você pode escrever f"$a%07d"(se tiver um val/ var ano escopo).

— fommil de

1

Na verdade, @fommil ainda não estava lá quando postei a resposta inicial, mas também usaria o interpolador f agora que ele existe.

— Huynhjl

Se você quer levando espaços em vez de zeros à esquerda , em seguida, você pode usar regex string.replaceAll("\\G0", " ")para substituir zeros à esquerda com espaços como dito aqui

— y2k-shubham

1

Se você quiser espaços iniciais em vez de zeros iniciais , use "% 7d".format(123).

— Erik van Oosten

36

Resposta curta:

"1234".reverse.padTo(7, '0').reverse

Resposta longa:

Scala StringOps (que contém um bom conjunto de métodos que os objetos string Scala possuem por causa das conversões implícitas) tem um padTométodo que anexa uma certa quantidade de caracteres à sua string. Por exemplo:

"aloha".padTo(10,'a')

Retornará "alohaaaaaa". Observe que o tipo de elemento de uma String é um Char, portanto, as aspas simples ao redor de 'a'.

Seu problema é um pouco diferente, pois você precisa preceder caracteres em vez de acrescentar los. É por isso que você precisa inverter a string, acrescentar os caracteres de preenchimento (você os estaria acrescentando agora, já que a string está invertida) e, em seguida, reverter tudo novamente para obter o resultado final.

Espero que isto ajude!

— Pablo Fernandez
fonte

14

Use .mkString para voltar a ser uma string

— samthebest,

2

ou use o caractere 'a'

— Lawrence Wagerfield

29

O paddingé denotado por %02dpara 0ser prefixado para fazer o comprimento 2:

scala> val i = 9 
i: Int = 9

scala> val paddedVal = f"${num}%02d"
paddedVal: String = 09

scala> println(paddedVal)             
09

— maxmithun
fonte

Nesta linha val paddedVal = f"${num}%02d"deve ser alterado numparai

— mjbsgll

f"$num%02d"(sem colchetes necessários aqui)

— Hartmut P.

9

huynhjl chegou antes de mim na resposta certa, então aqui está uma alternativa:

"0000000" + 123 takeRight 7

— Luigi Plinge
fonte

Isso falhará para números maiores que 10M: "0000000" + Int.MaxValue takeRight 7=> 7483647. Embora "tecnicamente" correto pela interpretação literal da pergunta, é improvável que o leitor não queira que o número preenchido ultrapasse 7 dígitos se o número for tão grande.

— Emil Lundberg de

Bem, você poderia dizer que esta solução é melhor porque pelo menos os dígitos ainda estão corretamente alinhados naquele caso particular, ao contrário da solução aceita. A questão toda é fazer com que os dígitos se alinhem corretamente.

— Luigi Plinge de

3

def leftPad(s: String, len: Int, elem: Char): String = {
 elem.toString * (len - s.length()) + s
}

— zeromem
fonte

1

Caso este Q&A se torne o compêndio canônico,

scala> import java.text._
import java.text._

scala> NumberFormat.getIntegerInstance.asInstanceOf[DecimalFormat]
res0: java.text.DecimalFormat = java.text.DecimalFormat@674dc

scala> .applyPattern("0000000")

scala> res0.format(123)
res2: String = 0000123

— som-snytt
fonte

1

Você precisa lidar com números negativos? Se não, eu apenas faria

def str(i: Int) = (i % 10000000 + 10000000).toString.substring(1)

ou

def str(i: Int) = { val f = "000000" + i; f.substring(f.length() - 7) }

Caso contrário, você pode usar NumberFormat:

val nf = java.text.NumberFormat.getIntegerInstance(java.util.Locale.US)
nf.setMinimumIntegerDigits(7)
nf.setGroupingUsed(false)
nf.format(-123)

— 0__
fonte