大数据Hadoop第九周——Scala开发环境搭建+Scala语言值变量类型表达式

大数据第9周

1.Scala开发环境搭建

目前具备全部功能的集成开发环境只有Idea。
下载解压idea：tar -zxvf ideaIE-2019.3.3.tar.gz。
进入bin目录，执行：./idea.sh。
选择新建一个project。

接着按如下界面选择。

进入如下界面。输入Project name。

JDK选择我们hadoop系统使用的同一个软件包：点击JDK栏右侧的“New”，在界面中选择我们使用的jdk1.8文件夹，然后点击“OK”。

点击“Scala SDK”右侧的 “Create”，如果在以下界面中有scala显示，那么检查版本号是否与我们使用的(2.11.12)相同，如果相同，可以直接选择，如果不同，点击下方“Browse”。

选择我们使用的Scala软件包的文件夹，点击下方“OK”。

项目建立后，点击项目界面左侧的“src”。因为我们将在src下建立文件。

在主菜单点击“New”，选择“Scala Class”。

跳出如下界面，要在在界面中选择“Object”，输入名字后回车。不要选“Class”。Scale的顺序是project，然后object，要有object才可以运行，与java不同。

若要调字体大小等，点击在“File”菜单里的“Setting”，在“Editor”的“Font”下更改，如图所示。

在界面中输入一段程序，写入main，选择“main”会自动建立一个function。下入一段程序。鼠标光标点在程序上，点击右键，选择“Run”。

结果显示如下图：

2.SCALA语言简介

2.1值和变量

值：val

变量：var

“值”类型声明后不可以更改数值，而“变量”类型可以。

声明时可以指定数值类型，也可以不指定，不指定时系统会自动判定。
指定类型方式：用冒号“:”：例如：val c:Float=5。
注意对大小写敏感。声明时如果不指定数据类型，则根据初始化的字面量，系统自动进行判断，判断的原则是：

数值类型在计算中可以进行自动转换，如果计算的数值类型不同，将向高级的数值类型自动转换，而不会向低级的数据类型进行转换。

如果要手工转换数据类型，使用toType方法。如果转成Int型是toInt，转成Float型是toFloat。

1. Scala类型
C和Java基本类是Object，而Scala是Any。它包括数值类型和引用类型。如下图所示。

2.3 String类型

String类型都是引用类型。
要在String中加入值或变量，更直接的一种方式是利用字符串内插。
字符串内插：在字符串中插入变量，显示为变量的值，用“$”。

3.Scala的表达式

3.1表达式的返回值

Scala语言的表达式返回值不是用return语句，而是最后执行的那一句就是返回语句。
如图在“{}”中的是一句表达式，最后执行的那一句“a”、“b”、“c”就是返回语句。这是Scala区别于其它语言的较大的不同点，其它语言一般都用“return”返回。

如果没有“{}”那就说明不是一句表达式，每一句表达式都会有返回。变量“resA”只是用来存储表达式的返回值。

3.2 if表达式

Scala只有if，else，没有其他语言常用的if，else if，else if，else格式。没有“？”表达式语句，比如java中的System.exit(job.waitForCompletion(true) ? 0 : 1);。

3.3 匹配表达式

类似其他语言的case语句。

object testScala {
  def main(args: Array[String]): Unit = {
    val x=10; val y=20
    val max=x>y match{
        case true =>println(s"Received data is $x.");x
        case false =>println(s"Received data is $y.");y
    }
    println(s"The max is $max.")
  }
}

通配模式匹配，用“other”或“_”。

object testScala2 {
  def main(args: Array[String]): Unit = {
    var message="OK"
    val status = message match {
        case "OK" => 200
        case other => {
          println(s"Couldn't parse $other")
          -1
        }
    }
    println(s"status is $status")
    message="hhh"
    val status2 = message match {
      case "OK" => 200
      case other => {
        println(s"Couldn't parse $other")
        -1
      }
    }
    println(s"status2 is $status2")
  }
}

模式哨卫匹配。
第一个例子：

object testScala3 {
  def main(args: Array[String]): Unit = {
    val response:String="OK"
    val res=response match{
      case s if s!=null =>println(s"Received s is $s.");s
      case s =>println(s"Other $s");
    }
    println(s"The res is $res.")
  }
}

第二个例子：

object testScala4 {
  def main(args: Array[String]): Unit = {
    val x:Int=12180
    val y:Any=x
    val res=y match{
      case x:String =>println(s"$x.");x
      case a:Float =>println(s"$a%.2f.");a
      case b:Double =>println(s"$b..2f.");b
      case c:Long =>println(s"${c}l.");c
      case d:Int =>println(s"${d}i.");d
    }
    println(s"The res is $res.")
  }
}

