scala基础语法

一.声明变量

object VaDemo {
  def main(args: Array[String]): Unit = {
    val a = 1
    println(a)
    val b = "hello"
    println(b)
    val str:String = "world"
    println(str)
  }
}

二.常用类型

Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型

三.条件表达式

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

    //支持混合类型表达式
    val z = if(x > 1) 2 else "你是不是神经病"
    println(z)

    //如果缺失else及后面的值,  相当于 if(x>2) 1 else () 什么都没得打印个括号
    val a = if(x>2) 2
    println(a)

    //在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)
  }
}

四.块表达式

object BlockExpression {
  def main(args: Array[String]): Unit = {
    val x = 0
    //在scala中{}中可包含一系列表达式,块中最后一个表达式的值就是块的值
    val result = {
      if(x < 0){
        -1
      } else if (x >= 1){
        1
      } else {
        "xixi"
      }
    }
    println(result)
  }
}

五.for循环

package com.doit.scala.day01

object ForCycleDemo {
  def main(args: Array[String]): Unit = {
    //为 i 返回一个1 到 10 的 Range空间 Range代表的是一段整数的范围
    for (i <- 1 to 10)
      println(i)

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

    //多重for循环
    for(i <- 1 to 3; j <- 1 to 3 if i != j)
      println(10*i+j)

    //for 循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将
    // 返回该集合。Scala 中 for 循环是有返回值的。如果被循环的是 Map，返
    // 回的就是 Map，被循环的是 List，返回的就是 List，以此类推。

    val v = for (i <- 1 to 10 )yield i * 10
    println(v)
  }
}

六.调用方法

Scala中的+ - * / %等操作符的作用与Java一样，位操作符 & | ^ >> <<也一样。只是有

一点特别的：这些操作符实际上是方法。例如：

a + b

是如下方法调用的简写：

1. +(b)

a 方法 b可以写成 a.方法(b)

七.定义函数和方法

    定义函数的时候,只要 整个定义过程中明确出每个参数列表中的元素以及返回值的数据类型,就怎么简单怎么来,

当然返回值的数据类型编译器是可以推断出来的,所以基本也不用写

package com.doit.scala.day01

object DefinitionMethod {
  def main(args: Array[String]): Unit = {
    //定义函数的几种方法
    val f = (x: Int) => x+x
    //个人理解中  建立一个方法就是val 一个名称
    // 冒号后面加上 (冒号后面是函数的类型) 函数的类型(类似于Int=>Int  第一个Int表示参数列表,第二个Int表示返回值类型)
    //再加一个等于号  后面加上  (参数列表) => 函数体
    //当然也可以简写
    val f1: Int => Int = (x:Int) => x+x
    val f2: Int => Int = (x) => x+x
    //当参数列表只有一个参数的时候  可以省略括号
    val f3: Int => Int = x => x+x
    //=============================================
    //也可以更简单  省略之前 : 到 = 之间的数(包括 :)
    val f4 = (x: Int,y: Double) => x+y
    val f5: (Int,Double) => Double = (x: Int,y: Double) => x*y
    val f6: (Int,Double) => Double = (x,y) => x+y
    //函数的本质就是引用而理性,就是特质new的实例
    val f8 = new Function2[Int, Double, Double] {
      override def apply(v1: Int, v2: Double): Double = {
        v1 * v2
      }
    }
  }
}

定义函数

 //定义方法
    def m1 (x: Int, y: Int) :Int = x+y


    def m2 (x: Int,y: Int): Int = {
      //方法中调用函数
      f(x) + y
      //方法中调用方法
      //m1(x,y)
    }
    println(m2(3,4))
    //将函数作为参数传入方法中
    def mf1(f: Int => Int) : Int = {
      f(8)
    }
    var mfa = mf1((m: Int) => m*m)
    println(mfa) //64
    //将函数和Int类型作为参数列表传入方法中
    def mf2(x: Int,f:Int => Int): Int ={
      f(x)
    }
    var mfb = mf2(8,(x: Int) => x*x)
    println(mfb) //64

八.map reduce

object MapReduceDemo {
  def main(args: Array[String]): Unit = {
    var arr = Array(1,2,3,4,5,6,7,8,9)
    var f = (x: Int) =>x * x
    //求和
    println(arr.sum)
    //长度
    println(arr.length)
    //最大值
    println(arr.max)
    //最小值
    println(arr.min)
    //map方法  底层是遍历这个数组 每个元素都调用f
    var a1: Array[Int] = arr.map(f)
    for(i <- a1)
    println(i)
    //过滤
    var a2 = arr.filter(x => x % 2 != 0).map(x => x * x)
    for(i <- a2) println(i)
    //reduce  底层就是遍历挨边加一加  ((a+b)+c)+......
    println(arr.reduce((a,b) => a+b))
    //下划线(占位符)代替参数
    println(arr.reduce(_+_))
    }
}