Scala浅谈

1：关于scala环境的搭建

在本地环境下调试，可以安装scala的window版，开发工具idea安装scala的插件，注意插件版本兼容性问题，插件下载地址：

https://plugins.jetbrains.com/plugin/1347-scala

2：scala的变量类型

scala的变量类型和java类似，有Byte  Char  Int  Short    Long    Float     Double    Boolean  8中类型，区别在于它没有包装类类型。

scala的val和var的区别：

val修饰的变量值不可更改，如果变量名重名会被覆盖掉；var修饰的变量值可能更改，scala推荐使用val。

scala编译器可以自动识别变量类型，可以不用指定变量类型  例如  val  a = “123”  也可以指定变量类型  例如：

val   a : String  = "123"

3：scala的循环遍历

定义字符串：val str = "12345678910"

定义数组：val  arr = Array("a","b","c","d","e")

scala的方法：  1 to 3 输出1,2,3的集合，本质是 1.to(3)  这是scala内置的方法

//for循环

for(i <- str)println(i)

结果：1     2     3     4    5   6   7   8   9   10

for(i <- arr)println(i)

结果：a    b   c   d    e 

for(i <- 0 until  arr.length)println(arr(i))

结果：a b c d e

或者 

for(i <- 0 to arr.length-1)println(arr(i))

结果：a  b  c  d  e

for(i <- 1 to 5 ;j <- 2 to10 ; if i==j)println(i*j)

结果：4    9     16     25 

//yield

for(i <- 1 to 5)yield(i*100)

结果：返回一个集合  (100,200,300,400,500)

//map

(1 to 5).map(_*100)

结果：返回一个集合(100,200,300,400,500)

4：if判断

val x = 10

val y = if(x>10)100 else 200

或者

val  y = if(x>10) {

100
} else {

200

}

