Scala基本运用

scala会自定推断类型，但是存在多个数据类型时，scala会推断他们共有的数据类型，即父类Any

1.定义变量

object中的 o 一定要小写和java中的object是不一样的
object创建的类单例类

/**
  * 定义变量
  * object中的o 一定要小写和Java中的Object不一样
  * Object创建的类是单例类
  */
object ValAndVar {
  //入口方法def开头的都是方法，main是方法名，()是参数列表 ,args参数名 Array[String]
  //后面的Unit-->数据类型就是Java中的void 没有返回值
  //{方法体}

  def main(args: Array[String]): Unit = {
    //在scala中不需要显示的声明数据类型，因为Scala会根据值自动判断
    //定义变量需要使用两个关键字val和var
    //语法：val/var变量名:数据类型=值
    //ps:()中的可以省略的
    //var可变的,val不可变
    //val修饰的变量是不可变的===Java总的final，一旦赋值不能被修改
    //var修饰的变量是可以被修改的
    val name="小明";
//    name = "df";//报错
    var age = 18;
    age = 20;

    //同时声明多个变量
    val name1 ,name2="111"
    var num1,num2=100
    //在创建变量的时候，是不显示的使用数据类型，但是在scala中的存在着基本数据类型
    //Byte-Char-Short-Int-Double-Float-Boolean这些都是类
    //这些类提供了一些方法方便我们来使用，并且Scala会负责基本数据类型和引用数据类型的转换操作
    //ps:在声明变量的时候，scala建议使用val来声明变量

    /**
      * 八种基本数据类型在Scala中提供了一个加强类Rich基本数据类型
      * 例如：RichInt--Int 的加强类
      */
    /**
      * Scala中运算符合java基本上没有什么区别，只不过
      * 1.Scala中没有 ++ --
      * 2.常用的 + - * / > < >= <= == || ! 都是和Java 一样的
      * 3.scala基本数据类型将运算符写成了方法，所以可以直接通过对象.运算符(值)进行计算
      *
      */
    val sum = 1+1
    val sum1 = 1.+(1)
    println(sum1)
  }
}

2.格式化输出

/**
  * Scala的格式化输出
  */
object PrintDemo {
  def main(args: Array[String]): Unit = {
    //scala的打印
    val name ="xlj"
    val price=30;
    val url="www.baidu.com"
    //输出打印
    //1.普通版本
    //可以向Java一样进行字符串拼接
    println("name = "+name,"price = "+price,"url = "+url)//带ln就是换行，不带就是不换行
    //print中有一个带f后缀的方法，这个方法类似于C语言的打印方法，pintf
    //2.printf
    //Java中的String,有一个静态方法---format格式控制符,对应的值
    //第一个参数是：格式控制符
    //第二是对应的值
    printf("名字：%s 值: %d 网址: %s",name,price,url)//但是不能换行
    println()
    println(f"$name $price $url")//这种方法也可以直接获取

    //可以使用s来处理字符串中直接使用变量
    println(s"name=$name")
    //使用s处理字符串时，是可以使用${}来完成一个表达式并进行计算
    println(s"1+1 = ${1+1}")
    println(s"1+1"+(1+1))
    //获取控制台上的数据
    val scan = readLine()
    println(scan)
  }
}

3.条件表达式

/**
  * 条件表达式
  * 1.if表达式的定义和Java中的是基本相同的，也是一个Boolean的表达式
  * if或else最后一行语句可以是返回值
  * 例如 val  age = 30
  * if (age > 18) 1 else 0
  * val age =30
  * 这样做就相当于Java中的一个运算符三目 ？:
  * val newAge = if(age > 18) 1 else 0
  * 上面的另外 一种写法，两句话放在一行，用分号隔开
  * var i = 1; if(age > 18) i  = 1 else i = 0
  * 也可以使用基本的形式来完成
  * if(age > 18) println("1") else println("0")
  *
  * 2.if表达式可以推断类型
  * 若if表达式有值或是if else表达式有值，会自动推断类型
  * val age = 30
  * val newAge=if(age > 18) 1 else 0 -->得到结果的时候相当于 val newAge:Int  = ?
  * val newAge=if(age>18) "String" else 0 -->得到结果的时候
  * scala会推断他们共有的数据类型，即父类Any
  *
  * 若是使用一个单独的if后面没有else
  * 例如 val age = 30
  * val newAge = if(age > 18) "String" 此时scala会认为else是默认存在并且数据类型时Unit
  * val newAge=if(age > 18) "String" else () --> ()代表空，什么也没有
  * 关系运算符和逻辑运算符的引用和Java是一样的，可以直接使用或值在if使用
  * 1.默认scala是不需要使用语句结束符的，不需要使用分号来分割
  * 2.一行多条语句，这必须使用分隔符分开，也就是 分号
  * 例如 var a,b,c=0;if(a < 10){b = b+1;c=c+1}
  * 通常可以这样写
  * var a,b,c=0
  * if(a< 10){
  * b = b + 1
  * c = c+1
  * }
  * if中若是有多行语句建议使用{}
  * 3.{}就是在块表达式，在当前代码中有多条语句，最后一条语句值是整个块表达的返回值
  * var a = 2
  * var b = 1
  * var c = 1
  * var d = if(a < 10){
  * b = b + 1
  * c = c + 1
  * b + c
  * }
  *
  * println(d)
  * 4.scala 中 没有switch ---case ,但是提供了一个更强大的应用匹配模式
  */
