Scala之List

列表

不可变列表(List)

1. 在Scala中，通过List来定义不可变列表，需要注意的是，List本身是一个抽象类，所以并不能直接使用List来构建对象，需要使用它的伴生对象来构建

   package com.fesco.list
   
   import scala.::
   
   object ListDemo {
   
     def main(args: Array[String]): Unit = {
   
       // 方式一
       val list = List[Int](2, 3, 4, 5, 6)
       println(list)
       val list2 = List.apply(2, 3, 4, 5, 6)
       println(list2)
   
       // 方式二：
       // :: 在list之前来追加数据
       val list3 = 1 :: list
       println(list3)
   
       // 方式三：
       // Nil是List的子类，表示一个空列表
       val list4 = Nil
       println(list4)
   
       // 方式四：
       val list5 = 1 :: 2 :: 3 :: 4 :: Nil
       println(list5)
    
     }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31

2. List被sealed修饰，说明List是一个密封类，那么就意味着List的子类必须和List处在同一个scala文件中，即List无法直接扩展

3. 基本操作

   package com.fesco.list
   
   object ListDemo2 {
   
     def main(args: Array[String]): Unit = {
   
       val list = List[Int](3, 4, 8, 1, 5, 9, 7)
   
       // 获取指定下标位置上的元素
       // 底层实际上是调用了父特质LinearSeq中的apply函数
       println(list(2))
       // 等价于
       println(list.apply(2))
       // 获取第一个元素
       // println(list(0))
       // 等价于
       println(list.head)
       // 获取最后一个元素
       println(list.last)
       // 追加一个元素 - 产生一个新的列表
       // val r1 = list :+ 6
       val r1 = list.:+(6)
       println(r1)
       // 在头部追加元素
       // 从右向左计算
       val r2 = 1 +: list
       // val r2 = list.+:(1)
       // 当出现:的时候，:对着谁就从谁开始计算
       // 如果两边都有:，那么从右向左计算
       // 错误的写法：list +: 1
       println(r2)
       // 或者
       // val r3 = list.::(1)
       val r3 = 1 :: list
       // list :: 1
       println(r3)
       // 构建了列表
       // 从右到左：先构建空列表List()，然后头部拆入5，在插入4
       val r4 = 1 :: 2 :: 3 :: 4 :: 5 :: List()
       // 等价于
       val r5 = 1 :: 2 :: 3 :: 4 :: 5 :: Nil
       println(r4)
       println(r5)
   
     }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47

4. 列表的合并

   package com.fesco.list
   
   object ListDemo3 {
   
     def main(args: Array[String]): Unit = {
   
       val list1 = List[Int](1, 2, 3, 4)
       val list2 = List[Int](5, 6, 7, 8)
   
       // 合并列表
       val r1 = list1 ++ list2
       println(r1)
       val r2 = list1 ++: list2
       println(r2)
       val r3 = list1 :++ list2
       println(r3)
       val r4 = list1.concat(list2)
       println(r4)
       val r5 = list1 ::: list2
       println(r5)
   
     }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24

可变列表(ListBuffer)

1. Scala中，通过ListBuffer来定义可变列表

   package com.fesco.list
   
   import scala.collection.mutable.ListBuffer
   
   object ListBufferDemo {
   
     def main(args: Array[String]): Unit = {
   
       // 方式一
       // 调用ListBuffer类的主构造器
       val buffer1 = new ListBuffer[Int]()
       buffer1 += 4
       println(buffer1)
       // 方式二
       // 调用了ListBuffer伴生对象中的apply函数
       val buffer2 = ListBuffer[Int](1, 2, 3, 4, 5)
       println(buffer2)
   
     }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21

2. 基本操作

   package com.fesco.list
   
   import scala.collection.mutable.ListBuffer
   
   object ListBufferDemo2 {
   
     def main(args: Array[String]): Unit = {
   
       val list = ListBuffer[Int](1, 2, 3, 4, 5)
   
       // 在尾部追加元素
       list += 4
       list append 7
       println(list)
       // 在头部插入元素
       list prepend 0
       // list.+=:(2)
       2 +=: list
       println(list)
       // 在指定下标位置上插入元素
       list.insert(3, 6)
       println(list)
       // 修改指定位置上的元素
       list(2) = 10
       list.update(3, 12)
       println(list)
       // 删除指定下标位置上的元素
       list.remove(0)
       println(list)
       // 删除指定的元素(第一个)
       list -= 3
       println(list)
   
     }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36

3. 合并列表

   package com.fesco.list
   
   import scala.collection.mutable.ListBuffer
   
   object ListBufferDemo3 {
   
     def main(args: Array[String]): Unit = {
   
       val list1 = ListBuffer[Int](1, 2, 3)
       val list2 = ListBuffer[Int](4, 5, 6)
   
       // 将list1和list2合并
       // ++合并之后产生一个新的列表，而不是修改原列表
       val r1 = list1 ++ list2
       println(r1)
       // 要求：将list2中的数据合并到list1中
       list1 ++= list2
       println(list1)
       // 获取list1中有而list3中没有的数据 - 差集
       val list3 = ListBuffer[Int](1, 3, 5, 7)
       list1 --= list3
       println(list1)
   
     }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26