Scala序列List | 易学教程

Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable。
在 Scala 中集合有可变（mutable）和不可变（immutable）两种类型， immutable 类型的集合初始化后就不能改变了（注意与 val 修饰的变量进行区别）。

不可变序列
1. 构建List
2. 插入
3. 追加
4. 合并
序列常用操作
可变序列
1. 构建可变列表
2. 追加
3. 合并

不可变序列

导包

import scala.collection.immutable._

在 Scala 中列表要么为空（Nil 表示空列表）要么是一个 head 元素加上一个 tail 列表。
9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表。
注意： :: 操作符是右结合的，如 9 :: 5 :: 2 :: Nil 相当于 9 :: (5 :: (2 :: Nil))。

1. 构建List序列

// 构建不可变的序列
val lst = List(1,2,3)        // List(1, 2, 3)

2. 插入

//将 0 插入到 lst 的前面生成一个新的 List,几种方式
val lst2 = 0 :: lst
val lst3 = lst.::(0)
val lst4 = 0 +: lst
val lst5 = lst.+:(0)        // List(0, 1, 2, 3)

3. 追加

//将一个元素添加到 lst1 的后面产生一个新的集合
val lst6 = lst :+ 3        // List(1, 2, 3, 3)

4. 合并

val lst0 = List(1,2,3)
val lst1 = List(4,5,6)

//将 2 个 list 合并成一个新的 List
val lst2 = lst0 ++ lst1

//将 lst0 插入到 lst1 前面生成一个新的集合
val lst3 = lst0 ++: lst1

//将 lst0 插入到 lst1 前面生成一个新的集合
val lst4 = lst1.:::(lst0)

println(lst4)        // List(1, 2, 3, 4, 5, 6)

序列常用操作

构建列表

使用 :: 及 Nil 进行列表构建

val lst = 1 :: (2 :: (3 :: (4 :: Nil)))

// :: 操作符的优先级是从右往左，因此也可以这样写
val lst=1::2::3::4::Nil        // List(1, 2, 3, 4)

判断是否为空

lst.isEmpty        // false

取第一个无素

lst.head            // 1

取除第一个元素外剩余的元素，返回的是列表

lst.tail            // List(2, 3, 4)

取列表第二个元素

lst.tail.head            // 2

取列表最后一个元素

nums.last            // 4

取除最后一个元素外的元素，返回的是列表

nums.init            // List(1, 2, 3)

List 连接操作

List(1,2,3):::List(4,5,6)        // List(1, 2, 3, 4, 5, 6)

列表元素倒置

nums.reverse            // List(4, 3, 2, 1)

一些方法调用

nums.reverse.reverse==nums        // true

nums.reverse.init                // List(4, 3, 2)

scala> nums.tail.reverse        // List(4, 3, 2)

丢弃前 n 个元素

lst.drop(1)            // List(2, 3, 4)

lst drop(2)            // List(3, 4)

lst drop 3             // List(4)

获取前 n 个元素

lst take 1             // List(1)

lst.take(3)            // List(1, 2, 3)

将列表进行分割

lst.splitAt(2)                // (List(1, 2),List(3, 4))

(lst.take(2),lst.drop(2))     // (List(1, 2),List(3, 4))

Zip 操作

var lst0=List(1,2,3,4)            // List(1, 2, 3, 4)

val chars=List('1','2','3','4')   // List(1, 2, 3, 4)

//返回的是 List 类型的元组(Tuple）
lst0 zip chars    // List[(Int, Char)] = List((1,1), (2,2), (3,3), (4,4))

toString

lst.toString            // String = List(1, 2, 3, 4)

mkString

lst.mkString            // 1234

转换成数组

nums.toArray            // Array(1, 2, 3, 4)

排序插入算法实现

  // 排序
  def isort(xs: List[Int]): List[Int] = {
    if (xs.isEmpty) Nil
    else insert(xs.head, isort(xs.tail))
  }

  // 插入
  def insert(x: Int, xs: List[Int]): List[Int] = {
    if (xs.isEmpty || x <= xs.head)
      x :: xs
    else 
      xs.head :: insert(x, xs.tail)
  }

可变序列

import scala.collection.mutable._

1. 构建可变列表

// 初始 3 个元素 1,2,3
val lst = ListBuffer[Int](1,2,3)

创建空的可变列表

val lst = new ListBuffer[Int]

2. 追加

// 向 lst 中追加元素，注意：没有生成新的集合
lst += 4
lst.append(5)

// 将 lst1 中的元素追加到 lst0 中,注意：没有生成新的集合
lst0 ++= lst1

//将元素追加到 lst0 的后面生成一个新的集合
val lst3 = lst0 :+ 5

3. 合并

// 将 lst0 和 lst1 合并成一个新的 ListBuffer 注意：生成了一个集合
val lst2= lst0 ++ lst1

来源：CSDN

作者：南宫紫攸

链接：https://blog.csdn.net/weixin_45353054/article/details/104009256

标签

scala

immutable