Кращий спосіб створення списку Scala

Існує кілька способів побудови незмінного списку в Scala (див. Надуманий приклад коду нижче). Ви можете використовувати змінний ListBuffer, створити varсписок та змінити його, використовувати хвостовий рекурсивний метод та, ймовірно, інші, про які я не знаю.

Інстинктивно я використовую ListBuffer, але у мене немає вагомих причин для цього. Чи є кращий або ідіоматичний метод створення списку, чи існують ситуації, які найкраще підходять для одного методу над іншим?

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- це список, що змінюється, який має додавання постійного часу та конверсію постійного часу в a List.

List є незмінним і має додаток до постійного часу та додавання лінійного часу.

Спосіб побудови списку залежить від алгоритму, для якого ви будете використовувати список, і порядку, в якому ви отримуєте елементи для його створення.

Наприклад, якщо ви отримуєте елементи в протилежному порядку, коли вони будуть використані, ви можете просто використовувати a Listі робити препенди. Незалежно від того, чи будете ви це робити з хвостово-рекурсивною функцією foldLeft, чи щось інше не дуже важливо.

Якщо ви отримуєте елементи в тому ж порядку, коли ви їх використовуєте, то ListBuffer, швидше за все, це кращий вибір, якщо продуктивність є критичною.

Але якщо ви не знаходитесь на критичному шляху, а вхід недостатньо низький, ви завжди можете reverseперелічити пізніше, або просто foldRight, або reverseвхід, який є лінійним часом.

Те, що ви НЕ РОБИТИ , - це використовувати Listта додавати до нього. Це дасть вам набагато гірші показники, ніж просто передбачення та перевернення в кінці.

А для простих випадків:

val list = List(1,2,3) 

:)

Гмм .. це здаються мені занадто складними. Можна запропонувати

def listTestD = (0 to 3).toList

або

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

Ви хочете зосередити увагу на незмінності Scala, усуваючи будь-які вари. Читання все ще важливо для вашого ближнього чоловіка, тому:

Спробуйте:

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)

Мабуть, вам навіть не потрібно перетворюватись на список у більшості випадків :)

Індексований seq матиме все необхідне:

Тобто тепер ви можете працювати над цим IndexedSeq:

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

Я завжди віддаю перевагу списку, і для розуміння використовую "скласти / зменшити" перед ". Однак "для розуміння" бажано, якщо потрібні вкладені "складки". Рекурсія є крайнім заходом, якщо я не можу виконати завдання, використовуючи «скласти / зменшити / для».

тому для вашого прикладу я зроблю:

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

перед тим, як зробити:

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

Примітка: я використовую тут "foldRight (: \)" замість "foldLeft (/ :)" через порядок "_" s. Для версії, яка не кидає StackOverflowException, використовуйте натомість "foldLeft".

Використовуючи List.tabulate, як це,

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)

Примітка. Ця відповідь написана для старої версії Scala.

Класи колекції Scala будуть перероблені, як і в Scala 2.8, тому будьте готові змінити спосіб створення списків дуже скоро.

Який прямий сумісний спосіб створення списку? Поняття не маю, оскільки ще не прочитав 2,8 документа.

Документ у форматі PDF, що описує запропоновані зміни класів колекції

Як новий розробник scala, я написав невеликий тест, щоб перевірити час створення списку з запропонованими вище методами. Схоже, що (для (p <- (0 до x)) вихід p) для переліку найшвидшого підходу.

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

лише приклад, який використовує 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)

Щоб створити список рядків, використовуйте наступне:

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