大数据云计算——scala语言基本的语法

scala语言

Spark—新一代内存级大数据计算框架，是大数据的重要内容。Spark 就是使用 Scala 编写的。因此为了更好的学习 Spark, 需要掌握 Scala 这门语言。Scala 是 Scalable Language 的简写，是一门多范式(编程的方式[面向对象编程,函数式编程])的编程语言。

Scala 是一门以 java 虚拟机（JVM）为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。

特点：

1) Scala 是一门多范式 (multi-paradigm) 的编程语言， Scala 支持面向对象和函数式编程 2) Scala 源代码(.scala)会被编译成 Java 字节码(.class)，然后运行于 JVM 之上，并可以调用现有的 Java 类库，实现两种语言的无缝对接。 [案例演示] 3) scala 单作为一门语言来看， 非常的简洁高效 【三元运算符, ++ --】 4) Scala 在设计时， 马丁·奥德斯基 是参考了 Java 的设计思想，可以说 Scala 是源于 java，同时马丁·奥德斯基 也加入了自己的思想，将函数式编程语言的特点融合到 JAVA 中, 因此，对于学习过 Java 的同学，只要在学习 Scala 的过程中，搞清楚 Scala 和 java 相同点和不同点，就可以快速的掌握 Scala 这门语言 5) 快速有效掌握 Scala 的建议 [1. 学习 sala 独有的内容(语法，功能)2 搞清楚 scala 和 java 的区别， 3 如果正确的规范的使用 scala] //ssm => ssh （hibernate mvc ）

Scala与java的区别

/**
 * 1. object表示一一个伴生对象，这里我们可以简单的理解就是一个对象
 * 2. HelloScala就是对象名字，它底层真正对应的类名是HelloScala$,对象是HelloScala$ 类型的- -个静态对象MODULE$
 * 3.当我们编写一个object HelloScala底层会生成两个.class文件分别是HelloScala和HelloScala$
 * 4. scala在运行时，的流程如下
 * (1)先从HelloScala 的main开始执行
 * public static void main(StringD paramArrayOfString){
 *    HelloScala$.MODULE$.main(paramArrayOfString);
 * }
 * (2)然后调用HelloScala$类的方法HelloScala$ .MODULE$.main
 * (3) 即执行了下面的代码
 * public void main(String[ args){
 *    PredefMODUL E$ printn"hello,scala!~~");
 * }
 * object HelloScala {
 * 1. def表示是- -个方法，这是一个关键字
 * 2. main表示方法名字，表示程序入口
 * 3. args: Array[String]表示形参，scala 的特点是讲参数名在前，类型后
 * 4. Array[String]表示类型数组
 * 5.:Unit=表示该函数的返回值为空(void)
 * 6. printn("hello,scala!~")输出一句话
 * }
 */

scala的输入方式：

