Scala学习

Scala中没有基本类和包装类之分，所有基本类型类似于java的包装类

操作符
基运算符±*/%
关系运算符<> <= >= != ==
逻辑运算符&& || !
位运算符：^ | & >> << ~ >>>(无符号右移)
赋值运算符 = +=

和Java不同的地方
1.所有的运算符都是方法，底层都是定义的方法。a+b等于a.+(b)
2.在Scala中没有++和–运算符 如果需要 使用+=和-=来代替。
运算符的优先级：
使用()限制运算的先后顺序。

表达式
if else条件表达式
块表达式
所有的表达式都有返回值
所有语句的最后一条语句返回。

object IfDemo {

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

    val i = 0
    // if else 表达式有返回值，返回值是最后一条语句的结果，如果最后一条语句
    // 是打印语句或者是赋值语句，返回结果返回值是unit类型()
    // unit类型类比Java中void类型

    var res = if (i > 0) println("正数")
    else println("非正数")
    println(res)
    var res1 = if (i>0) 10
    else -10
    println(res1)

    var b = 0
    var res2 = if (i > 0) b = 10
    else b = 100
    println(res2)
    // 混合的条件表达式   if else语句的返回类型不一样

    var res3 = if (i > 0) b = 10
    else 100
    // 此时返回类型为any类型
    println(res3)

    var  res4 = if (i>0) 10
    // 返回的类型是unit   没有else语句   就等价于 else() ---->uint
    println(res4)


    // if else if  else  嵌套

    var res5 = if (i>0) println("正数")
    else if (i < 0) println("负数")
    else println("等于0")
    println(res5)

    // 注意： scala中没有switch，scala中有更强大的模式匹配！！！
  }
}

Scala中的循环

for循环

object ForDemo {

  // java for(i=0;i<100;i++)
  // scala: fro(i <- 表达式（可能是个数组或者集合）)
  // to until by--->(步长)

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

    // to 和 until 的区别  to 是闭区间   until是右开区间
    // 默认步长是1，通过by来改变步长

    for (i <- 1 to 10) {
      println(i)
    }

    for (i <- 1 to 10 by 2) {
      println(i)
    }


    for (j <- 1 until 10) {
      println(j)
    }

    for (j <- 1 until 10 by 2) {
      println(j)
    }


    val arr = Array(10,20,30)
    // 遍历一个数组
    for (tmp <- arr)
      println(tmp)


    // 转换，把字符转化成一个字符数组
    val str = "abcdef"

    for (strtmp <- str) {
      println(strtmp)
    }

    for(k <- 0 until str.length) {
      println(str(k))
    }

    // 高级循环  1 到 100
    // if条件在for叫守卫条件
    for (m <- 0 to 9; n <- 0 to 9; if (m!=n)) {
      println(10*m + n)
    }

    println("----------------------------------------------------")
    // for 推导   给我一个集合我可以生成一个新的集合
    val res = for (p <- 1 to 10) yield p * 10
    println(res)

    var arr1 = Array(1, 2, 3, 4, 5)
    val arr2 = arr1.map(_ * 10)
    val arr3 = for (q <- arr1) yield q * 10
    println(arr3)

    // scala 中使用continue break


  }
}

while和do…while循环

object WhileDemo {

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

    while (i > 0) {
      println(i)
      i -= 1
    }

//
//    do {
//      println(i)
//      i -= 1
//    } while (i > 0)
  }

}

Scala中的break 和continue

import  util.control.Breaks._
object BreakDemo {


  def main(args: Array[String]): Unit = {
    breakable(for (i <- 0 to 10) {

      if (i == 5) {
        break
      }
      println(i)
    }
    )



    // 如果包住的是for循环里面的语句  实现的功能就是continue
    println("-------------------------------")
    for (i <- 0 to 10) {

      breakable {
        if (i == 5) {
          break
        }
        println(i)
      }
    }
  }
}

块表达式
（一系列的语句）
返回值，是最后一条语句的结果（如果是打印语言或者赋值语句，块表达式的返回值是unit类型的()）

object BlockExpressionDemo {

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

    // 块表达式
    var x = 0
    val res = {

      if (x > 0) 1
      else if (x == 0) 0
      else -1
    }
    println(res)

