Добавить элемент в список В Scala

Я запускаю Scala 2.10.2. Я хочу создать список, а затем добавить некоторые элементы в список и ожидать увидеть все элементы в списках при вызове имени списка. Но я заметил что-то довольно странное (по крайней мере, странно для меня, так как я новичок). Ниже я попытался сделать это в sbt console

scala> val l = 1.0 :: 5.5 :: Nil
l: List[Double] = List(1.0, 5.5)

scala> l
res0: List[Double] = List(1.0, 5.5)

scala> l ::: List(2.2, 3.7)
res1: List[Double] = List(1.0, 5.5, 2.2, 3.7)

scala> List(l) :+ 2.2
res2: List[Any] = List(List(1.0, 5.5), 2.2)

scala> l
res3: List[Double] = List(1.0, 5.5)

scala>

Сначала я создал список l с двумя элементами (1.0 и 5.5). Я называю l и получаю то, что ожидаю; два элемента. Теперь я попытался добавить еще один элемент в список, используя :::, который вернул новый список с новым списком добавленных мной элементов (2.2 и 3.7). Sweet! Я даже проверил код другого пользователя: Добавление элемента в конец списка в Scala для использования новой конструкции :+. Поэтому на этом этапе я все счастлив, но я называю l, и я получаю неожиданное: `res3: List [Double] = List (1.0, 5.5) '.

Где элементы, которые я добавил? И как я могу добавить эти элементы правильно, чтобы при вызове l я получил новый список со всеми материалами, которые я добавил?

Ответ 1

Вы используете неизменный список. Операции в списке возвращают новый список. Старый список остается неизменным. Это может быть очень полезно, если другой класс/метод содержит ссылку на исходную коллекцию и полагается на то, что он остается неизменным. Вы можете использовать разные имена vals, как в

val myList1 = 1.0 :: 5.5 :: Nil 
val myList2 = 2.2 :: 3.7 :: mylist1

или используйте var, как в

var myList = 1.0 :: 5.5 :: Nil 
myList :::= List(2.2, 3.7)

Это эквивалентный синтаксис для:

myList = myList.:::(List(2.2, 3.7))

Или вы можете использовать один из изменяемых коллекций, например

val myList = scala.collection.mutable.MutableList(1.0, 5.5)
myList.++=(List(2.2, 3.7))

Не следует путать со следующим, что не изменяет исходный измененный список, но возвращает новое значение:

myList.++:(List(2.2, 3.7))

Однако вы должны использовать только изменяемые коллекции в критическом для производительности коде. Неизменяемые коллекции гораздо легче рассуждать и использовать. Одно большое преимущество заключается в том, что неизменный список и scala.collection.immutable.Vector являются ковариантными. Не беспокойтесь, если это еще ничего не значит для вас. Преимущество этого заключается в том, что вы можете использовать его без его полного понимания. Следовательно, коллекция, которую вы использовали по умолчанию, фактически scala.collection.immutable.List ее просто импортировала для вас автоматически.

Примечание: лично я использую Seq в качестве моей коллекции по умолчанию. Это использует неизменяемую характеристику Seq. List/Vector/Array - это деталь реализации для производительности, а не функциональность. Список более эффективен для небольших коллекций.

Ответ 2

Используйте import scala.collection.mutable.MutableList или аналогичный, если вам действительно нужна мутация.

import scala.collection.mutable.MutableList
val x = MutableList(1, 2, 3, 4, 5)
x += 6 // MutableList(1, 2, 3, 4, 5, 6)
x ++= MutableList(7, 8, 9) // MutableList(1, 2, 3, 4, 5, 6, 7, 8, 9)

Ответ 3

Я попытаюсь объяснить результаты всех команд, которые вы пробовали.

scala> val l = 1.0 :: 5.5 :: Nil
l: List[Double] = List(1.0, 5.5)

Прежде всего, List - это псевдоним типа scala.collection.immutable.List (определенный в Predef.scala).

Использование сопутствующего объекта List является более простым способом создания экземпляра List. Пример: List(1.0,5.5)

scala> l
res0: List[Double] = List(1.0, 5.5)

scala> l ::: List(2.2, 3.7)
res1: List[Double] = List(1.0, 5.5, 2.2, 3.7)

::: возвращает список, полученный в результате конкатенации префикса данного списка и этого списка

Исходный список НЕ изменен

scala> List(l) :+ 2.2
res2: List[Any] = List(List(1.0, 5.5), 2.2)

List(l) - это List[List[Double]] Определенно не то, что вы хотите.

:+ возвращает новый список, состоящий из всех элементов этого списка, за которым следует элемент.

Тип List[Any], потому что это общий суперкласс между List[Double] и Double

scala> l
res3: List[Double] = List(1.0, 5.5)

l остается неизменным, потому что ни один метод в immutable.List не изменил список.

Ответ 4

Поскольку вы хотите добавить элементы в существующий список, вы можете использовать var List [Int], а затем продолжать добавлять элементы в один список. Примечание. > Вы должны убедиться, что вы вставляете элемент в существующий список следующим образом: -

var l: List [int] = List()//создает пустой список

l = 3:: l//добавляет 3 к заголовку списка

l = 4:: l//делает int 4 в качестве заголовка списка

//Теперь, когда вы будете печатать l, вы увидите два элемента в списке (4, 3)