1.数组
数组的定义
| // 数组的定义, 定义一个固定长度的数组, 长度可变, 内容可变 var x:Array[String] = new Array[String](3) // 定义定长数组, 长度不可变, 内容可变 val z = Array(1,2,3) |
map|flatten|flatMap|foreach 方法的使用
| // 定义一个数组 println(x.toBuffer) println("--------骚气的分割线--------") // 定义一个数组 // 将数组中的每个元素进行分割 // 此时数组中的每个元素进过 split 之后变成了 Array, flatten 是对 splitWords 里面的元素进行扁平化操作 //上述的2步操作,可以等价于flatMap, 意味先map操作后进行flatten操作 val result: Array[String] = words.flatMap(wd => wd.split(" ")) // 遍历数组, 打印每个元素 result.foreach(println) |
2. 集合的使用
Scala 的集合有三大类:序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable 特质 在 Scala 中集合有可变(mutable)和不可变(immutable)两种类型，immutable 类型的集合 初始化后就不能改变了(注意与 val 修饰的变量进行区别).
定长数组和变长数组
import scala.collection.mutable.ArrayBuffer object ArrayTest {
def main(args: Array[String]) {
//初始化一个长度为 8 的定长数组，其所有元素均为 0 val arr1 = new Array[Int](8) //直接打印定长数组，内容为数组的 hashcode 值 println(arr1) //将数组转换成数组缓冲，就可以看到原数组中的内容了 //toBuffer 会将数组转换长数组缓冲 println(arr1.toBuffer)
//注意:如果 new，相当于调用了数组的 apply 方法，直接为数组赋值 //初始化一个长度为 1 的定长数组
val arr2 = Array[Int](10)
println(arr2.toBuffer)
//定义一个长度为 3 的定长数组
val arr3 = Array("hadoop", "storm", "spark") //使用()来访问元素
println(arr3(2))
////////////////////////////////////////////////// //变长数组(数组缓冲)
// 如 果 想 使 用 数 组 缓 冲 ， 需 要 导 入 import
scala.collection.mutable.ArrayBuffer 包 val ab = ArrayBuffer[Int]() //向数组缓冲的尾部追加一个元素 //+=尾部追加元素
ab += 1
//追加多个元素
ab += (2, 3, 4, 5) //追加一个数组++=
ab ++= Array(6, 7) //追加一个数组缓冲
ab ++= ArrayBuffer(8,9) //打印数组缓冲 ab
//在数组某个位置插入元素用 insert ab.insert(0, -1, 0) //删除数组某个位置的元素用 remove ab.remove(8, 2)
println(ab)
}
}
5.2 Seq 序列
不可变的序列 import scala.collection.immutable._
在 Scala 中列表要么为空(Nil 表示空列表)要么是一个 head 元素加上一个 tail 列表。 9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
def main(args: Array[String]) { //创建一个不可变的集合 |
| //将 0 插入到 lst1 的前面生成一个新的 List val lst2 = 0 :: lst1 val lst5 = lst1.+:(0) val lst6 = lst1 :+ 3 val lst0 = List(4,5,6) //将 lst0 插入到 lst1 前面生成一个新的集合 val lst9 = lst1.:::(lst0) } |
注意::: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil)) 可变的序列 import scala.collection.mutable._
| import scala.collection.mutable.ListBuffer object MutListTest extends App{ //构建一个可变列表，初始有 3 个元素 1,2,3 val lst0 = ListBuffer[Int](1,2,3) //创建一个空的可变列表 //将 lst1 中的元素最近到 lst0 中， 注意:没有生成新的集合 lst0 ++= lst1 //将 lst0 和 lst1 合并成一个新的 ListBuffer 注意:生成了一个集合 val lst2= lst0 ++ lst1 //将元素追加到 lst0 的后面生成一个新的集合 |
集合常用的方法
| 方法 | 例子 | 说明 |
| map | 定义 val lt =List[Int](3,5,7) lt.map(x=>x*10) 所有元素都乘以10 |
|
| flatMap | 定义 val lt =List("we are coder","they are producer") lt.flatMap(x=>x.split(' ")) 每个元素会切分，并且铺平，行程的list为 |
|
| filter | 定义 val lt= List(3,4,7) lt.filter(x=>x>5) 会返回一个List(7) |
|
| sortedBy | 定义 val lt= List(3,4,7) val nw =lt.sortBy(x=> -x);会按list中的数据进行倒序排序 |
|
| sortedWith | val lt =List[(Int,Int)]((2,3),(3,4)) val nw =lt.sortWith((x,y)=>x._2 > y._2) 按照里面元素元组的第二个元素进行正序排序 |
|
| grouped | val lt =List[Int](3,4,3,5,6) val nw =lt.grouped(2).toList 会按2个元素一个组分组 |
|
| fold | val lt =List[Int](3,4,3,5,6) val s= lt.fold(21)((x,y)=>x-y) 以21为初始值，进行x-y的逻辑运算 |
|
| zip | val list1 =List[Int](1,5,3) val list2= List[Int](2,3,4) val list3= list1.zip(list2); list3将是一个将同一位置为元素的一个元祖 |
|
| mkString | val list1 =List[Int](1,5,3)
val s = list1.mkString("|")
s是一个以|将1，5，3隔开的字符串 |
|
| slice | val list1 =List[Int](1,5,3) val ss = list1.slice(1,3) ss是截取5，3两个数 |
map, flatten, flatMap, filter, sorted, sortBy, sortWith, grouped,
fold(折叠), foldLeft, foldRight, reduce, reduceLeft, aggregate, union, intersect(交集), diff(差集), head, tail, zip, mkString, foreach, length, slice, sum