scala基本语法

Map：集合a）不可变Map定义一个Map**（默认为不可变）**获取map的name映射获取map的age映射可以使用以下get方法，但是不简洁 b）可变Map：需要导包导包定义一个Map元素的增加元素的删除遍历Map tuple：元组定义元组如果元组只有两个元素，那么就是对偶元组，map映射是对偶元组的集合 元组的方法元组的迭代器 List：列表不可变列表 List定义一个列表，里面含有两个以上元素List.head：返回列表第一个元素List.tail：返回列表除第一个元素的所以元素定义一个列表，里面含有一个元素List.tail返回一个空列表在list前加上元素，构成新列表。原列表不变在list后加上元素，构成新列表。原列表不变 可变列表ListBuffer，需要导包定义一个可变列表可变集合的元素增加可变集合的元素删除列表头部添加元素 set集合，没有重复元素，无序定义不可变setset之间的运算set的改变集合的遍历 flatMap方法

Map：集合

a）不可变Map

定义一个Map**（默认为不可变）**

scala> val m = Map("name" -> "dumb" , "age" -> 60) m: scala.collection.immutable.Map[String,Any] = Map(name -> dumb, age -> 60)

获取map的name映射

scala> m("name") res44: Any = dumb

获取map的age映射

scala> m("age") res46: Any = 60

可以使用以下get方法，但是不简洁

scala> m.get("age") res47: Option[Any] = Some(60) scala> m.get("name") res48: Option[Any] = Some(dumb)

b）可变Map：需要导包

导包

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

定义一个Map

scala> val m1 = Map("name" -> "dumb" , "age" -> 60) m1: scala.collection.mutable.Map[String,Any] = Map(age -> 60, name -> dumb)

元素的增加

scala> m1 += ("city" -> "shenzheng") //m1.put("city" -> "shenzheng") res49: m1.type = Map(city -> shenzheng, age -> 60, name -> dumb)

元素的删除

scala> m1 -= ("city") //m1.remove("city") res50: m1.type = Map(age -> 60, name -> dumb)

遍历Map

scala> for((x,y) <- m1) println(x +"-----------"+y) age-----------60 name-----------dumb //也可以使用如下 scala> for(i <- m1.keys) println(i +"-----------"+m1(i)) age-----------60 name-----------dumb

tuple：元组

定义元组

如果元组只有两个元素，那么就是对偶元组，map映射是对偶元组的集合

scala> val t =(12,"hello",true,1.22) t: (Int, String, Boolean, Double) = (12,hello,true,1.22) scala> t res72: (Int, String, Boolean, Double) = (12,hello,true,1.22)

元组的方法

scala> t. _1 _2 _3 _4 canEqual copy equals hashCode productArity productElement productIterator productPrefix toString scala> t._2 res71: String = hello

元组的迭代器

scala> t.productIterator.foreach(println(_)) 12 hello true 1.22 scala> t.productIterator.foreach(i => println(i)) 12 hello true 1.22

List：列表

不可变列表 List

定义一个列表，里面含有两个以上元素

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

List.head：返回列表第一个元素

scala> l.head res79: Int = 1

List.tail：返回列表除第一个元素的所以元素

scala> l.tail res80: List[Int] = List(2, 3)

定义一个列表，里面含有一个元素

scala> val l1 = List(1) l1: List[Int] = List(1)

List.tail返回一个空列表

scala> l1.tail res81: List[Int] = List()

在list前加上元素，构成新列表。原列表不变

scala> 0 +: l1 res88: List[Int] = List(0, 1)

在list后加上元素，构成新列表。原列表不变

scala> l1 :+ 2 res87: List[Int] = List(1, 2)

可变列表ListBuffer，需要导包

定义一个可变列表

scala> val l2 = ListBuffer(1,2,3) l2: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

可变集合的元素增加

scala> l2.append(4,5) scala> l2 res90: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 5) scala> l2 += 6 res91: l2.type = ListBuffer(1, 2, 3, 4, 5, 6)

可变集合的元素删除

scala> l2 -= (1) res93: l2.type = ListBuffer(2, 3, 4, 5, 6) **remove方法是删除索引所在的元素** scala> l2.remove(0) res105: Int = 2 scala> l2 res106: scala.collection.mutable.ListBuffer[Int] = ListBuffer(3, 4, 5, 6)

列表头部添加元素

scala> 7 +: l2 res116: scala.collection.mutable.ListBuffer[Int] = ListBuffer(7, 3, 4, 5, 6, 7)

set集合，没有重复元素，无序

定义不可变set

scala> val s = Set(1,2,2,3,3,3,4,4,7,5) s: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 7, 3, 4)

set之间的运算

& ：两个集合之间的交集 ++：两个集合之间的并集 --：前这集合减去后者集合中有的元素，剩余的元素

set的改变

scala> s += 7 // s.add(7) res125: s.type = Set(2, 3, 7, 4) scala> s -= 7 //s.remove(7) res127: s.type = Set(2, 3, 4)

集合的遍历

scala> for(i <- s) println(i) 2 3 7 4

flatMap方法

scala> val l = List("hello world","scala test","java spark 1") l: List[String] = List(hello world, scala test, java spark 1) scala> l.flatMap(x => x.split(" ")) res5: List[String] = List(hello, world, scala, test, java, spark, 1) scala> l.flatMap(_.split(" ")) res6: List[String] = List(hello, world, scala, test, java, spark, 1)