    val x0, y0 = 1
    val x1, y1 = 2
    val distance = {
      val dx = x1 - x0
      val dy = y1 - y0
      println(Math.sqrt(dx * dx + dy * dy))
    }
    println(distance)
  }
}

方法和函数

def 方法名(参数): 返回值类型（可以省略，他会自动根据方法体最后一行的返回值类型来进行推断）= 方法体

object methodDemo {

  // 最基本的定义方法的方式
  def add(x:Int,y:Int) : Int = x + y

  def add3(x:Int)(y:Int) = x+y

  // 系统自动推断
  def add1(x:Int,y:Int) = x + y

  def add2(x:Int,y:Int){x + y}

  // 定义带有参数列表的方法
  def addAndMultiply(x:Int,y:Int)(multiplier:Int) :Int = (x+y)*multiplier

  // 定义无参的方法
  def name:String = System.getProperty("user.name")
  def name1():String = System.getProperty("user.name")

  // 定义带有默认值参数的方法     java通过方法的重载来实现
  def method(a:Int =1,b:Int,c:Int=10) = println("a=" + a + "b=" + b + "c=" + c)

  // 可变参数方法
  def add4(a:Int*)={

    var sum = 0
    for (i<-a){
      sum+=i
      println(i)
    }
    // 最终返回值
    sum
  }

  // 强行加个return 自动推断失效  需要加返回值类型Int
  def add5(a:Int*):Int={

    var sum = 0
    for (i<-a){
      sum+=i
      println(i)
    }
    // 最终返回值
    return sum
  }

  def main(args: Array[String]): Unit = {
    val res = add(1,1)
    println(res)

    val res1 = add1(2,3)
    println(res1)

    val res2 = add2(3,4)
    println(res2)

    val res3 = addAndMultiply(1,1)(10)
    println(res3)

    val res4 = name

    println(res4)

//    val res5 = name()   失败
//    println(res5)

//    name      不支持滴。。。

    println("----------两种方式--------------")
    val res6 = name1()
    println(res6)

    val res7 = name1
    println(res7)

    name1()

    method(b = 3, c = 4)
    // 把10赋值给a，把20赋值给b，c是默认值
    method(10,20)

    val res8 = add4(1,2,3,4)
    println(res8)
  }
}

方法和函数

def方法名（参数）：返回值类型=方法体
函数
定义方式：

object FunctionDemo {

  // 定义一个函数
  // 必须掌握f1   f4 Spark项目中也会用     前面的val fn去掉  就变成了一个匿名函数
  val f1 = (a:Int,b:Int) => a+b
  //     函数的参数    =>固定函数写法    函数体

  val f2 = ((a:Int,b:Int) => a+b)

  val f3 = (_:Int)+(_:Int)  // _代表函数的一个参数  Scala中_有十种以上的用法

  val f4:(Int,Int)=>Int = (_+_)

  val f5:((Int,Int)=>Int) = {(x,y) => x+y}

  val f6 = new Function2[Int,Int,Int] {

    override def apply(x: Int, y: Int): Int = x+y
  }

  // 定义一个匿名函数
  (x:Int) => x+1

  // 定义无参函数
  val getResult = () => 100

  // 定义一个方法，参数是一个函数    参数是一个函数 相当于一个高阶函数？
  def  m(f:(Int,Int)=>Int) = f(5,5)

  def add(x:Int,y:Int):Int = x+y

  // 前面代表参数类型   最后那个代表返回值类型

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

    val  res1 = f1(1, 2)
    println(res1)

    f3(2,3)

    // 无参函数调用
    getResult()

    // 方法参数是个函数的调用
    val  res = m(f1)
    println(res)

    // 系统会自动把方法转化成函数
    val res2 = m(add)

    // 空格+_
    val res3 = m(add _)
  }
  // 方法和函数的区别是什么？？？
  // 没有函数转化成方法

}

方法和函数的区别：
1.定义的语法不一样
2.方法一般定义在类，对象，特质（类似Java中的接口）
3.方法可以共享类和对象的数据

方法可以转化成函数
1.把方法作为参数传入其他的方法或者函数，系统就会自动把方法转化成函数。
2.使用 方法名 空格+_ 也可以将方法转换为函数

Scala中没有静态方法这个概念，需要通过伴生类对象来实现