1)字符串通过+号连接（类似 java）。 2) printf 用法 （类似 C 语言）字符串通过 % 传值。 (格式化输出) 3) 字符串通过$引用(类似 PHP）

package scala_base

object outputDemo {
  def main(args: Array[String]): Unit = {
    val name: String = "Tom"
    val age: Int = 10
    val sal: Double = 7.58

    //格式化输出
    //sal=%.2f 保留小数点两位的方式输出(四舍五入)
    printf("name=%s age=%d sal=%.2f\n", name, age, sal)
    //字符串通过$引用(类似 PHP）。
    println(s"name=$name age=${age + 1} sal=$sal sum2=${sum2(23, 90)}")
  }

  /**
   * @example
   * n1=10 n2=10 返回是n1-n2=-10
   * @param n1 形参
   * @param n2 形参
   * @return 返回值
   */
  def sum2(n1: Int, n2: Int): Int = {
    return n1 + n2
  }
}

Scala的变量的认识

声明/定义变量 (scala 要求变量声明时初始化一定要初始化 初始化可以是默认的值)：

var | val 变量名 [: 变量类型] = 变量值

注意事项 1) 声明变量时， 类型可以省略（就是叫 类型推断） 2) 类型确定后，就不能修改，说明 Scala 是强数据类型语言. 3) 在声明/定义一个变量时，可以使用 var 或者 val 来修饰， var 修饰的变量可改变， val 修饰的变量不可改。(推荐使用 val,线程安全，使用效率高、val修饰的变量在编译后，等同于加上final）

package scala_base

object VarDemo01 {
  def main(args: Array[String]): Unit = {
    var name: String = "smith"
    var age: Int = 10
    var gender: Char = '男'
    var isPass: Boolean = true
    var sal: Float = 8907.4f
    var num1 = 100 //就使用到了类型推断
    //在 idea 中，直接可以通过工具看到变量的类型
    //类型确定后，就不能修改，说明Scala 是强数据类型语言
    //num1 = "jack"
    //在声明/定义一个变量时，可以使用 var 或者 val 来修饰， var 修饰的变量可改变， val 修饰的变量不可改
    //因为 val 是线程安全的，因此效率高， scala 推荐使用
    //即能够使用 val ,就不要使用 var
    //var 是可以变的。
    var lover = "小红"
    lover = "小黑"
    //val 是不可变的变量
    val girlFriend = "小白"
    //girlFriend = "小黄"
  }
}
package scala_base

/**
 * 变量声明时，需要初始值
 */
object VarDemo03 {
  def main(args: Array[String]): Unit = {
    //创建一个对象
    //1. dog 是 val 修饰的，即 dog 是不可变，即 dog 的应用不可变
    //2. 但是 dog.name 是 var 他的属性可变
    val dog = new Dog
    //dog = null [error]
    dog.name = "大黄狗"
    var dog2 = new Dog
    dog2 = null
    dog2.name = "小黄瓜"
    //变量声明时，需要初始值（显示初始化）。
    var job: String = "大数据工程师"
  }
}

class Dog {
  var name = "tom" //初始化 name 为 tom
}

Scala 数据类型分为两大类 AnyVal(值类型) 和 AnyRef(引用类型)， 注意：不管是 AnyVal 还是 AnyRef 都是对象。

1) Any 是所有类的根类型,即所有类的父类(基类) 2) 在 scala 中类分为两个大的类型分支(AnyVal [值类型，即可以理解成就是 java 的基本数据类型], AnyRef 类型) 3) 在 AnyVal 虽然叫值类型，但是仍然是类(对象) 4) 在 scala 中有两个特别的类型(Null ), 还有一个是 Nothing 5) Null 类型只有一个实例 null, 他是 bottom class ,是 AnyRef 的子类. 6) Nothing 类型是所有类的子类， 它的价值是在于因为它是所有类的子类，就可以将 Nothing 类型的对象返回给任意的变量或者方法，比如案例 def f1():Nothing= { //表示 f1 方法就是没有正常的返回值，专门用于返回异常            throw new Exception("异常发生") } 7) 在 scala 中仍然遵守 低精度的数据自动的转成 高精度的数据类型。 8) 在 scala 中， Unit 类型比较特殊，这个类型也只有一个实例 ()

特点:相对于 java 的类型系统， scala 要复杂些！也正是这复杂多变的类型系统才让面向对象编程和函数式编程完美的融合在了一起。

package scala_base

/**
 * Scala 与 Java 有着相同的数据类型，在 Scala 中数据类型都是对象，也就是说 scala 没有 java 中的原生类型
 * Scala 数据类型分为两大类 AnyVal(值类型) 和 AnyRef(引用类型)， 注意：不管是 AnyVal 还是 AnyRef 都
 * 是对象
 */
object DataTypeDemo01 {
  def main(args: Array[String]): Unit = {
    //在 scala 中，一切皆为对象 ，比如(Int,Float,Char....)
    var num1: Int = 10
    println(num1.toString)
    println(100.toFloat)
    var sex = '男'
    println(sex.toString)
  }
}

Scala的数据类型列表：

变量的使用细节

1) Scala 各整数类型有固定的表数范围和字段长度，不受具体 OS 的影响，以保证 Scala 程序的可移植性。

