Scala基础知识（二）

1.条件表达式

object ConditionDemo {
  def main(args: Array[String]) {
    val x = 1
    //判断x的值，将结果赋给y
    val y = if (x > 0) 1 else -1
    //打印y的值
    println(y)

    //支持混合类型表达式
    val z = if (x > 1) 1 else "error"
    //打印z的值
    println(z)

    //如果缺失else，相当于if (x > 2) 1 else ()
    val m = if (x > 2) 1
    println(m)

    //在scala中每个表达式都有值，scala中有个Unit类，写做(),相当于Java中的void
    val n = if (x > 2) 1 else ()
    println(n)

    //if和else if
    val k = if (x < 0) 0
    else if (x >= 1) 1 else -1
    println(k)
  }
}

2.块表达式

val result = {
      if (x < 0){
        -1
      } else if(x >= 1) {
        1
      } else {
        "error"
      }
    }

块表达式中一般最后一个参数就是表达式的返回值。

3.循环语句

for循环 1 to 10 ,to是一个方法，是将1到10数据产生

for的格式1： for（i <- res1）object ForDemo {

  def main(args: Array[String]) {
    //for(i <- 表达式),表达式1 到 10返回一个Range
    //每次循环将区间中的一个值赋给i
    for (i <- 1 to 10)
      println(i)

    //for(i <- 数组)
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)

    //高级for循环
    //每个生成器都可以带一个条件，if前面没有分号
    for(i <- 1 to 3; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")
    println()

    //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值，将i的值进行操作，将数据装入vector中。如果对数组进行操作，最后结果返回一个数组。
    val v = for (i <- 1 to 10) yield i * 10
    println(v)

  }
}

练习：将一个1到9的数据中的偶数取出来。

//使用val更加的节省资源
val a1=Array(1,2,3,4,5,6,7,8,9)
val a1=for(i<- a1;if(i%2==0)) yield i

练习：filter过滤

a1.filter(_%2==0)

_表示每次输出的值

for循环通过角标开始

for（i <- 1 to a1.length）
println(a1(i-1))

for（i <- 1 until a1.length）
println(a1(i))

to是[]的操作,until是（]的操作

1 to 10  等同于 1.to（10）

5.在scala中是不存在操作符运算的，运算的底层都是使用方法来完成的。

scala>1-3
res1:Int = -2

scala>1.-(3)
res2:Double = -2.0

对于为什么返回的是一个double，这是因为它将第一个1当做是double运算的，所以后来大印的就是double。

测试方法：将3定义成一个val a的值，1.-（a）结果仍为double，将1定义为一个val b的值，a.-(b)结果是int。

在源码中，方法的返回的类型和输入的参数是和传入参数有关的。

6.方法和函数

方法定义 def 方法名（参数列表）:返回值类型 = 操作

方法定义：
def m1(a:Int,b:Int):Int = x*y
方法调用
m1（3,5）

不写返回值的类型
def m1(a:Int,b:Int) = x*y

注意：但是递归是必须要有返回值类型的。

7.函数定义

定义一个函数，无名函数
（x:Int,y:Int）=>{x+y}  


有名函数
val f1=(x:Int，y:Int)=>{x+y}


调用
f1（参数）
 

8.函数有一个特性就是可以作为参数传入到方法里面。

定义一个函数
val f3=(x:int)=>x*10
准备一个数组，将数组的值进行函数f3的操作
val a1=Array(1,2,3,4,5,6,7,8,9)
a1.map(f3)

这也就是说函数式编程可以将数据的进行任意操作，这也是他的灵活性。

9.方法是通过方法名进行调用，函数是可以作为参数进行传递的。

10.a1.map(_*100) 将a1中数据乘以10.这个是不定义函数，也可以定义匿名函数

匿名函数


a1.map((x:Int)=>x*100)

但是在a1中的参数都是知道的，这个时候就不需要指定数据的类型
a1.map(x=>x*10)

当然了最简单的方式是
a1.map(_*100)

11.下划线的作用

  将方法转化为函数，如果一个函数的逻辑和方法的逻辑相同，那么就可以使用下面的方法将方法转换为函数。

def testZhanshu(x:Int,y:Int):Int = {
   X+y;
}

将上面的方法转换为函数
Val fun2 = testZhanshu_

 总结：

       函数和方法的最大区别在于，函数可以作为参数进行传递。

　　定义函数的方式

Val fun=（x:Int，y：Int）=>操作
Val fun1 = （x:Int，y：Int）=>返回值[可以为任意的，可以是一个元祖

返回值类型是可以设置的，也可以不需要设置的，因为元函数的返回值是可以自己推断出来的。] ={操作}
Val fun2:(Int,Double)=>(Double,Int)={(x,y[因为只是将前面数据的定义了，但是并没有定义变量，所以这里的需要将变量定义出来。])=>具体的业务逻辑}
递归必须有返回值类型的
加入说没有返回值的时候，这个时候返回值是Unit，调用之后，返回值是一个()