ScalaNote16-集合之元组、列表、队列

元组Tuple

  元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组, 最多的特点灵活,对数据没有过多的约束。有点像R里的List~注意：元组中最大只能有22个元素!
  看个简单的Demo:

// 和python元组定义方式类似
val tuple1 = (1, 2, 3, "hello", 4)
println(tuple1)
println(tuple1.getClass.getSimpleName)

(1,2,3,hello,4)
Tuple5





tuple1: (Int, Int, Int, String, Int) = (1,2,3,hello,4)

• t1的类型是Tuple5类,是scala特有的类型
• t1的类型取决于t1后面有多少个元素,有对应关系，比如 4个元素=》Tuple4
• 元组中最大只能有22个元素 即 Tuple1…Tuple22

下面看下元组的访问和遍历

// 访问指定位置的元素
println(tuple1._1) //访问元组的第一个元素 ，从1开始
println(tuple1.productElement(0)) // 访问元组的第一个元素，从0开始
//遍历元素  
//和Array不同，元组需要调用productIterator
tuple1.productIterator.foreach((i=>print(i+",")))

1
1
1,2,3,hello,4,

列表List

  List和Array类似，也有List和ListBuffer。还是看个Demo:

val list01 = List(1, 2, 3) //创建时，直接分配元素
println(list01)
val list02 = Nil  //空集合
println(list02)

List(1, 2, 3)
List()





list01: List[Int] = List(1, 2, 3)
list02: scala.collection.immutable.Nil.type = List()

• List默认为不可变的集合
• List 在 scala包对象声明的,因此不需要引入其它包也可以使用
• val List = scala.collection.immutable.List
• List 中可以放任何数据类型，比如 arr1的类型为 List[Any]
• 如果希望得到一个空列表，可以使用Nil对象, 在 scala包对象声明的,因此不需要引入其它包也可以使用

下面再看下列表元素访问和追加：

val list01 = List(1, 2, 3) 
println("list01(0) = " + list01(0)+";"+"list01(1) = " + list01(1))
val list02 = list01 :+ 4 //在列表后面追加元素
println("list02 ="+list02)
val list03 = 0+:list01 //在列表前面增加元素
println("list03 ="+list03)
val list04 = 0::0::list01 //在列表前面增加元素
println("list04 ="+list04)
val list05 = 0::list01:::list01 //:::前面的List打散放到后面集合中
println("list05 ="+list05)
val list06 = 0::List(1,3):::0::list01 //在列表前面增加元素
println("list06 ="+list06)

list01(0) = 1;list01(1) = 2
list02 =List(1, 2, 3, 4)
list03 =List(0, 1, 2, 3)
list04 =List(0, 0, 1, 2, 3)
list05 =List(0, 1, 2, 3, 1, 2, 3)
list06 =List(0, 1, 3, 0, 1, 2, 3)





list01: List[Int] = List(1, 2, 3)
list02: List[Int] = List(1, 2, 3, 4)
list03: List[Int] = List(0, 1, 2, 3)
list04: List[Int] = List(0, 0, 1, 2, 3)
list05: List[Int] = List(0, 1, 2, 3, 1, 2, 3)
list06: List[Int] = List(0, 1, 3, 0, 1, 2, 3)

• 访问列表中元素，和array一致。()访问，索引从0开始计数
• 元素的追加并不改变原来的列表，而是新赋值给另一个列表
• ::表示把元素加到最右边的列表中
• :::表示把前面的集合元素打算加到最后边的列表中

ListBuffer和ArrayBuffer类似，属于可变集合。看下它的使用：

import scala.collection.mutable.ListBuffer  
println("--------- Create ---------")
val lstbuffer0 = ListBuffer[Any](1, 2, 3)
println("lstbuffer0 =" + lstbuffer0)
println("lstbuffer0(0)=" + lstbuffer0(0))
println("--------- Add Item---------")
//--- 追加一个or多个元素
lstbuffer0 += 4
lstbuffer0.append(5,6)
lstbuffer0.append(Array(7))
lstbuffer0.append(List(8,9))
println("lstbuffer0 =" + lstbuffer0)
//--- 列表和列表相加，元素打散  
val lstbuffer1 = ListBuffer[Any](1, 2, 3)
val lstbuffer2 = ListBuffer[Any](3, 2, 1)
val lstbuffer3 = lstbuffer1++lstbuffer2
println("lstbuffer3 = "+lstbuffer3)
// lstbuffer3 ++= lstbuffer1//这个相当于直接打散加入到lstbuffer3
println("--------- Remove Item---------")
lstbuffer3.remove(0)//删除第一个元素
println("lstbuffer3.remove(0) ="+lstbuffer3)
lstbuffer3.remove(0,2)//从第一个位置开始，删除两个元素
println("lstbuffer3.remove(0,2) ="+lstbuffer3)

