Formattazione numero in Scala?

Question

Ho una lettura di input che cambia dinamicamente da un file. I numeri sono Int o Double. Perché Scala stampa .0 dopo ogni numero ? C'è un modo per Scala di stamparlo nello stesso modo in cui lo legge?

Esempio:

var x:Double = 1 
println (x)    // This prints '1.0', I want it to print '1' 
x = 1.0     // This prints '1.0', which is good 

Non posso usare Int perché alcuni degli input ricevo sono Double s. Non riesco a utilizzare String o AnyVal perché eseguo alcune operazioni matematiche.

Grazie,

Answer 1

Uso printf:

printf("The value is %.0f", x) 

Per una descrizione della stringa di formato, vedere this page dalla documentazione delle API Java SE 6.

Si noti che è anche possibile utilizzare la libreria Java di Scala, quindi è possibile utilizzare anche altri modi per formattare numeri da Java. Si può ad esempio l'uso di classe java.text.DecimalFormat:

val df = new java.text.DecimalFormat("#####") 
println(df.format(x)) 

Answer 2

var x:Double = 1 
var y:Double = 1.0 

print(x) // => 1.0 
print(y) // => 1.0 

Se ho capito si mette in discussione che si desidera scala stampare X e Y in modo diverso? Il problema è che xey sono entrambe variabili del tipo Double e hanno lo stesso aspetto.

Perché si definisce esplicitamente il tipo di vars?

var x = 1 
var y= 1.0 

print(x) // => 1 
print(y) // => 1.0 

Answer 3

Utilizzare l'inferenza del tipo piuttosto che la digitazione esplicita.

scala> val xi = 1 
xi: Int = 1 

scala> val xd = 1.0 
xd: Double = 1.0 

scala> println(xi) 
1 

scala> println(xd) 
1.0 

Answer 4

scala> "%1.0f" format 1.0 
res3: String = 1 

Se il vostro ingresso è sia Int o Double, si può fare in questo modo:

def fmt(v: Any): String = v match { 
    case d : Double => "%1.0f" format d 
    case i : Int => i.toString 
    case _ => throw new IllegalArgumentException 
} 

Usage:

scala> fmt(1.0) 
res6: String = 1 

scala> fmt(1) 
res7: String = 1 

scala> fmt(1.0f) 
java.lang.IllegalArgumentException 
     at .fmt(<console>:7) 
     at .<init>(<console>:6) 
     at .<clinit>(<console>) 
     at RequestResult$.<init>(<console>:4) 
     at RequestResult$.<clinit>(<console>) 
     at RequestResult$result(<console>) 
     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) 
     at sun.reflect.Dele... 

In caso contrario, si potrebbe utilizzare BigDecimals. Sono lenti, ma lo fanno venire con la scala, così "1", "1,0" e "1,00" sono tutti diversi:

scala> var x = BigDecimal("1.0") 
x: BigDecimal = 1.0 

scala> x = 1 
x: BigDecimal = 1 

scala> x = 1.0 
x: BigDecimal = 1.0 

scala> x = 1.000 
x: BigDecimal = 1.0 

scala> x = "1.000" 
x: BigDecimal = 1.000 

Answer 5

L'uso di un "_.0" alla fine della virgola mobile i numeri sono una convenzione. Solo un modo per sapere che il numero è effettivamente a virgola mobile e non un intero.

Se si davvero è necessario "stamparlo nello stesso modo in cui lo legge", potrebbe essere necessario rivedere il modo in cui il codice è strutturato, possibilmente preservando i dati di input.Se è solo un problema di formattazione, il modo più semplice è quello di convertire i valori a numeri interi prima della stampa:

val x = 1.0 
println(x.toInt) 

Se alcuni sono interi e alcuni non lo sono, è necessario un codice po 'di più:

def fmt[T <% math.ScalaNumericConversions](n : T) = 
        if(n.toInt == n) n.toInt.toString else n.toString 

val a : Double = 1.0 
val b : Double = 1.5 
val c : Int = 1 

println(fmt(a)) 
println(fmt(b)) 
println(fmt(c)) 

il codice di cui sopra dovrebbe stampare:

1 
1.5 
1 

la firma del metodo fmt accetta qualsiasi tipo che o è un sottotipo di ScalaNumericConversions o può essere convertito in un attraverso conversioni implicite (quindi possiamo usare il metodo toInt).

Answer 6

Partendo Scala 2.10 è possibile utilizzare the f interpolator:

scala> val x: Double = 1 
x: Double = 1.0 

scala> println(f"$x%.0f") 
1 

scala> val i = 1 
i: Int = 1 

scala> println(f"$i%.0f") 
1