Modo preferito per creare un elenco Scala

Esistono diversi modi per costruire un elenco immutabile in Scala (vedere il codice di esempio inventato di seguito). Puoi utilizzare un ListBuffer mutabile, creare un varelenco e modificarlo, utilizzare un metodo ricorsivo di coda e probabilmente altri di cui non sono a conoscenza.

Istintivamente, utilizzo ListBuffer, ma non ho una buona ragione per farlo. Esiste un metodo preferito o idiomatico per creare un elenco o ci sono situazioni che sono migliori per un metodo rispetto a un altro?

import scala.collection.mutable.ListBuffer

// THESE are all the same as: 0 to 3 toList.
def listTestA() ={
    var list:List[Int] = Nil

    for(i <- 0 to 3) 
        list = list ::: List(i)
    list
}


def listTestB() ={
    val list = new ListBuffer[Int]()

    for (i <- 0 to 3) 
        list += i
    list.toList
}


def listTestC() ={
    def _add(l:List[Int], i:Int):List[Int] = i match {
        case 3 => l ::: List(3)
        case _ => _add(l ::: List(i), i +1)
    }
    _add(Nil, 0)
}

ListBufferè un elenco modificabile che ha l'aggiunta in tempo costante e una conversione in tempo costante in un file List.

List è immutabile e ha un prefisso in tempo costante e un append in tempo lineare.

Il modo in cui costruisci la tua lista dipende dall'algoritmo per cui utilizzerai la lista e dall'ordine in cui ottieni gli elementi per crearla.

Ad esempio, se ottieni gli elementi nell'ordine opposto di quando verranno utilizzati, puoi semplicemente usare a Liste fare anteponi. Che lo farai con una funzione ricorsiva di coda foldLefto qualcos'altro non è realmente rilevante.

Se ottieni gli elementi nello stesso ordine in cui li usi, allora a ListBufferè molto probabilmente una scelta preferibile, se le prestazioni sono critiche.

Ma, se non sei su un percorso critico e l'input è abbastanza basso, puoi sempre reversel'elenco in seguito, o solo foldRight, o reversel'input, che è tempo lineare.

Quello che NON fai è usare Liste aggiungervi. Questo ti darà prestazioni molto peggiori rispetto alla semplice anticipazione e inversione alla fine.

E per casi semplici:

val list = List(1,2,3) 

:)

Uhmm .. questi sembrano troppo complessi per me. Posso proporre

def listTestD = (0 to 3).toList

o

def listTestE = for (i <- (0 to 3).toList) yield i

Vuoi concentrarti sull'immutabilità in Scala in generale eliminando qualsiasi variabile. La leggibilità è ancora importante per i tuoi simili, quindi:

Provare:

scala> val list = for(i <- 1 to 10) yield i
list: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Probabilmente non è nemmeno necessario convertire in un elenco nella maggior parte dei casi :)

Il seq indicizzato avrà tutto ciò di cui hai bisogno:

Cioè, ora puoi lavorare su quel IndexedSeq:

scala> list.foldLeft(0)(_+_)
res0: Int = 55

Preferisco sempre List e uso "piega / riduci" prima di "per comprensione". Tuttavia, "per la comprensione" è preferito se sono richieste "pieghe" annidate. La ricorsione è l'ultima risorsa se non riesco a portare a termine il compito usando "fold / reduce / for".

quindi per il tuo esempio, farò:

((0 to 3) :\ List[Int]())(_ :: _)

prima di me:

(for (x <- 0 to 3) yield x).toList

Nota: qui uso "foldRight (: \)" invece di "foldLeft (/ :)" a causa dell'ordine di "_". Per una versione che non genera StackOverflowException, utilizza invece "foldLeft".

Usando List.tabulate, in questo modo,

List.tabulate(3)( x => 2*x )
res: List(0, 2, 4)

List.tabulate(3)( _ => Math.random )
res: List(0.935455779102479, 0.6004888906328091, 0.3425278797788426)

List.tabulate(3)( _ => (Math.random*10).toInt )
res: List(8, 0, 7)

Nota: questa risposta è scritta per una vecchia versione di Scala.

Le classi della collezione Scala saranno ridisegnate a partire da Scala 2.8, quindi preparati a cambiare il modo in cui crei le liste molto presto.

Qual è il modo compatibile con il futuro per creare un elenco? Non ne ho idea dato che non ho ancora letto i documenti 2.8.

Un documento PDF che descrive le modifiche proposte delle classi di raccolta

Come nuovo sviluppatore scala ho scritto un piccolo test per controllare il tempo di creazione della lista con i metodi suggeriti sopra. Sembra che (per (p <- (da 0 a x)) rendimento p) Elenca l'approccio più veloce.

import java.util.Date
object Listbm {

  final val listSize = 1048576
  final val iterationCounts = 5
  def getCurrentTime: BigInt = (new Date) getTime

  def createList[T] ( f : Int => T )( size : Int ): T = f ( size )

  // returns function time execution
  def experiment[T] ( f : Int => T ) ( iterations: Int ) ( size :Int ) : Int  = {

    val start_time = getCurrentTime
    for ( p <- 0 to iterations )  createList ( f ) ( size )
    return (getCurrentTime - start_time) toInt

  }

  def printResult ( f:  => Int ) : Unit = println ( "execution time " + f  )

  def main( args : Array[String] ) {


    args(0) match {

      case "for" =>  printResult ( experiment ( x => (for ( p <- ( 0 to x ) ) yield p) toList  ) ( iterationCounts ) ( listSize ) )
      case "range"  =>  printResult ( experiment ( x => ( 0 to x ) toList ) ( iterationCounts ) ( listSize ) )
      case "::" => printResult ( experiment ( x => ((0 to x) :\ List[Int]())(_ :: _) ) ( iterationCounts ) ( listSize ) )
      case _ => println ( "please use: for, range or ::\n")
    }
  }
}

solo un esempio che utilizza collection.breakOut

scala> val a : List[Int] = (for( x <- 1 to 10 ) yield x * 3)(collection.breakOut)
a: List[Int] = List(3, 6, 9, 12, 15, 18, 21, 24, 27, 30)

scala> val b : List[Int] = (1 to 10).map(_ * 3)(collection.breakOut)
b: List[Int] = List(3, 6, 9, 12, 15, 18, 21, 24, 27, 30)

Per creare un elenco di stringhe, utilizzare quanto segue:

val l = List("is", "am", "are", "if")