Scala——变量的定义，循环结构，选择结构，函数定义与使用，高阶函数

Scala中变量的的定义

以下变量的定义都在交互式命令行中，所有代码均可以在开发工具中使用

var与val

自动识别变量类型

变量的lazy声明

声明为lazy变量后，只有该变量在使用时才会被调用

定义变量使用大括号时，最后一行表示返回值

scala中一切皆对象

选择结构

object HelloScala {
  def main(args: Array[String]): Unit = {
    val isSuccess = true
    if(isSuccess == true){
      println("是正确")
    }else{
      println("不对")
    }
  }
}

只有一行命令时大括号可以省略

if(flag) “aa” else “bb”

for循环结构

import scala.collection.immutable

object ForDemo {
  def main(args: Array[String]): Unit = {
    //循环表达式
    val arr = 1 to 10 //相当于一个数组

    //scala中使用for循环变量元素
    for (item <- arr){
      print(s"它的值：$item")
    }
    println()
    println("-----------------------------")
    //for循环 if条件守卫判断
    for (item <- arr if item%2 ==0){
      print(s"它的值：$item")
    }
    println
    println("-----------------------------")
    for (item <- arr if item%2 ==0)print(s"它的值：$item")

    println
    println("-----------------------------")

    //打印9*9乘法表
    for(i <- 1 to 9){
      for(j <- 1 to 9){
        if(j==1) println()
        print(s"${i*j}  ")
      }
    }
    println
    println("-----------------------------")
    for{
      i <- 1 to 9 //外循环
      j <- 1 to 9 //内循环
    }{
      if(j==1) println()
      print(s"${i*j}  ")
    }

    val names = Array(" www.baidu.com ","www.google.com"," hadoop.apche.org"," ")

    for{
      name <- names
      tmpName = name.trim
      if tmpName.length >0
    }{
      println(tmpName)
    }

    //基于一个现有的数组，产生一个新的数组，在循环变量的时候
    //需求：将原有的数组 变量 平方
   val result: IndexedSeq[Int] =  for (item <- arr) yield{
      item * item
    }
    println(result)
  }
}

while循环结构

object whileDemo {
  def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array(11,222,33,44,55,66)
    //遍历数组，定义数组索引下标
    var index = 0;
    while(index < arr.length){
      println(s"index=$index,value=${arr(index)}")
      //索引+1
      index += 1;
    }
  }
}

Break与Continue关键字

break

import scala.util.control.Breaks

object BreakDemo {
  def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array(11,222,33,44,55,66)
    //1.创建Breaks实例对象
    val loop = new Breaks()
    //2.对要遍历的循环进行控制
    loop.breakable{
      for (item <-arr){
        println(s"value of is $item")
        //当item==33的时候，停止遍历，跳出循环
        if(item ==33){
          loop.break()//3.跳出循环
        }
      }
    }
  }
}

continue

import util.control.Breaks._

object BreakOrContinue {
  def main(args: Array[String]): Unit = {
    val arr = Array(1,2,3,4,5,6,7,8)
    for(i<-0 until 10){
      breakable{
        if(i==3||i==6) {
          break
        }
        println(i)
      }
    }
  }
}

函数的定义与使用

object FunDemo {
  //定义函数：比较2个数的较大值
  def max(x:Int,y:Int):Int = {
    if(x >y){
      x
    }else{
      y
    }
  }

  //如果一个函数的函数体只有一行代码，可以省略{}
  def max1(x:Int,y:Int):Int = if(x >y) x else y

  //如果一个函数的返回值类型，可以通过 函数体 推断得到，可以省略 返回值类型
  def max2(x:Int,y:Int) = if(x >y) x else y

  //可以将一个函数 赋值给一个变量(注意语法)
  val max3 = max2 _
  
  //如果一个函数么有返回（使用Unit表示），可以省略 返回值类型 和=
  def printArray(arr:Array[Int]):Unit={
    for(item <- arr) println(item)
  }
  def printArray1(arr:Array[Int])= for(item <- arr) println(item)

  def printArray2(arr:Array[Int]){
    for(item <- arr) println(item)
  }

  //定义函数的时候，可以给函数参数赋值，称为参数的默认值
  //注意点：有默认的参数，参数必须放在最后面
  def sayHello(name:String,msg:String="hi !"){
    println(msg + name)
  }

  /** 在调用函数的时候，可以指定参数名称 ，
    * 传递参数的顺序可以和函数声明的顺序不一致（了解）
    * sayHello1(msg = "早上好",name="老李")
    * @param name
    * @param msg
    */
  def sayHello1(name:String,msg:String){
    println(msg + name)
  }

  /**
    * 局部函数：函数内定义函数，被外部函数调用
    */
  def f1():Unit={
    println("f1() invoke..........")
    //定义内部函数
    def g():Unit={
      println("g() invoke.......")
    }
    //调用内部函数
    g()
  }
  //参数可变的函数
  def printCourse(courses:String*)={
    courses.foreach(item =>println(item))
  }

  def main(args: Array[String]): Unit = {
    val maxValue = max3(11,12)
    println(maxValue)

    val number = Array(1,2,3,4,5,6,7,8)
    printArray2(number)

    sayHello("lalal","nihao")
    sayHello1(msg = "早上好",name="老李")

    f1
    f1()
    printCourse("90","80","11")
    val courseXXX = Array("11","22","33")
    printCourse(courseXXX:_*) //:_*将数组里面的元素 铺开

    val nums: Array[Int] = Array(1,2,3,4,5,6,7,8)
    //foreach方法：
    //     参数名称：f
    //     参数类型：A => U
    //def foreach(f: A => U): Unit
    nums.foreach( (item) =>{
      println(item)
    })
    //def println(x: Any) = Console.println(x)
    nums.foreach(println)
    //def map[B, That](f: A => B)
    val  result = nums.map( (item)=>{
      item * item
    }  )
    result.foreach(println)
  }
}

高阶函数的简单定义与使用

object HighFunction {

  //定义了一个高级函数
  def greeing(name:String,sayHello:(String)=>Unit): Unit ={
    sayHello(name); //调用传递过来的函数
  }

  def main(args: Array[String]): Unit = {

    greeing("lalal", (name: String) => {
      println(name + "你好")
    })

    greeing("lalal", (name: String) => {
      println(name + "早上好")
    })
  }
}