Scala之变量与函数

Scala 官网：http://www.scala-lang.org/

一、数据类型

二、变量

/*
 * 变量的定义
 * 语法：
 * 关键字（val / var） 变量名：数据类型（首字母大写）：值
 * 特点：
 * ⑴Scala是强类型语言，必须定义类型；
 * ⑵Scala中没有基本数据类型和包装类之分，所有的数据类型都是类，类型首字母需要大写；
 * ⑶声明变量时可以不指定变量类型，Scala会帮我们进行变量类型推断；
 * ⑷当val修饰的变量被lazy修饰时，则该变量的初始化将被推迟，直到第一次使用时才会去初始化，
 * 如：lazy val a = 11.2
 */
//使用val声明一个不可变变量
val a:Int = 1  //再次赋值a=2  报错：error:reassignment to val

//使用var声明一个可变变量
var b = 2

//声明一个空值的变量
var name:String = ""   //赋值一个空串
var name1:String = _   //使用占位符'_'

三、函数

1、函数定义的语法

def  函数名称 （参数名称：参数类型） ：函数返回值类型 = { 

函数体内容

}

/*
 * Scala函数的定义
 * 语法：
 * def 函数名称（参数名称：参数类型）：函数返回值类型 = { 函数体内容 }
 * 特点：
 * ⑴Scala可以自动推断数据类型，所以函数的返回值类型一般可以省略；
 * ⑵Scala中函数的默认返回值为Unit；
 * ⑶Scala中函数为空参时，可以直接使用函数名调用，小括号可以省略；
 */
//函数的定义
def fun1(x:Int, y:Int) : Int = { x+y }
fun1(1,2)

//定义返回值缺省的函数
def fun2(x:Int, y:Int) = { x+y }
fun2(2,3)

//定义空参函数
def fun3() = { println("hello world!")}
fun3()
fun3

//函数中定义另一个函数，内函数可以调用外函数的变量
def fun4(a:Int) = {
  def fun5(b:Int) = {
    println("a+b=" + (a+b))
  }
  fun5(500)
}

fun4(20)

2、匿名函数的定义

/*
 * 匿名函数的定义
 * 语法：
 * （变量1：数据类型，...变量2：数据类型）=> { 函数体内容 }
 * 特点：
 * ⑴匿名函数可以赋值给一个函数；
 * ⑵匿名函数可以赋值给一个变量；
 */
//匿名函数赋值给一个函数
def add1 = (x:Int, y:Int) => { x+y }
add1(1,2)

//匿名函数赋值给一个变量
val add2 = (x:Int, y:Int) => { x+y }
add2(1,2)

//将一个非匿名函数赋值给一个变量
def add3(x:Int, y:Int) = { x+y }
val add4 = add3 _    //函数名+空格+占位符
add4(1,2)


/*
 * 指定参数默认值的函数定义
 */
def loadConf(conf:String="spark-default.xml") = {
  println("conf is " + conf)
}
loadConf()
loadConf("file.xml")

3、变长参数的函数定义

/*
 * 变长参数的函数定义
 * Scala在定义函数时允许指定最后一个参数可以重复（变长参数），
 * 从而允许函数调用者使用变长参数列表来调用该函数；
 * Scala中使用"*"来致命该参数为重复参数；
 *
 * 在函数内部，变长参数的类型，实际为一维数组，比如上例的String*类型实际为Array[String]。
 * 然而，如果你试图直接传入一个数组类型的参数给这个参数，编译器会报错，如
 * val arr = Array("Hadoop","Hive","Hbase","Spark")
 * printCourses(arr)
 * 为了避免这种情况，我们可以通过在变量后面添加"_*"来解决，
 * 这个符号告诉Scala编译器在传递参数时逐个传入数组的每个元素，而不是数组整体。
 * printCourses(arr: _*)
 */
def printCourses(c:String*) = {
  c.foreach(x => println(x))
}
printCourses("Hadoop","Hive","Hbase","Spark")

val arr = Array("Hadoop","Hive","Hbase","Spark")
printCourses(arr: _*)

三、结构

1、循环表达式

/*
 * Range是左闭右开区间：[)
 * until是左闭右开区间：[)
 * to是左闭右闭区间：[]
 */
1 to 5
1.to(5)
1 to(5)

1 until 5
1.until(5)
1 until(5)

Range(1,5)
Range(1,5,2)   //可以指定步长
//Range(1,5,0) 步长不能为0，报错
Range(1,-5,-2)
Range(5,1,-1)

2、for循环

/*
 * for循环；
 * "<-"是一个提取符，可以从集合中遍历提取出所有元素；
 */
for (i <- 1 to 5) {
  println(i)
}

for (i <- 1.to(5)) {
  println(i)
}

for (i <- 1 until 5) {
  println(i)
}

//求1-10的偶数
for (i <- 1 to 10 if i % 2 == 0) {
  println(i)
}

3、break

import scala.util.control.Breaks
object LoopTest{
  def main(args: Array[String]) {
    val list = List("Hadoop","Hive","Scala")
    val loop = new Breaks
    loop.breakable{
      for (x <- list) {
        println(x)
        if (x == "Scala")
          loop.break()
      }
    }
    println("loop over!")
  }
}

4、元组tuple

/*
 * tuple 元组
 * 语法：
 * val tuple = (变量1,...,变量22)
 * 特点：
 * ⑴元组的类型时Scala和Python中特有的；
 * ⑵在Scala中，元组是n个不同数据类型对象的一个聚合，n的最大值是22；
 * ⑶Map的元素实际上是n=2的元组，即2元组，也是最简单的元组；
 */
//元组的遍历
val tuple = (1,2,"Scala",1)
for (x <- 0 until tuple.productArity) {
  println(tuple.productElement(x))
}

5、数组

/*
 * 数组是存储相同类型的元素的固定大小的连续集合；
 * 数组的第一个元素的索引是数字0，最后一个元素的索引是元素的总数减去1；
 * Scala中数组的类型：
 * 定长数组
 * 变长数组（scala.collection.mutable.ArrayBuffer）
 */
//定长数组（长度不可变）：数组采用()访问，而不是[]，下表从0开始
val a = new Array[String](3) //Array[String] = Array(null,null,null)
a.length  //Int = 3

//不用new，直接将值写在数组中，底层调用的是Object Array的apply方法
val b = Array("aa","bb","cc")
b(1)  //String = bb
// b(3) 报错：java.lang.ArrayIndexOutOfBoundsException:3

//变长数组
val c = scala.collection.mutable.ArrayBuffer[Int]()

//+=/++=/-=/--=/insert/remove/toArray/sum/max/reverse
c += 1
c += 2
c += (3,4)

//++可以放置一个Array进去
c ++= Array(5,6,7,8)

//在指定的位置插入指定的数据
c.insert(0,0)
c


//删除指定位置的数据
c.remove(1)
c

//从第0个开始删除3个
c.remove(0,3)

//变成定长数组
c.toArray
c.toArray.sum
c.toArray.min

//移除最后的两个
c.trimEnd(2)
c

for (i <- 0 until c.length) println(i)
for (ele <- c) println(ele)

//排序
//scala.util.Sorting.quickSort(c)

//将数组转换成字符串
c.mkString(",")
c.mkString("[",",","]")

//数组的遍历
val arr=Array(1,2,3,4)
for (x <- 0 until arr.length) {
  println(arr(x))
}

for (x <- arr) {
  println(x)
}

//排序
val arr1 = scala.collection.mutable.ArrayBuffer(1,2,3,4)
val arr2 = arr1.toArray
scala.util.Sorting.quickSort(arr2)
arr2
arr1.sorted  //默认是升序排序