--------- Create ---------
lstbuffer0 =ListBuffer(1, 2, 3)
lstbuffer0(0)=1
--------- Append Item---------
lstbuffer0 =ListBuffer(1, 2, 3, 4, 5, 6, [I@4897e374, List(8, 9))
lstbuffer3 = ListBuffer(1, 2, 3, 3, 2, 1)
--------- Remove Item---------
lstbuffer3.remove(0) =ListBuffer(2, 3, 3, 2, 1)
lstbuffer3.remove(0,2) =ListBuffer(3, 2, 1)





import scala.collection.mutable.ListBuffer
lstbuffer0: scala.collection.mutable.ListBuffer[Any] = ListBuffer(1, 2, 3, 4, 5, 6, Array(7), List(8, 9))
lstbuffer1: scala.collection.mutable.ListBuffer[Any] = ListBuffer(1, 2, 3)
lstbuffer2: scala.collection.mutable.ListBuffer[Any] = ListBuffer(3, 2, 1)
lstbuffer3: scala.collection.mutable.ListBuffer[Any] = ListBuffer(3, 2, 1)

• 追加元素有多个方法，就用append好了，提供那么多方法有啥用，又记不住。。。
• List和List的相加，用+
• remove和ArrayBuffer用法差不多，不提了

队列Queue

  之前没有接触过队列，简单看下特点和用法吧~

• 队列是一个有序列表，在底层可以用数组或是链表来实现
• 其输入和输出要遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
• 在Scala中，由设计者直接给我们提供队列类型使用
• 在scala中, 有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue , 一般来说，我们在开发中通常使用可变集合中的队列

import scala.collection.mutable
println("----------------- Create -----------------")
//说明: 这里的Int是泛型，表示q1队列只能存放Int类型
//如果希望q1可以存放其它类型，则使用 Any 即可。
val q1 = new mutable.Queue[Int] 
println("q1 = "+ q1)
println("----------------- Add Item -----------------")
q1 += 20 // 增加元素
println("q1 = "+ q1)
q1 ++= List(2,4,6) // 把List中元素一次放入队列中，注意放入的顺序从左往右
println("q1 = "+ q1)

----------------- Create -----------------
q1 = Queue()
----------------- Add Item -----------------
q1 = Queue(20)
q1 = Queue(20, 2, 4, 6)





import scala.collection.mutable
q1: scala.collection.mutable.Queue[Int] = Queue(20, 2, 4, 6)

队列的删除和加入

val q1 = new mutable.Queue[Int]
q1 += 12
q1 += 34
q1 ++= List(2,9)
println("q1 = "+q1)
q1.dequeue() //从队列头删除一个元素，队列头在最左边
println(q1)
q1.enqueue(20,60) //队列位加入元素
println(q1)

q1 = Queue(12, 34, 2, 9)
Queue(34, 2, 9)
Queue(34, 2, 9, 20, 60)





q1: scala.collection.mutable.Queue[Int] = Queue(34, 2, 9, 20, 60)

队列元素的查询

• 队列的第一个元素head
• 最后一个元素last
• 除第一意外的所有元素，tail

val q1 = new mutable.Queue[Int]
q1.enqueue(1,2,3,4,5,6) //队列位加入元素
//返回队列的第一个元素
println(q1.head)
//返回队列最后一个元素
println(q1.last)
//返回队列的尾部
//即：返回除了第一个以外剩余的元素， 可以级联使用，这个在递归时使用较多。
println(q1.tail)
println(q1.tail.tail)

1
6
Queue(2, 3, 4, 5, 6)
Queue(3, 4, 5, 6)





q1: scala.collection.mutable.Queue[Int] = Queue(1, 2, 3, 4, 5, 6)

                                2020-03-11 于南京市栖霞区