val y = if(x>5){

5
}else if(x>6){

6

}else{

` 7
}

if判断可以返回混合类型，例如：

val y = if(x>10000) 200 else "error"

结果：error

val y = if(x>2000)3

结果：()  

说明，()是unit的实例，相当于void

5：运算符

scala中的加减乘除和java中语法一样，区别就在于scala中的加减乘除都是方法，例如a+b  实际是a.+(b)方法

a-b 实际就是a.-(b)

6:scala的方法

写法一：def m(x:Int,y:Int):Float = x+y

或者

def m(x:Int,y:Int):Float = {x+y}

解释：scala中的方法使用def定义，m是方法名称，x,y为参数，Int为参数类型，Float为返回值类型

或者简写成

写法二：def m(x:Int,y:Int){

x+y

}

写法三：def m(x:Int,y:Int)={

x+y

}

方法调用  val z = m(10,30)

写法一的返回值为  40

写法二的返回值为Unit的实例：z:Unit = ()

写法三的返回值为40

Main方法

def main(args:Array[String]){

println("I am a girl")

}

调用：main(Array("a","b"))

结果：I am a girl

7：scala的函数

一般

val f = (x:Int) => x*100

f函数的引用，相当于函数名；x参数，Int参数类型，x*100函数体

匿名函数

(x:Int) => x*x

8：scala的方法和函数的区别？

在scala中的方法和函数是两个不同的概念，方法是由def定义的，函数的标识是=>

注意：函数可以作为方法的参数，例如：

val array = Array(1,2,3,4,5)

array.map(f)

结果返回（100,200,300,400,500）的集合

或者array.map((x:Int) => x*x),简写成array.map(x => x*x)

或者array.map(_*100)，"_"表示将数组中的元素赋值给_

array.filter(_%2==0)

结果返回 (2,4)的集合

"_"表示数组或者元素中的每个元素

9：scala的原始函数

val f : Int => Double = {x => x*100}

调用 f(2)

结果：200.0

val m : (Int,Double) => (Double,Int) = {(x,y) => (y,x)}

调用：m(10,88.0)

结果：(88.0,10)

由于返回的是一个元组trupe

val n = m(10,88.0)

可以使用元组取值：

调用：n._2

结果：10

调用：n._1

结果：88.0

10：scala是函数式编程

scala的函数可以作为形参传入到方法中，例如：

def m(f : Int => Double) = {

println(f(30))

}

val yy = (x:Int) =>  x*x*1.0

调用方法：m(yy)

返回结果：900.0

scala中的方法还可以作为形参传入到方法中，例如：

def m(f:Int => Double) = {

println(f(10))

}

def o(x:Int) = {

x*80.0

}

调用：m(o)

返回值：800.0

m(o)它等价于  m(o _)或者

val w = o _

m(w)

方法作为形参传入到方法中，实际是就它是将方法先转换成函数，然后将函数传入到方法，o _ 这种表达式就是将方法o（）转换成函数，然后传入到方法中，它的本质就是：m(x => o(x)),返回结果是一样的

11：scala的数组

val lc = Array(1,2,3,4,5,6,7,8,9,10)

val lw = new Array[Int](8)表示定义了Int数组，元素个数为8

lw(0)=88,修改数组的元素值

数组的常用方法：

lc.max 求最大值结果：10

lc.min 求最小值结果：1

lc.filter(_%2==0) 过滤 结果:(2,4,6,8,10)

lc.map(_*10) 遍历 结果：(10,20,30,40,50,60,70,80,90,100)

lc.sum 求和     结果：55

lc.sorted 排序结果(1,2,3,4,5,6,7,8,9,10)

lc.sorted.reverse 反序 结果(10,9,8,7,6,5,4,3,2,1)

数组的长度是固定的，ArrayBuffer的长度是可以改变的

在window系统的scala的shell窗口中，导入包

import scala.collection.mutable._

val lz = new ArrayBuffer[Int]();

lz += 1 末尾追加(1)

lz += 2 末尾追加(1,2)

lz += (3,4,5,6)  批量末尾追加 结果：(1,2,3,4,5,6)

lz ++=Array(7,8,9,10)追加数组结果：(1,2,3,4,5,6,7,8,9,10)

lz -+ 10 末尾减去结果(1,2,3,4,5,6,7,8,9)

lz.insert(0,0,-1)表示在0的索引位置添加0，-1两个元素结果：(-1,0,1,2,3,4,5,6,7,8,9)

lz.reduce(_+_) 聚合，会将相邻的两个元素相加 结果：55相当于((1+2)+3)+4.........

12:scala的map

val lz = Map("a" -> 1,"b" -> 2,"c" -> 3,"d" -> 4)

修改值：lz("a")=10

加入元素：lz("f)=8

获取元素：lz.getOrElse("a",99)结果：1表示获取元素a的值，如果没有就为99

下面这种map的元素不能修改

val lc = scala.collection.immutable.Map("a" -> 3,"b" -> 6)

12:scala的元组

在java中元素一般放到集合中处理，在scala中一般放到元组中

val lc = (1,2,,3,"hello","boy")

lc._1 结果：1

lc._4 结果：hello注意元组的角标是从1开始的

val lx =  Map("a" -> 3,"b" -> 8)

map实际是一个特殊的元组：对偶元组，由两个元组组成的，等同于：

val lx = Map(("a",3),("b",8))

lx += ("c" -> 9) 追加 结果：Map("a" -> 3,"b" -> 8,"c" -> 9)

lx += (("c",66)) 追加 结果：Map("a" ->3,"b" -> 8,"c" -> 66)

13：scala的List，Set

在scala中的集合由三种：序列seq（实际上就是List），集Set，映射Map；

在scala中集合由可变和不可变两种，可变mutable，和不可变immutable

List

scala中默认导入不可变的包

val s = List(1,3,5,7,9)，它的值不能被修改

s :+ 88 生成新的集合

scala导入可变包，import   scala.collection.mutable.ListBuffer

val ss = ListBuffer(3,4,6,9.10)

ss += 3 在ss集合上末尾追加3

ss ++= Array(33,99,22) 在ss集合末尾追加数组

Set集合

val  se = HashSet[Int](2);

和list一样默认导入不可变的包，导入可变的包：import scala.collection.mutable.HashSet

val ee = HashSet[Int]();

ee += 3  元集合末尾追加 3

ee += (1,3,5)  原集合末尾追加 (1,3,5)

14：scala的一些练习

    //创建一个List

val lst0 = List(1,7,9,8,0,3,5,4,6,2)

    //将lst0中每个元素乘以10后生成一个新的集合

  lst0.map(_*10)

    //将lst0中的偶数取出来生成一个新的集合

lst0.filter(_%2==0)

    //将lst0排序后生成一个新的集合

lst0.sorted

    //反转顺序

lst0.sorted.reverse

    //将lst0中的元素4个一组,类型为Iterator[List[Int]]

 lst0.grouped(4)

    //将Iterator转换成List

 lst0.grouped(4).toList

    //将多个list压扁成一个List

Lst0.grouped(4).toList.flatten

    val lines = List("hello tom hello jerry", "hello jerry", "hello kitty")

    //先按空格切分，在压平

lines.map(_.split(“ “)).flatten

//模拟wordcount计数

val lines = List("hello tom hello jerry", "hello jerry", "hello kitty")

lines.map(_.split(" ")).flatten.map((_,1)).groupBy(_._1).map(t => (t._1,t._2.size)).toList.sortBy(_._1)

(未完待续)