Scala集合是保存序列线性项(如列表，集合，元组，选项，地图等)的容器。
集合可以是严格的或者惰性的。
直到访问它们才分配内存。
集合可以是可变的或者不变的。

在本文中，让我们了解列表和集合。

Scala列表

列表中的元素具有相同的数据类型。
列表类似于数组，但有两个区别，即列表是不可变的，列表表示链表，而数组是平面。

List表示为" List [T]"，其中T是元素的数据类型。

考虑一个例子；

val StudentNames[String] = List("Rohan", "Andreas", "Rob", "John")

空列表可以创建为

val em: List[Nothing] = List()

二维列表可以创建为

val twodim: List[List[Int]] =
 List(
    List(1, 0, 0),
    List(0, 1, 0),
    List(0, 0, 1)
 )

Scala列表上的基本操作

基本操作包括：

head：返回列表中的第一个元素。

tail：返回列表中第一个元素以外的所有元素。

isempty：如果列表为空，则返回true。

考虑这些操作的例子。

object Student {
def main(args:Array[String]) {
  val names= "Harry" :: ("Adam" :: ("Jill" :: Nil))
  val age = Nil
    println( "Head of names array : " + names.head )
    println( "Tail of names array : " + names.tail )
    println( "Check if names is empty : " + names.isEmpty )
    println( "Check if age is empty : " + age.isEmpty )
 }
}

我们正在创建带有两个列表的学生对象-名称和年龄。
我们正在调用数组名称和年龄的head，tail和empty方法。

输入Student.main(null)运行输出，您将看到以下输出。

Head of names array : Harry
Tail of names array : List(Adam, Jill)
Check if names is empty : false
Check if age is empty : true

您也可以将以上代码保存在Student.scala文件中，并以

$scalac Student.scala
$scala Student
Head of names array : Harry
Tail of names array : List(Adam, Jill)
Check if names is empty : false
Check if age is empty : true

Scala串联列表

要连接列表，我们使用:::或者List。
:: :()或者concat方法来连接两个或者多个列表。

考虑一个如何串联列表的例子

object Country {
	def main(args:Array[String]) {
	val country_1 =  List("San Franceco","SriLanka","Algeria")
	val country_2 = List("Austria","Belgium","Canada")

	val country = country_1 ::: country_2
	println( "country_1 ::: country_2 : " + country )

	val cont = country_1.:::(country_2)
          println( "country_1.:::(country_2) : " + cont )
	val con = List.concat(country_1, country_2)
          println( "List.concat(country_1, country_2) : " + con  )

 }
}

我们创建了两个列表country_1和country_2。
我们使用:::运算符将两个列表country_1和country_2连接到一个国家列表中。
在第二种情况下，我们使用。
:::运算符将country_1和country_2合并到"连续"列表中，并且将首先插入第二个列表country_2数据，然后显示country_1列表数据。

最后，我们使用concat方法将country_1和country_2连接到列表" con"中。

通过输入Country.main(null)运行以上代码，您将看到以下输出。

country_1 ::: country_2 : List(San Franceco, SriLanka, Algeria, Austria, Belgium, Canada)
country_1.:::(country_2) : List(Austria, Belgium, Canada, San Franceco, SriLanka, Algeria)
List.concat(country_1, country_2) : List(San Franceco, SriLanka, Algeria, Austria, Belgium, Canada)

Scala反向列表顺序

List数据结构提供List.reverse方法来反转列表的所有元素。

考虑下面的示例。

object Country {
	def main(args:Array[String]) {
	val country = List("Denmark","Sweden","France")
	println("Country List before reversal :" + country)
	println("Country List after reversal :" + country.reverse)
}
}

其中我们使用反向方法来反转国家/地区列表的元素。

通过输入Country.main(null)运行代码，您将看到以下输出。

Country List before reversal :List(Denmark, Sweden, France)
Country List after reversal :List(France, Sweden, Denmark)

Scala创建统一列表

List.fill()方法创建相同元素的零个或者多个副本。

考虑一个例子；

object Student {
 def main(args: Array[String]) {
    val name = List.fill(6)("Rehan") 
    println( "Name : " + name  )

    val id = List.fill(6)(12)         
    println( "Id : " + id  )
 }
}

其中我们使用fill方法并为六个元素创建名称相同的名称列表" Rehan"。
对于所有六个元素，使用相同的ID 12创建的ID列表。

scala>Student.main(null)

Name : List(Rehan, Rehan, Rehan, Rehan, Rehan, Rehan)
Id : List(12, 12, 12, 12, 12, 12)

Scala列表方法

List支持的其他一些方法是：

定义：List [X]→从列表中构建一个没有任何重复元素的新列表。

def indexOf(elem：X，from：Int)：Int→在某个起始索引之后或者起始索引处查找列表中某个值首次出现的索引。

def length：Int→返回列表的长度。