object IfDemo {
  def main(args: Array[String]): Unit = {
    val age = 30
    //这样做就相当于Java中的一个运算符 三目 ?:
    val newAge =  if (age > 18)  1 else 0
    //上面的另外一种写法,两句话放在一行，用分号隔开
    var i = -1 ; if(age > 18)  i =1 else i = 0
    //也可以使用基本的形式来完成
    if (age > 18) println("1") else println("0")

    //if的分支应用
    val faceValue=99
    val rs = if (faceValue > 90) "帅得不要不要的" else "瘪犊子玩意"
    println(rs)

    val x = 8
    val rs1 = if (x>8) x
    println(rs1)
    val rs2 = if (x > 8) x else "前面是一个整数,这里是一个字符串rs2的数据类型是什么"
    println(rs2)
    //if else if 的语句较多那么会使用{} 来完成
    val score = 76
    val rs3 = {if (score > 60 && score < 70) "及格"
    else if (score >= 70 && score  < 80) "良好"
    else "优秀" }
    println(rs3)

    var rs4  =""
    if (score > 60 && score < 70) {
      rs4  = "及格"
    } else if (score >= 70 && score  < 80){
      rs4  ="良好"
    }
    else {
      rs4  = "优秀"
    }
    println(rs4)
  }

}

4.循环

/**
  * 1.Scala中有while和do while 基本语法和Java是相同，也即是说java怎么写 scala也就怎么写，需要注意的是这没有++ --
  * 所以自增或自减需要使用+= 或  -= 完成
  * 2.scala 中没有标准的for循环
  * 标准for循环 -- > for (循环变量赋初值;循环条件;循环变量的自增或自减){循环体}
  * 若是需要使用这种类似的for只能用while代替
  * Scala中有类似于java中的增强for循环但是语法完全不一样
  * 3.scala没有跳出循环语句
  * 虽然scala中没有提供类似于Java中的break语句，但是可以使用如下三种方式完成循环停止

object LoopDemo {
  def main(args: Array[String]): Unit = {
    var i= 1
    while (i < 100){
      println(i)
      i += 1
    }
    //定义数组元素 1 -6
    //数组是有可变和不可变之分
    val array1 = Array(1,2,3,4,5,6)
    val array2 = Array(1,2,3,4,5,6)
    //遍历数组并打印
    //类似于java的增强for循环
    //java中的增强for循环

    /**
      * for (数据类型  变量:  集合名(数组名)){
      * 变量就会获得数组中的每一个元素
      * }
      */
    //scala中的for循环 <-指向
    for  (ele<-array1){
      println(ele)
    }

    //通过下标获取当前数组中的元素
    //to 方法 until方法
    val r1 = 1 to 5
    println(r1)
    println("-------------------------------------")
    val r2 = 1 until 5
    println(r2)
    println("-------------------------------------")
    for (i <- 0 until  6){//不包含头尾  或 arrar.length
      println(array1(i)) //取出数组的元素
    }
    println("-------------------------------------")
    for (i <- 0 to  5){//包含头尾
      println(array1(i)) //取出数组的元素
    }

    //for循环中可以添加添加守卫-->添加条件
    //if即守卫
    for (e <- array1 if e % 2 ==0){//在循环中可添加条件,即守卫
      println(e)
    }
    //for循环的嵌套
    for (i <- 1 to 3){
      for (j <- 1  to 3){
        if (i != j){
          print(10 *  i + j+"  ")
        }
      }
      println()
    }

    //g高级for循环(for循环嵌套)
    //if i!=  j 是 j<- 1 to 3的守卫
    for(i <- 1 to 3;j<- 1 to 3 if i!=  j){
      print((10 *  i + j)+"  ")
    }

    //yield  礼让(多线程) --for循环的推导式，该循环会构建一个新的大集合或数组，每次迭代会生成集合的一个新值
   println()
    var res = for (i <- 1 to 10) yield i
    println(res)

    //foreach   filter  map 函数使用和含义  明天早上听写
    val arr = Array(1,2,3,4,5,6)
    //filter一个过滤器，根据传入的条件将数据过滤出来
    val arr1: Array[Int] =arr.filter(x => x % 2 ==0)
    println(arr1.toBuffer)//不可变数组叫Array 可变数组是ArrayBuffer
    //map 把数组中 每一个元素都取出来得到一个全新的全新数组
    val arr2: Array[Int] =arr.map(x =>x)
    println(arr2.toBuffer)
    //foreach数组中的元素取出来并打印(无返回值)
    arr.foreach(x => println(x))
  }

}

5.九九乘法表

object HomeWork {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9){
      for (j <- 1 to 9){
        if (j <=i) {
          print(j +"*"+ i+"="+ (+j * i) + " ")
        }
      }
      println()
    }
  }
}

1.Scala 中没有提供 break 和 continue 语句来退出循环, 如果需要 break, 可以这样做:
使用 Boolean 型的控制变量
使用 scala.util.control.Breaks 对象的 break 方法
函数中可以把 return 当做 break 使用