3.4 for循环

(1) 例如：for (x<-1 to 7) println(s"Day $x:")

注意：for()里赋值要用“<-”，不是“=”。

(2) 如果使用yield，则结果作为一个集合返回。

object testScala5 {
  def main(args: Array[String]): Unit = {
    val res = for(x<-1 to 7) yield {
      println(s"Day: $x:");
      s"Day: $x:"
    }
    println(res)
  }
}

运行结果：

其中循环里的s"Day: $x:"是把这个值存入res。如果没有s"Day: $x:"这句话，res的结果会是Vector((), (), (), (), (), (), ())，也会存入东西，但是是空的。而如果连yield也没有的话， res的结果是()。

(3) 迭代器哨卫

也叫过滤器，就是在for语句中加入if表达式，通过if跳过一些迭代。

object testScala6 {
  def main(args: Array[String]): Unit = {
    val res = for (x <- 1 to 20 if x%3==0) yield {println(s"Result is $x:");x}
    println(res)
  }
}

运行结果：

(4) 迭代器嵌套

相当于多个for循环，多个嵌套的时间复杂度是乘积关系。For后面是{}，不是()。

testScala7 {
  def main(args: Array[String]): Unit = {
    val res = for(x<-1 to 2; y<-1 to 3) yield{print(s"(%x,$y)");(x,y)}
    println(s"
result: $res")
  }
}

执行结果：

(5) 迭代值绑定

其实就是在跑循环的时候获得变化的变量的值，然后对它做些操作。
例如，下面例子中，pow = 1 <<i就是值绑定，<<是指二进制左移，就是乘2，右移是除2。再将pow的值存入res。

object testScala8 {
  def main(args: Array[String]): Unit = {
    val res = for(i<-1 to 8;pow=1<<i) yield{print(s"$pow");pow}
    println("
result:$res")
  }
}

3.5 while/do while循环

和java/c没大的区别

4．函数

4.1无输入函数

object testScala {
  def printhi= println("hello,my first function")
  def main(args: Array[String]): Unit = {
     printhi
    }
}

运行结果：

4.2函数的返回值类型定义方法

用“def 函数名：类型 = ”定义

object testScala9 {
  def printhi:String = "hello, my first function"
  def main(args: Array[String]): Unit = {
    println(printhi)
  }
}

运行结果同上。

4.3 定义一个完整的函数

包括参数、返回值。

object testScala10 {
  def multi(x:Int,y:Int):Long=x*y
  def main(args: Array[String]): Unit = {
    val res=multi(3,5)
    println(s"The multi result is $res.")
  }
}

执行结果：

4.4 return语句在函数中的应用

Scala语言一般不用return语句，但也可以使用，主要的使用场合是提前终止函数的运行。

4.5 空括号的使用

对于没有输入参数的函数，可以使用空括号，这样在调用时就显得比较和其他函数一致。

4.6 递归函数

递归函数要需要注意什么时候会终止，终止条件是什么。
下面的例子中n<1就是终止条件。

object testSScala11 {
  def power(x:Int, n:Int): Long = {
    if(n>=1) x*power(x,n-1)
    else 1
  }
  def main(args: Array[String]): Unit = {
    var res=power(2,8);println(res)
    res=power(2,1);println(res)
    res=power(2,0);println(res)
  }
}

运行结果：

4.7 用命名参数调用函数

其他语言在实参传入过程中，一般是按顺序进行的，但scala可以不按顺序进行，如果不按顺序传入实参，则需要使用形参名字，采用“形参名=实参“的形式。

4.8 有默认值的参数

在函数定义时，可以直接指定参数的默认值，这样在调用时可以不传入对应的实参。一般情况下，有默认值的参数放在参数表的最后。

比如：传参时，定义1，2，3，4(默认)，然后传参1，2，3是可以的。

4.9 Vararg参数

Scala也支持vararg参数，所以可以定义输入参数个数可变的函数。

object testScala12 {
  def sum(x:Int*):Long={var total=0;for(i<-x) total+=i;total}
  def main(args: Array[String]): Unit = {
      val res=sum(1,2,3,4,5,6)
      println(s"The multi result is $res.")
  }
}

运行结果：

上述程序中，sum的参数数量是可变的(vararg)，表达方式是在类型后加“*”。

4.10 类型函数(下次）