章节目录

Scala数组Scala元组Scala集合不可变集合可变集合常用集合Scala List常用操作Scala List 排序方式 Scala Set常用操作Set集合求交、并、差集 Scala Map常用操作 Scala Stream & Vecto

Scala数组

存储固定大小的元素 数组索引从0开始

#数组创建方式一： 案例： var array:Array[String] = new Array[String](3) array(0) = "hello" array(1) = "world" array(2) = "scala"

#数组创建方式二： 案例： var array2 = Array("kb09","luoxing","gree","run")

#数组创建方式三：区间数组

Scala元组

1、可以包含不同类型的元素 2、最多支持22个元素（Tuple1~Tuple22） 3、使用下划线“_"访问元素，“_1"表示第一个元素

4、定义元组的方式：

#元组定义方式一 var tupleDemo = ("hello",2.4,12,"world",'a') println(tupleDemo) println(tupleDemo._1) println(tupleDemo._2) println(tupleDemo._3) println(tupleDemo._4) println(tupleDemo._5)

#元组定义方式二 var tupleDemo2 = new Tuple5(“ab”,“bc”,“cd”,“de”,“ef”) println(tupleDemo2)

#元组定义方式三 def mike="mike"->5->6 println(mike) println(mike.getClass)

5、迭代元组

tupleDemo.productIterator.foreach(x=> println("value:"+x))

6、将元组元素依次赋给三个变量

val tp1=("zhangsan","andemen",19) val (name,address,age)=tp1 println(name) println(address) println(age)

Scala集合

1、Seq 序列，元素按顺序排列2、Set 集合，元素不重复3、Map 映射，键值对集合

不可变集合

scala.collection.immutable，默认Scala选择不可变集合

可变集合

scala.collection.mutable，可以修改、添加或移除一个集合的元素

常用集合

Scala List常用操作

var c = List('a', 'b', 'c') var x = 'x' +: c // (x, a, b, c) var y = c :+ 'x' // (a, b, c, x) import scala.collection.mutable._ //导入可变集合 var lb = ListBuffer(1, 2, 3, 4) lb += 100 //1, 2, 3, 4, 100 lb += (21, 33) //1, 2, 3, 4,100,21,33 88 +=: lb //88, 1, 2, 3, 4, 100, 21, 33 List(77, 66) ++=: lb //77, 66,88,1,2,3,4,100, 21, 33

var l = List(2, 3, 4, 6, 8, 9, 11, 20) var x = l grouped 3 //分组读取，3表示分组元素个数 //等价l.grouped(3) x.next() //(2, 3, 4) x.next() //(6, 8, 9) var y = l sliding 2 //迭代器，滑动读取，2表示滑动的个数 y.next() // (2, 3) y.next() // (3, 4)

var a1 = Array[Int](1, 2, 3, 4) var a2 = Array[Int](100, 200, 300, 400) var a = List.concat(a1, a2) //Array->List 合并集合，结果类型为List

var a3=a1++a2 //Arrays->Array 合并集合，结果类型为Array

//过滤集合a中不能被2整除的元素 val x = a.filter( _ %2 != 0 )

Scala List 排序方式

方式一 //逆序排序 val y = a.reverse

方式二 a.sorted //排序，默认升序 a.sorted( Ordering.Int.reverse ) //逆序排序

方式三 a.sortWith( _ > _ ) //按逆序排序 a.sortWith(_ < _) //按升序排序

方式四 a.sortBy( x => x ) //升序 a.sortBy( x => x*(-1) ) //降序

Scala Set常用操作

var s = Set("ab", "yz") //默认immutable //s使用var修饰，s+=相当于对s重新赋值 s += "mn" //添加元素 s -= "yz" //删除元素

var t = Set("ab", "gh", "mn", "st", "yz" ) t -- s //集合t中删除集合s的元素 t ++ s //集合t中添加集合s的元素

#使用前需要导包：import scala.collection.mutable._ var os = SortedSet(1, 99, 66, 54, 77 ) //有序集合，结果会自动升序排序 os //1, 54, 66, 77, 99 os += 33 os //1, 33, 54, 66, 77, 99

Set集合求交、并、差集

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

Scala Map常用操作

//定义一个map var m = Map("a"->1, "b"->2, "c"->3, "d"->4, "e"->5, "f"->6, "g"->7, "h"->8, "i"->9) m("a") //1 m += ("j"->0) //m使用var修饰，m+=相当于对m重新赋值

//遍历map for((k,v) <- m){println(k+":"+v)}

//有序Map，按照key的字母序进行排序 val m2 = scala.collection.SortedMap("dd"->25,"cc"->30,"aa"->25,"bb"->29)

//定义一个可变map val stu = scala.collection.mutable.Map("jack"->20,"tom"->21,"peter"->22)

Scala Stream & Vecto

1、Stream是List惰性版，它只会确定第一个值，后面的值用到再求值，可以防止数据过大全部加载导致内存溢出 val stream = (1 to 1000).toStream stream // Stream(1, ?) stream.head // 1 stream.tail // Stream(2, ?) stream(3) // 4 stream.tail // Stream(2,3,4,?)

2、Vector拥有连续的内存空间，利于随机存取（直接访问） val v = Vector(1,2,3) val v1 = v ++ Vector(3) v(1) v1.length val x = IndexedSeq(1,2,3)