Scala中的集合包括Seq序列、Set组、Map映射，Seq包含了有索引的数组(Array、ArrayBuffer)和无索引的列表(List、ListBuffer)。
不可变集合指的是集合对象的存放地址、集合大小与类型、占用内存空间不可修改，只可以修改元素。若增删元素，则每次增删后会产生新对象，原有对象不会改变
可变集合指的是集合对象的存放地址、集合大小与类型、占用内存空间都可以修改，每次修改后不会产生新对象。对可变集合的操作尽量不要重新赋予新变量，因为新变量改变后，原变量也会随之改变。
可变集合包：scala.collection.mutable
不可变集合包：scala.collection.mutable
一、数组
数组就是常见的下标与元素一一对应的集合，即有索引的Seq。数组也分为可变与不可变，都用new关键字创建
new Array/ArrayBuffer[type](length)不可变数组是Array，可变数组是ArrayBuffer，可变数组的长度可以不定义
1、不可变数组
创建长度为5的整数型数组，并访问、修改元素
object Main {
def main(args:Array[String])=
{
//空数组
val arr1 = new Array[Int](5)
//值数组
val arr2 = Array(1,2,4,3,6)
//访问数组第一个元素
println(arr2(0))
//修改并访问数组第2个元素
arr2(1) = 8
println(arr2(1))
}
}
遍历数组所有元素
object Main {
def main(args:Array[String])=
{ //直接遍历
for (i <- arr2) println(i)
//调用foreach方法
arr2.foreach(println)
//角标遍历
for (j <- 0 until arr2.length) println(arr2(j))
for (m <- arr2.indices) println(arr2(m)) //indices相当于数组所有角标组成的序列
//迭代器，存在下一个则输出
val iter = arr2.iterator
while (iter.hasNext)
println(iter.next())
//输出所有元素组成的字符串
println(arr2.mkString(" "))
}
}
增加元素产生新对象
调用方法：最后边新增:+、最前边新增+:
object Main {
def main(args:Array[String])=
{
val arr2 = Array(1,2,4,3,6)
//在最前面加元素
val newarr = arr2.+:(8)
val newarr1 = arr2.+:(8).+:(9)
val newarr6 = 1 +: arr2 //方法调用的圆点可以省略，等同于数组、方法、新增元素用空格隔开。方法以:结尾时，右边往前调用的，也就是数组要在方法右侧，新增元素在方法左侧
println(newarr.mkString("-"))
println(newarr1.mkString("-"))
println(newarr6.mkString("-"))
//在最后边加元素
val newarr2 = arr2.:+(7)
val newarr3 = arr2.:+(0).:+(6)
val newarr7 = arr2 :+ 2 //方法调用的圆点可以省略，等同于数组、方法、新增元素用空格隔开
println(newarr2.mkString("-"))
println(newarr3.mkString("-"))
println(newarr7.mkString("-"))
//同时在前后加元素
val newarr4 = arr2.:+(1).:+(2).+:(3).+:(4)
val newarr5 = 1 +: 2 +: arr2 :+ 3 :+ 4
println(newarr4.mkString("-"))
println(newarr5.mkString("-"))
}
}
2、可变数组
创建数组，访问、修改元素同不可变数组
object Main extends App {
import scala.collection.mutable._
//创建空数组
val arr:ArrayBuffer[Int] = new ArrayBuffer[Int]()
//创建值数组
val newarr = ArrayBuffer(1,2,3)
println(arr)
println(newarr) //可变数组可直接输出，默认调用toString方法
}
ArrayBuffer()
ArrayBuffer(1, 2, 3)
增加元素
调用方法：最后边新增+=或append、最前边新增+=:或prepend、按索引插入元素insert、按索引插入数组insertAll或prependAll或appendAll
object Main extends App {
import scala.collection.mutable._
val newarr = ArrayBuffer(1,2,3)
val newarr1 = Array(4,5)
//最后边新增元素
newarr += 4 += 5
newarr.append(6,7)
//最前边新增元素
0 +=: newarr
newarr.prepend(8,9)
//按索引新增元素
newarr.insert(1,2,3) //新增元素
//新增数组
newarr.appendAll(newarr1) //最前边
newarr.prependAll(newarr1) //最后边
newarr.insertAll(2,newarr1) //按索引
println(newarr)
}
ArrayBuffer(4, 5, 4, 5, 8, 2, 3, 9, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5)
删除元素
调用方法：删除元素-=、按索引删除remove
object Main extends App {
import scala.collection.mutable._
val newarr = ArrayBuffer(1,2,3,4,5)
//删除元素
newarr -= 3
println(newarr)
//按索引删除
newarr.remove(1) //删除索引1对应的元素
println(newarr)
newarr.remove(0,2) //从索引0开始，删除2个元素
println(newarr)
}
ArrayBuffer(1, 2, 4, 5)
ArrayBuffer(1, 4, 5)
ArrayBuffer(5)
3、可变数组与不可变数组的相互转换：toArray、toBuffer
object Main extends App {
import scala.collection.mutable._
//可变转不可变
val newarr = ArrayBuffer(1,2,3,4,5)
val arr = newarr.toArray
println(newarr)
println(arr.mkString(","))
//不可变转可变
val newarr1 = (arr :+ 8).toBuffer
println(newarr1)
}
4、多维数组
多维数组用Array.ofDim[type](i,j,…)，i表示几行，j表示几列
创建2维数组，并访问
object Main extends App {
//创建2行3列的数组
val arr = Array.ofDim[Int](2,3)
println(arr.mkString(","))
//元素修改
arr(0)(1) = 2
arr(1)(2) = 3
//按角标遍历
for (i <- 0 until arr.length;j <- 0 until arr(i).length) println(arr(i)(j)) //输出每个元素
for (i <- arr.indices;j <- arr(i).indices) {
print(arr(i)(j) + "\t") //每行元素用空格分隔
if (j == arr(i).length-1) println() //每行到最后一个元素时，输出空行
}
//调用foreach方法
arr.foreach(line => line.foreach(println)) //数组的每行都调用方法
arr.foreach(_.foreach(println)) //方法简写
}
5、队列Queue
队列为有序数组，先进 Queue.enqueue() 先出 Queue.dequeue，分为可变与不可变，分别用scala.collection.mutable/immutable来创建
队列是一个类，创建空队列需要使用关键字new(一般只有可变队列会先创建空队列，再往里边新增元素；不可变队列直接创建即可)
最常使用的是可变队列
- 可变队列，队列可直接新增元素
object Main extends App {
val list = List("f,g")
val queue = new scala.collection.mutable.Queue[Any]
queue.enqueue("a","b",3)
println("队列：" + queue)
println("第一个元素：" + queue.head) //第一个元素
println("最后一个元素：" + queue.last) //最后一个元素
println("尾队列：" + queue.tail) //除第一个元素外剩下的队列
println("首队列：" + queue.init) //除最后一个元素外剩下的队列
println("前2个元素：" + queue.take(2))
println("后2个元素：" + queue.takeRight(2))
println("出1：" + queue.dequeue)
println("队列：" + queue)
println("出2：" + queue.dequeue)
println("队列：" + queue)
//新增元素
queue.enqueue("d","e")
queue += "f"
println("新进：" + queue)
println("出3：" + queue.dequeue)
println("队列：" + queue)
//新增list内所有元素
println("新增list内所有元素")
println(queue ++= list)
//新增list为一个元素
println("新增list为一个元素")
println(queue += list)
}
队列：Queue(a, b, 3)
第一个元素：a
最后一个元素：3
尾队列：Queue(b, 3)
首队列：Queue(a, b)
前2个元素：Queue(a, b)
后2个元素：Queue(b, 3)
出1：a
队列：Queue(b, 3)
出2：b
队列：Queue(3)
新进：Queue(3, d, e, f)
出3：3
队列：Queue(d, e, f)
新增list内所有元素
Queue(d, e, f, f,g)
新增list为一个元素
Queue(d, e, f, f,g, List(f,g))
- 不可变队列
object Main extends App {
val queue1 = scala.collection.immutable.Queue(1,2,3)
println("队列：" + queue1)
println(queue1.dequeue)
println("队列：" + queue1)
val queue2 = queue1.enqueue(4,5)
println("出2：" + queue2.dequeue)
println("队列：" + queue2)
}
队列：Queue(1, 2, 3)
(1,Queue(2, 3))
队列：Queue(1, 2, 3)
出2：(1,Queue(2, 3, (4,5)))
队列：Queue(1, 2, 3, (4,5))
二、列表
列表List是一个没有索引的Seq序列，也分为可变和不可变。不可变列表本质是一个抽象类，创建的时候不需要使用new关键字，但可变列表创建时需要使用new关键字。直接创建含值列表时，可用List/ListBuffer()创建。
1、不可变列表
object Main extends App {
//用List创建列表
val list = List(1,2,3,4)
println(list) //列表是封闭的，所以可以按列表形式直接打印
//用Nil调用方法::，创建列表。Nil是一个空列表
val list5 = 12 :: 13 :: 14 :: Nil
println(list5)
//访问元素的方式跟数组相同，这只是scala底层针对列表访问做了优化，并不代表列表有索引。列表就不能按索引赋值
println("元素2：" + list(1))
//调用foreach方法
list.foreach(println)
}
List(1, 2, 3, 4)
List(12, 13, 14)
元素2：2
1
2
3
4
元素新增
object Main extends App {
val list = List(1,2,3,4)
println("list：" + list)
//添加元素
val list1 = list :+ 5 :+ 6
println("list1：" + list1)
val list2 = 7 +: 8 +: list
println("list2：" + list2)
//调用::方法，给列表最前边加元素
val list3 = list.::(0).::(1)
val list4 = 2 :: 3 :: list
println("list3：" + list3)
println("list4：" + list4)
//列表合并，调用方法:::或++
val list5 = list1 ::: list
val list6 = list1 ++ list
println("list5：" + list5)
println("list6：" + list6)
}
list：List(1, 2, 3, 4)
list1：List(1, 2, 3, 4, 5, 6)
list2：List(7, 8, 1, 2, 3, 4)
list3：List(1, 0, 1, 2, 3, 4)
list4：List(2, 3, 1, 2, 3, 4)
list5：List(1, 2, 3, 4, 5, 6, 1, 2, 3, 4)
list6：List(1, 2, 3, 4, 5, 6, 1, 2, 3, 4)
2、可变列表
object Main extends App {
import scala.collection.mutable._
val list = new ListBuffer[Int]()
val list1 = ListBuffer(1,2,3)
val list2 = ListBuffer(14,15)
println("list：" + list)
println("list1：" + list1)
//添加元素
list1.append(4,5)
println("list1：" + list1)
list1.prepend(6,7)
println("list1：" + list1)
10 +=: 11 +=: list1 += 8 += 9
println("list1：" + list1)
list1.insert(1,12,13)
println("list1：" + list1)
//插入列表
list1.insertAll(1,list2)
println("list1：" + list1)
list1.appendAll(list2)
println("list1：" + list1)
list1.prependAll(list2)
println("list1：" + list1)
//列表合并
list1 ++= list2 //只改变list1,list2不变
println("list1：" + list1)
println("list2：" + list2)
//修改元素
list1(2) = 1
println("元素2：" + list1(2))
//删除元素
list1.remove(1) //删除第2个元素
println("删除第2个元素" + list1)
list1 -= 3 //删除元素3
println("删除元素3" + list1)
}
list：ListBuffer()
list1：ListBuffer(1, 2, 3)
list1：ListBuffer(1, 2, 3, 4, 5)
list1：ListBuffer(6, 7, 1, 2, 3, 4, 5)
list1：ListBuffer(10, 11, 6, 7, 1, 2, 3, 4, 5, 8, 9)
list1：ListBuffer(10, 12, 13, 11, 6, 7, 1, 2, 3, 4