scala 入门1

　1 变量定义：　

　　println("hello world")

　　val/var 变量标识:变量类型 = 初始值

　　val 定义的是不可重新赋值变量

　　var 定义的是可重新赋值变量

 

 2    根据变量推断类型：

　　val name =123

       

3  惰性赋值：（不需要立刻加载到JVM里面，用的时候再加载和 hibernate 懒加载原理有相似之处）

　　lazy val/var 变量名 = 表达式

 

 4  字符串定义：

　　使用双引号            val/var 变量名 = "字符串"
　　使用插值表达式     val/var 变量名 = s"${变量/表达式}字符串"   （struts2 也有插值表达式）
　　使用三引号             val/var 变量名 = """字符串1字符串2"""

 

5  

比较两个对象的引用值，使用 eq 

比较两个对象的值            equals  ==

 

6           scala 类型结构        

                        any

anyval                              anyref

int short  double               string arr  object

boolean   unit()                 null

                          nothing

 

 7    条件表达式

 if 有返回值    val result = if("1"== "1") 1 else 0

 

8  块表达式

{}表示一个块表达式 ,块表达式是有值的 ,值是最后一个表达式值

 

9  for

for(i <- 表达式/数组/集合) {
}

var i =1
while(i<=10){
println(i)
i=i+1
}

 

list set 可变和非可变（长度和原始值都不能变化）

可变map  和 非可变map (  key value 不能有变化  )

val a = ListBuffer[Int]()

val a = ListBuffer(1,2,3,4)

a.toList       转换为不可变列表

a.toArray    转换为数组

a.length   

a.isEmpty

val c = a ++ b

 a.head   获取列表的首个元素

 a.tail       获取除第一个元素以外的元素，它也是一个列表

 a.reverse  

 a.take(3)   take方法获取前n个元素

 a.drop(3)   使用drop方法获取除了前3个元素以外的元素

 a.flatten     方法来进行扁平化

 

10   拉链与拉开

a.zip(b)

res16.unzip

println(a.toString)

a.mkString(",")

a.mkString("[",":","]")

a1.union(a2) 

a1.union(a2).distinct

a1.intersect(a2)

a1.diff(a2)

11   Set 

一种是不可变集 : 

　　for(i <- a) println(i)

　　a - 1

　　a ++ Set(6,7,8)

　　a ++ List(6,7,8,9)

另一种是可变集 :

　　a += 5

　　a -= 1

 

12  

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

不可变Map
可变Map

val/var map = Map(键->值, 键->值, 键->值...) 　　　　　　　　// 推荐，可读性更好
val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)　　　　

map("zhangsan")

map("zhangsan") = 20

map.keys

map.values

for((x,y) <-map ) println(s"$x $y")

 map.getOrElse("www",-1)

 map + ("wangwu"->35)

 map - "lisi"

 

13  函数式编程

遍历（ foreach ）

　　a.foreach((x:Int)=>println(x))

　　a.foreach(x=>println(x))

　　a.foreach(println(_))

14 映射（ map ）

　　a.map(x=>x+1)

 　　a.map(_+1)

15 映射扁平化（ flatmap ）

　　把flatmap，理解为先map，然后再flatten

　　a.map(x=>x.split(" "))

       a.map(x=>x.split(" ")).flatten

　　a.flatMap(_.split(" "))

 

16 过滤（ filter ）

　　List(1,2,3,4,5,6,7,8,9).filter(_%2==0)

是否存在（ exists ）

　　
17 排序（ sorted 、 sortBy 、 sortWith ）

　　List(3,1,2,9,7).sorted

       a.sortWith((x,y) => if(x<y)true else false)

　　res15.reverse

　　a.sortWith(_ < _).reverse

18 分组（ groupBy ）

　　 a.groupBy(_._1)

　　res83.map(x=> x._1->x._2.size)

 

19 聚合计算（ reduce ）

　　a.reduce( (x,y)=> x+y )

　　a.reduce( _ + _)

　　a.reduceLeft(_ + _)

　　a.reduceRight(_ + _)

20 折叠（ fold ）

　　a.fold(0)(_+_)