def sorted [Y>：X]：列表[X]→根据顺序对列表进行排序。

def sum：A→汇总此集合的元素。

def toString()：字符串→将列表转换为字符串。

def min：A→查找最小的元素。

def max A→查找最大元素。

def lastIndexOf(elem：A，end：Int)：Int→查找列表中某个给定的结束索引之前或者之后最后出现某个值的索引。

def toMap [X，Y]：Map [X，Y]→将此列表转换为地图。

斯卡拉集

Set是相同类型的唯一元素的集合。
与列表不同，Set不包含重复的元素。
集可以是可变的或者不可变的。
当对象是不可变的时，对象本身无法更改。

Scala默认使用不可变集。
导入" scala.collection.mutable.Set"以显式使用可变集。

例如;

val country = Set("Russia", "Denmark", "Sweden")

可以将Integer数据类型集创建为

var id : Set[Int] = Set(4,5,6,7,8,9)

空集可以创建为；

var age = Set()

Scala中集合的基本操作

基本操作包括：

head→返回集合的第一个元素。

tail→返回集合中第一个元素以外的所有元素。

isempty→如果集合为空，则返回true，否则返回false。

考虑一个例子；

object Student {
 def main(args: Array[String]) {
    val name = Set("Smith", "Brown", "Allen")
    val id: Set[Int] = Set()

    println( "Head of name : " + name.head )
    println( "Tail of name : " + name.tail )
    println( "Check if name is empty : " + name.isEmpty )
    println( "Check if id is empty : " + id.isEmpty )
 }
}

其中我们用两个集合"名称"和" id"创建学生对象。
我们正在对这些数组执行头，尾和空操作，并打印结果。

scala>Student.main(null)

Head of name : Smith
Tail of name : Set(Brown, Allen)
Check if name is empty : false
Check if id is empty : true

Scala连接集

要连接一个或者多个集合，请使用++运算符或者Set。
++()方法。
在添加集合时，将删除重复项。

例如;

object Furniture {
 def main(args: Array[String]) {
    val furniture_1 = Set("Sofa", "Table", "chair")
    val furniture_2 = Set("Bed", "Door")

     var furniture = furniture_1 ++ furniture_2
    println( "furniture_1 ++ furniture_2 : " + furniture )

    var furn = furniture_1.++(furniture_2)
    println( "furniture_1.++(furniture_2) : " + furn )
 }
}

我们正在创建两组家具_1和furniture_2，并使用++和Set。
++运算符将这两组家具连接成furniture和furn。

scala> Furniture.main(null)

furniture_1 ++ furniture_2 : Set(Door, Sofa, Bed, Table, chair)
furniture_1.++(furniture_2) : Set(Door, Sofa, Bed, Table, chair)

一组通用值

Set.`方法或者Set.intersect方法可用于查找两个或者更多集合中的公共元素。

考虑下面的示例。

object Numbers {
 def main(args: Array[String]) {
    val n1 = Set(11,45,67,78,89,86,90)
    val n2 = Set(10,20,45,67,34,78,98,89)

    println( "n1.&(n2) : " + n1.&(n2) )
    println( "n1.intersect(n2) : " + n1.intersect(n2) )
 }
}

我们正在创建两组数字n1和n2，并找到两组数字中存在的共同元素。

scala> Numbers.main(null)

n1.&(n2) : Set(78, 89, 45, 67)
n1.intersect(n2) : Set(78, 89, 45, 67)

一组中的最大和最小元素

Set.min方法用于找出最小值，Set.max方法用于找出集合中可用元素的最大值。

考虑一个例子；

object Numbers {
 def main(args: Array[String]) {
    val num1 = Set(125,45,678,34,20,322,10)

    println( "Minimum  element in the Set is : " + num1.min )
    println( "Maximum  element in the Set is : " + num1.max )
 }
}

我们使用最小和最大方法在集合" num1"中找到最小和最大数目。

scala> Numbers.main(null)

Minimum  element in the Set is : 10
Maximum  element in the Set is : 678

其他有用的Scala设置方法

Scala编程中的一些Set方法是：

def contains(elem：X)：布尔值→如果此集合中包含elem，则返回true，否则返回false。

def last：X→返回最后一个元素。

def product：X→返回该不可变集的所有元素相对于num中的*运算符的乘积

def size：Int→返回此不可变集中的元素数。

def sum：X→返回相对于num中的+运算符，此不可变集合的所有元素的总和。

def toList：List [X]→返回包含此不可变集合的所有元素的列表。

def toSeq：Seq [X]→返回一个包含此不可变集合的所有元素的序列。

def toArray：Array [X]→返回包含此不可变集合的所有元素的数组。

def subsetOf(that：Set [X])：布尔值→如果此集合是该集合的一个子集，即该集合的每个元素也是该集合的一个元素，则返回true。

def mkString：字符串→在字符串中显示此不可变集合的所有元素。