Какой лучший способ создать динамически растущий массив в Scala?
Я хотел динамически добавлять элементы в массив. Но кажется, что массивы и списки Scala не предоставляют никаких методов для добавления элементов динамически из-за неизменности.
Поэтому я решил использовать тип данных List, чтобы использовать this :: method для достижения этой цели. Мой код выглядит так
var outList = List(Nil)
val strArray = Array("ram","sam","bam")
for (str<-strArray)
outList = str :: outList
Хотя это работает каким-то образом, проблема в том, что новые строки предварительно добавляются в список. Но идеальным требованием является порядок данных. Да, я знаю, что вы думаете, вы можете полностью изменить список окончательных результатов, чтобы получить исходный заказ. Но проблема в том, что это огромный массив. И я считаю, что это не решение, хотя оно решает проблему. Я считаю, что должен быть простой способ решить эту проблему...
И моя причина взлома Scala - изучить функциональный способ кодирования. Мне кажется, что наличие var (изменяемого типа) и заполнение списка на лету не является функциональным способом решения проблем.
Как мне это сделать?
В идеале я хочу добиться чего-то подобного в Scala (ниже кода C#)
List<int> ls = new List<int>();
for (int i = 0; i < 100; i++)
ls.Add(i);
7 ответов
Но кажется, что Scala Arrays & Lists не предоставляет никаких методов для добавления элементов динамически из-за неизменности.
Ну нет. Scala Arrays - это просто массивы Java, поэтому они изменчивы:
val arr = Array(1,2)
arr(0) = 3 // arr == Array(3, 2)
Но так же, как массивы Java (и C/C++/C#/etc.), Вы не можете изменить размер массива.
Поэтому вам нужна другая коллекция, которая поддерживается массивом, но позволяет изменять размеры. Подходящая коллекция в Scala scala.collection.mutable.ArrayBuffer, java.util.ArrayList на Яве и т. д.
Если вы хотите получить List вместо Array в конце концов, используйте scala.collection.mutable.ListBuffer вместо.
Если вы хотите работать с неизменяемыми структурами, вы можете использовать метод ++:
scala> val orgList = List(1,2,3)
orgList: List[Int] = List(1, 2, 3)
scala> val list2Add = List(4,5,6)
list2Add: List[Int] = List(4, 5, 6)
scala> val newList = orgList ++ list2Add
newList: List[Int] = List(1, 2, 3, 4, 5, 6)
Если вы хотите больше работать с элементами, чем просто добавлять их, вы можете использовать функции более высокого порядка:
val newList = orgList ++ list2Add.map(_ * 2)
newList: List[Int] = List(1, 2, 3, 8, 10, 12)
Или с циклом:
val newList = orgList ++ {for(x <- list2Add) yield 2*x}
Или вы можете создать рекурсивный цикл:
def addAll(toList: List[Int], fromList: List[Int]): List[Int] =
fromList match {
case x :: tail => addAll(2*x :: toList, tail)
case Nil => toList
}
val newList = addAll(orgList, list2Add )
но в этом случае порядок добавленных элементов будет обратным:
List(12, 10, 8, 1, 2, 3)
Если вам нужна производительность при работе со списками, лучше поменять результат, чем пытаться добавить новые элементы в конце. Добавление элементов в конце списка не очень хорошо:-)
Далее после ответа ретронима:
Если вы все еще хотите использовать список, есть несколько способов добавить элемент в список. Что вы можете сделать, это (да, верхняя часть все еще не так):
scala> var outList : List[String] = Nil
outList: List[String] = List()
scala> val strArray = Array("a","b","c")
strArray: Array[java.lang.String] = Array(a, b, c)
scala> for(s <- strArray)
| outList = outList :+ s
scala> outList
res2: List[String] = List(a, b, c)
Обратите внимание на оператор:+. Если вы предпочитаете добавлять, вы должны использовать s +: outList.
Кто сказал, что программирование в Scala - это не весело?;)
PS Возможно, причина, по которой вы хотите сделать их неизменными, - это скорость. Обработка больших данных будет более эффективной с неизменяемыми типами данных. Я прав?
Если вы хотите использовать изменяемый буфер, как упоминалось в ретрониме. Это выглядит так:
scala> var outList = scala.collection.mutable.Buffer[String]()
outList: scala.collection.mutable.Buffer[String] = ArrayBuffer()
scala> for(str<-strArray) outList += str
scala> outList
res10: scala.collection.mutable.ListBuffer[String] = ListBuffer(ram, sam, bam)
В любом случае, возможно, лучше напрямую делать то, что вы хотите сделать с strArray, Например:
strArray map(_.toUpperCase) foreach(println)
Хорошо, есть кое-что прояснить.
Это неправильно, вы создаете список из одного элемента, содержащий пустой список:
scala> var outList = List(Nil)
outList: List[object Nil] = List(List())
Nil это пустой список:
scala> var outList: List[String] = Nil
outList: List[String] = List()
Или, если вы предпочитаете:
scala> var outList = List[String]()
outList: List[String] = List()
Без большего контекста трудно понять, что вы подразумеваете под "динамически". Ваш пример кода был бы лучше написан как:
scala> val strArray = Array("ram","sam","bam")
strArray: Array[java.lang.String] = Array(ram, sam, bam)
scala> strArray toList
res0: List[java.lang.String] = List(ram, sam, bam)
Если вам нужна изменчивая коллекция, которая может расти и эффективно обрабатывать операции добавления, добавления и вставки, вы можете использовать scala.mutable.Buffer,
Если вы хотите создать новую коллекцию, вы можете использовать ключевое слово yield:
val outlist = for(i <- 0 to 100) yield i
Или же:
val arrList = "Some" :: "Input" :: "List" :: Nil
val outlist = for ( i <- arrList ) yield i
Технически outlist является Seq в обоих приведенных выше примерах, поэтому вам может потребоваться вызвать для него метод toList, если вам нужны некоторые из методов List.
Мы можем использовать ArrayBuffer как предложено. Тем не менее, я создал простую программу, которая не принимает никаких параметров для массива int, и она позволит вам вводить числа и, наконец, мы их отображаем.
val arraySize = scala.io.StdIn.readLine().toInt
val arr = new ArrayBuffer[Int]() ++ (1 to arraySize).map{
i =>
scala.io.StdIn.readLine().toInt
}
println(arr.mkString(","))