scala 数组集合（思维导图，初级必备）

scala 系列

scala 入门基础

scala 数组集合

scala 143个数组函数大全

scala 函数

scala OOP

scala 高级扩展

---

---

前言

上一篇博客 scala 入门基础 已经为大家带来的是 scala 入门简介和编程基础，相信大家都已经对 scala 有了初步的了解，同时也掌握了基础的 scala 编程能力。

本篇博客将为大家带来 scala 最常用的数组和集合的简单介绍，其中最实用最重要的数组和集合常用函数方法，将在下一篇博客 scala 数组函数大全 一 一详细案例解析！

---

数组Array

不可变数组

不可变数组指的是数组的长度是不允许改变。

// 通过指定长度声明数组
val/var 数组名 = new Array[元素泛型](数组长度)

// 声明并赋值
val/var 数组名 = Array(elem1,elem2,...elemn)

备注：

• 在scala中，数组的泛型使用 [] 来指定
• 使用 () 来获取元素

实例：

//数组创建方式一
var a1:Array[String] = new Array[String](3)
a1(0)="Jason"
a1(1)="Marie"
a1(2)="Jimmy"

//数组创建方式二
var a2=Array("Jason","Marie","Jimmy")

//数据创建方式三：区间数组
var a3=Array.range(1,10,2)

可变数组

可变数组指的是数组的长度是可变的，可以往数组中添加、删除元素。

// 创建空的ArrayBuffer变长数组，语法结构：
val/var 数组名 = ArrayBuffer[元素泛型]()

// 创建带有初始元素的ArrayBuffer
val/var 数组名 = ArrayBuffer(elem1,elem2,...elemn)

备注：

• 创建可变数组，需要提前导入ArrayBuffer类import scala.collection.mutable.ArrayBuffer

数组方法

下面介绍一下数组最常用的方法：

数组方法，详见我的下一篇博客scala Array 方法大全

常用集合

总体分类

• Seq：序列，元素按顺序排列
• Set：集合，元素不重复
• Map：映射，键值对集合

不可变集合分类：

scala.collection.immutable 包下：

• Set：ListSet、HashSet、TreeSet

• Map：ListMap、HashMap、TreeMap

• Seq：Vector、String、Range、List、Stack、Stream、Queue

可变集合分类：

处于scala.collection.mutable包下。

常用集合

名称	可变/不可变	示例
Buffer	mutable	val buffer = scala.collection.mutable.ArrayBuffer[Int](10, 20, 30); buffer+=(2,3)
Array	mutable	val arr=Array(1,2,3)
List	immutable	val lst=List(1,2,3)
Map	mutable	val stu= Map("name" -> "Jason", "age" -> "18")
Set	mutable/immutable	val set=Set(1,2,3)
Vector	immutable	val v=Vector(1, 3, 5, 7, 11, 13)
Stack	mutable/immutable	val st=scala.collection.mutable.Stack(1,2,3) //堆栈，先进后出
Queue	mutable/immutable	val q=scala.collection.mutable.Queue(1,2,3) //队列，先进先出
BitSet	mutable/immutable	val bit=scala.collection.mutable.BitSet(3,2,0) //位集合
ListMap	immutable	val map = scala.collection.immutable.ListMap(1->"one", 2->"two")
HashSet	mutable	val set= scala.collection.mutable.HashSet(1,2,3)
HashMap	mutable	val stu= scala.collection.mutable.HashMap("name" -> "Jason", "age" -> "18")

Scala Stream & Vector：

• Stream是List惰性版

  val stream = (1 to 1000).toStream
  stream     // Stream(1, ?)
  stream.head // 1
  stream.tail  // Stream(2, ?)
  stream(3)
  stream.tail  // Stream(2,3,4,?)
  

• Vector拥有连续的内存空间，利于随机存取（直接访问）

  val v = Vector.empty :+ 2 :+ 2
  val v1 = v ++ Vector[Int](3)
  v.length
  v1.length
  

元组Tuple

元组定义

元组可以用来包含一组不同类型的值。最多支持22个元素 （Tuple1~Tuple22）。无法修改元组中的值。

// 使用括号定义元组
val/var 元组 = （elem1,elem2,...elemn）

val/var 元组 =  new Tuplen(elem1,elem2,...elemn)

// 使用 -> 定义元组
val/var 元组 = elem1 -> elem2

访问元组

使用下划线“_"访问元素，“_1"表示第一个元素，依次类推。

实例：

//元组声明方式一
var tp1 = ("Mike", "123 ABC street", 58)
println(tp1._1)
println(tp1._2)
println(tp1._3)

//迭代元组
tp1.productIterator.foreach{ i =>println("Value = " + i )}

//元组声明方式二
var tp2 = new Tuple3("Mike", "123 ABC street", 58)

//元组声明方式三
def mike = "Mike" -> 5

//输出scala.Tuple2
mike.getClass

//将元组元素依次赋给三个变量
val(name, address, age) = tp1
println(name)
println(address)
println(age)

列表List

