Scala listesi oluşturmanın tercih edilen yolu

Scala'da değişmez bir liste oluşturmanın birkaç yolu vardır (aşağıdaki hazırlanmış örnek koda bakın). Değişken bir ListBuffer kullanabilir, bir varliste oluşturabilir ve onu değiştirebilir, bir tail recursive metodu ve muhtemelen bilmediğim diğerlerini kullanabilirsiniz.

İçgüdüsel olarak ListBuffer'ı kullanıyorum, ancak bunu yapmak için iyi bir nedenim yok. Liste oluşturmak için tercih edilen veya deyimsel bir yöntem var mı, yoksa bir yöntem için diğerine göre en iyi olan durumlar var mı?

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)
}

ListBuffersabit zamanlı ek ve sabit zamanlı bir List.

List değişmezdir ve sabit zamanlı başa ve doğrusal zaman ekine sahiptir.

Listenizi nasıl oluşturacağınız, listeyi kullanacağınız algoritmaya ve onu oluşturmak için öğeleri elde ettiğiniz sıraya bağlıdır.

Örneğin, öğeleri ne zaman kullanılacaklarının tersi sırayla alırsanız, o zaman sadece a kullanabilir Listve başa ekler yapabilirsiniz. Bunu bir kuyruk özyinelemeli işlevle mi foldLeftyoksa başka bir şeyle mi yapacağınız gerçekten alakalı değildir.

Öğeleri kullandığınız sırayla alırsanız ListBuffer, performans kritikse, a büyük olasılıkla tercih edilen bir seçimdir.

Ancak, kritik bir yolda değilseniz ve girdi yeterince düşükse reverse, listeyi her zaman daha sonra veya sadece foldRightveya reversedoğrusal zaman olan girdiyi yapabilirsiniz.

Ne YAPMAYIN yapmak is a kullanmak Listkendisine ve append. Bu size, sonunda sadece önceden harcamaktan ve geri almaktan çok daha kötü bir performans verecektir.

Ve basit durumlar için:

val list = List(1,2,3) 

:)

Uhmm .. bunlar bana çok karmaşık görünüyor. Teklif edebilir miyim

def listTestD = (0 to 3).toList

veya

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

Scala'da genel olarak değişkenleri ortadan kaldırarak değişmezliğe odaklanmak istiyorsunuz. Okunabilirlik dostunuz için hala önemlidir, bu nedenle:

Deneyin:

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)

Muhtemelen çoğu durumda bir listeye dönüştürmenize bile gerek yoktur :)

İndekslenen sıra ihtiyacınız olan her şeye sahip olacaktır:

Yani, artık IndexedSeq üzerinde çalışabilirsiniz:

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

Her zaman List'i tercih ederim ve "anlamak için" önce "katla / küçült" seçeneğini kullanırım. Bununla birlikte, iç içe geçmiş "kıvrımlar" gerekliyse "anlama için" tercih edilir. Görevi "katla / azalt / için" kullanarak başaramazsam, yineleme son çare.

yani sizin örneğiniz için yapacağım:

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

benden önce:

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

Not: Burada "_" s sırasına göre "foldLeft (/ :)" yerine "foldRight (: \)" kullanıyorum. StackOverflowException oluşturmayan bir sürüm için bunun yerine "foldLeft" kullanın.

Bunun List.tabulategibi kullanarak

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)

Not: Bu cevap Scala'nın eski bir sürümü için yazılmıştır.

Scala koleksiyonu sınıfları Scala 2.8'den itibaren yeniden tasarlanacak, bu nedenle listeleri oluşturma şeklinizi çok yakında değiştirmeye hazır olun.

Liste oluşturmanın ileriye dönük uyumlu yolu nedir? Henüz 2.8 belgeyi okumadığım için hiçbir fikrim yok.

Koleksiyon sınıflarının önerilen değişikliklerini açıklayan bir PDF belgesi

Yeni bir ölçek geliştiricisi olarak, liste oluşturma zamanını yukarıda önerilen yöntemlerle kontrol etmek için küçük bir test yazdım. En hızlı yaklaşımı ((p <- (0 - x) için) vermek p) toList'e benziyor.

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")
    }
  }
}

sadece collection.breakOut kullanan bir örnek

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)

Bir dizi listesi oluşturmak için aşağıdakileri kullanın:

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