Scala - converti matrice [stringa] in matrice [doppia]

Question

Sono un principiante del linguaggio di programmazione funzionale e sto imparando a Scala per un progetto universitario.

Questo può sembrare semplice, ma non riesco a trovare abbastanza aiuto online per questo o un modo semplice per farlo: come posso convertire un array [stringa] in matrice [doppio]? Ho un file CSV che, quando letto nel REPL, viene interpretato come valori String (ogni riga del file ha una combinazione di valori interi e stringa) che restituirebbe un tipo Array [String]. Voglio codificare i valori stringa con valori double/int per restituire l'array [Double] al fine di rendere l'array omogeneo. C'è un modo semplice per farlo? Qualsiasi guida sarà molto apprezzata.

Quello che ho fatto fino ad ora è:

def retrieveExamplesFromFile(fileName : String) : Array[Array[String]] = { 
    val items = for { 
    line <- Source.fromFile(fileName).getLines() 
    entries = line.split(",") 
    } yield entries 

    return items.toArray 
} 

Il formato di ogni riga (restituito come String []) è così:

[[1.0, 2.0, item1], [5, 8.9, item2],....] 

E per convertire ogni riga nel file CSV in doppio array, ho solo una definizione pseudo redatta in modo:

def generateNumbersForStringValues(values : Array[String]) : Array[Double] = { 
val line = for(item <- values) 
{ 
    //correct way? 
    item.replace("item1", "1.0") 
    item.replace("item2", "1.0")  
} 
return //unable to typecast/convert 
} 

Tutte le idee sono benvenute. Grazie per il tuo tempo.

Answer 1

Probabilmente si desidera utilizzare map insieme toDouble:

values.map(x => x.toDouble) 

O più conciso:

values.map(_.toDouble) 

E per il ripiego per non-corde doppie, è potrebbe prendere in considerazione l'utilizzo della monade Try (in scala.util):

values.map(x => Try(x.toDouble).getOrElse(1.0)) 

Se si conosce ciò che ogni linea sarà simile, si potrebbe anche fare pattern matching:

values map { 
    case Array(a, b, c) => Array(a.toDouble, b.toDouble, 1.0) 
} 

Answer 2

Intendi convertire tutte le stringhe in double con un fallback a 1.0 per tutte le stringhe non convertibili? Che sarebbe:

val x = Array(
    Array("1.0", "2.0", "item1"), 
    Array("5", "8.9", "item2")) 

x.map(_.map { y => 
    try { 
    y.toDouble 
    } catch { 
    case _: NumberFormatException => 1.0 
    } 
}) 

Answer 3

Ampliando @ commento di DaunnC, è possibile utilizzare l'utilità Try per fare questo e pattern match sul risultato in modo da poter evitare di chiamare get o avvolgendo il risultato in un Option:

import scala.util.{Try, Success, Failure} 

def main = { 
    val maybeDoubles = Array("5", "1.0", "8.5", "10.0", "item1", "item2") 

    val convertDoubles = maybeDoubles.map { x => 
    Try(x.toDouble) 
    } 

    val convertedArray = convertDoubles.map { 
    _ match { 
     case Success(res) => res 
     case Failure(f) => 1.0 
    } 
    } 

    convertedArray 
} 

Questo permette di pattern match sul risultato di Try, che è sempre o un 01.233.418,millionso Failure, senza dover chiamare get o altrimenti avvolgere i risultati.

Ecco qualche informazione in più su Prova per gentile concessione di Mauricio Linhares: https://mauricio.github.io/2014/02/17/scala-either-try-and-the-m-word.html