List 是 scala 中最重要的、也是最常用的数据结构。List具备以下性质:

• 可以保存重复的值
• 有先后顺序

在 scala 中，也有两种列表，一种是不可变列表、另一种是可变列表。

不可变列表

// 常规定义
val/var 列表 = List(elem1,elem2,...,elemn)

// 空列表定义
val/var 列表 = Nil

// :: 方法定义
val/var 列表 = elem1 :: elem2 :: ... :: elemn :: Nil

实例：

scala> val a = Nil
a: scala.collection.immutable.Nil.type = List()

scala> val a = 1 :: 2 :: Nil
a: List[Int] = List(1, 2)

scala> val a = List(1,2)
a: List[Int] = List(1, 2)

可变列表

可变列表就是列表的元素，长度都是可变的。要使用可变列表，先要导入import scala.collection.mutable.ListBuffer

// 常规定义
val/var 列表 = ListBuffer(elem1,elem2,...,elemn)

// 空列表定义
val/var 列表 = ListBuffer[泛型]()

注意：

• 可变集合都在mutable包中
• 不可变集合都在 immutable包中（默认导入）

列表方法

下面介绍一下列表最常用的方法：

列表方法与数组方法几乎一致，详见我的下一篇博客scala Array 方法大全

集Set

Set(集)是代表没有重复元素的集合。Set具备以下性质:

• 元素不重复
• 不保证插入顺序

scala中的集也分为2种，一种是不可变集，另一种是可变集。

不可变集

// 常规定义
val/var 集 = Set[泛型](elem1,elem2,...,elemn)

// 空列表定义
val/var 集 = Set[泛型]()

可变集

可变集合与不可变集合的创建方式一致，只不过需要提前导入一个可变集合类。要使用可变集，必须要手动导入： import scala.collection.mutable.Set

实例：

// 新增元素操作和删除元素操作
scala> val f = scala.collection.mutable.Set[Int]()
f: scala.collection.mutable.Set[Int] = Set()

// 新增方法一
scala> f.update(0,false)

scala> f.update(0,true)

scala> f
res59: scala.collection.mutable.Set[Int] = Set(0)

// 删除方法一
scala> f -= 0
res61: f.type = Set()

// 新增方法二
scala> f += 0
res62: f.type = Set(0)

// 删除方法二
scala> f - 0
res64: scala.collection.mutable.Set[Int] = Set()

集方法

集方法与数组方法几乎一致，详见我的下一篇博客scala Array 方法大全

实例：

var s = Set("ab", "yz")
s += "mn"    //mn, ab, yz
s += "mn"    //??
s -= "yz"       //mn, ab
var t = Set("ab", "gh", "mn", "st", "yz" )
t -- s       //gh, st, yz   
t ++ s    //ab, gh, mn, st, ya

var os = SortedSet(1, 99, 66, 54, 77 )
os  //1, 54, 66, 77, 99
os += 33
os  //1, 33, 54, 66, 7

var s = Set("ab", "yz")
var t = Set("ab", "gh", "mn", "st", "yz" )
//求交集
t & s       
t intersect s
//求并集
t | s
t union s
//求差集
t &~ s
t diff s

映射Map

Map可以称之为映射。它是由键值对组成的集合。在scala中，Map也分为不可变Map和可变Map。

不可变Map

val/var 映射 = Map(key -> value, key -> value,..., key -> value)

val/var 映射 = Map((key,value),(key,value),...,(key,value))

可变Map

定义语法与不可变Map一致，可变Map需要手动导入import scala.collection.mutable.Map

实例：

scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map

scala> val map = Map("zhangsan"->30,"lisi"->40)
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)

scala> map("zhangsan")=20

scala> map
res66: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 20)

映射方法

映射方法与数组方法几乎一致，详见我的下一篇博客scala Array 方法大全

实例：

var m = Map[String, Int]("a"->1, "b"->2, "c"->3, "d"->4, "e"->5, "f"->6, "g"->7, "h"->8, "i"->9)
m("a")        //1

//新增元素
m += ("j"->0)   // Map(e -> 5, j -> 0, f -> 6, a -> 1, i -> 9, b -> 2, g -> 7, c -> 3, h -> 8, d -> 4)

// 修改元素
m += ("j"->11)   // Map(e -> 5, j -> 11, f -> 6, a -> 1, i -> 9, b -> 2, g -> 7, c -> 3, h -> 8, d -> 4)

// 新增map
var n = m ++ Map[String, Int]("a"->3, "j"->99)    // Map(e -> 5, j -> 99, f -> 6, a -> 3, i -> 9, b -> 2, g -> 7, c -> 3, h -> 8, d -> 4)

// 删除元素
n -= ("g", "e")		//Map(j -> 99, f -> 6, a -> 3, i -> 9, b -> 2, c -> 3, h -> 8, d -> 4)

本次分享就到这里，对于初学者来说，关于数组和集合的函数方法，原则上是必须要掌握且要硬记下来的！这对后续的spark学习有很大的帮助！