2) Scala 的整型 常量/字面量 默认为 Int 型，声明 Long 型 常量/字面量 须后加‘l’’或‘L’

3) Scala 程序中变量常声明为 Int 型，除非不足以表示大数，才使用 Long, 开发大数据时，我们的优化工作是点点滴滴

4）Scala 的浮点型常量默认为 Double 型，声明 Float 型常量，须后加‘f’或‘F’

5）Scala 也允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如： var c3 = ‘\n’ // '\n'表示换行符

6）可以直接给 Char 赋一个整数，然后输出时，会按照对应的 unicode 字符输出

7）Char 类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码.

package scala_base

/**
 * 1) 字符常量是用单引号(‘ ’ )括起来的单个字符。例如： var c1 = 'a‘ var c2 = '中‘ var c3 = '9'
 * 2) Scala 也允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如： var c3 = ‘\n’ // '\n'表示换行符
 * 3)可以直接给 Char 赋一个整数，然后输出时，会按照对应的 unicode 字符输出 ['\u0061' 97]
 * 4) Char 类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码
 */
object CharType {
  def main(args: Array[String]): Unit = {
    var char1: Char = 'c'
    var char2: Char = 97
    println("cha1=" + char1 + "  char2=" + char2)
    var char3: Char = 'a' //原因是‘a’+ 1 =>97 + 1 =>Int
    var char4: Char = 97 //原因:运算就会有类型 Int=>char
    var char5: Char = 98 //原因，没有运算，编译器只判断范围有没有越界

    println(char3)
  }
}

scala中的Unit Null Nothing的类型的比较

Unit：表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。unit只有一个实例值，写成()。相当于是java中的void变量的。 Null：null , Null类型只有一个实例值null Nothing：Nothing类型在scala的类层级的最低端;它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性) def f1():Nothing ={throw new Exception()}

注意事项和细节说明：

1) Null 类只有一个实例对象， null，类似于 Java 中的 null 引用。 null 可以赋值给任意引用类型(AnyRef)，但是不能赋值给值类型(AnyVal: 比如 Int, Float, Char, Boolean, Long, Double, Byte, Short)

2) Unit 类型用来标识过程，也就是没有明确返回值的函数。由此可见，Unit 类似于 Java 里的 void, Unit 只有一个实例， ()，这个实例也没有实质的意义。

3) Nothing，可以作为没有正常返回值的方法的返回类型， 非常直观的告诉你这个方法不会正常返回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。

scala的值的类型转换

当 Scala 程序在进行赋值或者运算时， 精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换(隐式转换 implicit conversion)

1) 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。

2) 当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，就会报错，反之就会进行自动类型转换。

3) (byte, short) 和 char 之间不会相互自动转换。

4) byte， short， char 他们三者可以计算，在计算时首先转换为 Int 类型。

5）Char 类型可以保存 Int 的常量值，但不能保存 Int 的变量值，需要强转

package scala_base

/**
 * 这是在scala中一切都是的对象 包括了的这个这个变量 和基本的类型都是的 所以能够直接调用的函数 其他的就是的在使用的是函数 就是说这样的都实现的对函数封装
 *
 * 例如：
 * final abstract class Byte private extends AnyVal {
 * def toByte: Byte
 * def toShort: Short
 * def toChar: Char
 * def toInt: Int
 * def toLong: Long
 * def toFloat: Float
 * def toDouble: Double
 * }
 */
object DataTypeTrans {
  def main(args: Array[String]): Unit = {
    val b: Byte = 10
    println(b.toInt)
    val d: Double = 1.123
    println(d.toByte)
  }
}

Scala中的运算符（同java语法）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。 1) 算术运算符 2) 赋值运算符 3) 比较运算符(关系运算符) 4) 逻辑运算符【与，或，非】 5) 位运算符 (位运算 ~ | ^ >> >>...)

scala中程序流程控制（同java语法）

在 scala 中没有 switch,而是使用模式匹配来处理

 /**
   * scala中的for的书写方式改变了
   */
  def testfor() = {
    val n = 10
    for (i