Scala学习1 基本数据类型，条件，循环

import org.junit.Test

/**
 * scala的基本数据类型，条件，循环
 */
class C1_Base {

    @Test
    def Test1(): Unit = {
        val name1: String = null
        println(name1)
        // Any类是所有类的超类
        val name2: Any = "leo"
        println(name2)

        //指定类型：无论声明val变量，还是声明var变量，都可以手动指定其类型，如果不指定的话，scala会自动根据值，进行类型的推断。
        val name3, name4: String = null
        val num1, num2 = 100

        //基本数据类型：Byte、Char、Short、Int、Long、Float、Double、Boolean
        //类型的加强版类型：scala使用很多加强类给数据类型增加了上百种增强的功能或函数。
        //scala没有基本数据类型与包装类型的概念，统一都是类。scala自己会负责基本数据类型和引用类型的转换操作。
        println(1.toString())
        //1 + 1，可以写做
        1.+(1)
        //Scala还提供了RichInt、RichDouble、RichChar等类型，RichInt就提供了to函数
        // 1.to(10)，此处Int先 隐式转换 为RichInt，然后再调用其to函数
        println(1.to(10))
        //又可以写做
        println(1 to 10)
        //String类通过StringOps类增强了大量的函数 交集
        println("Hello".intersect(" World"))

        //       (1, 2, 3)的写法定义一个Tuple3
        println((1, 2, 3).getClass.getSimpleName)
    }

    @Test
    def mathTest(): Unit = {
        import scala.math._;
        println(sqrt(2));
        println(pow(2, 4));
        println(min(3, Pi))
    }

    @Test
    def Test2(): Unit = {
        //如果调用函数时，不需要传递参数，则scala允许调用函数时省略括号
        println("Hello World".distinct)

        //使用“类名()”的形式，其实就是“类名.apply()”的一种缩写。通常使用这种方式来构造类的对象，而不是使用“new 类名()”的方式。
        println(Array(1, 2, 3, 4)) //实际上是用Array object的apply()函数来创建Array类的实例
        println("Hello World"(6)) //获取第6个字母 实际上是"Hello World".apply(6)的缩写
    }

    @Test
    def ifTest(): Unit = {
        //条件
        //if表达式的定义：在Scala中，if表达式是有值的，就是if或者else中最后一行语句返回的值。
        val age = 30;
        //可以将if表达式赋予一个变量
        val adult = if (age > 18) 1 else 0
        //if表达式的类型推断：由于if表达式是有值的，而if和else子句的值类型可能不同
        //Scala会自动进行推断，取两个类型的公共父类型。
        //Any是String和Int的公共父类型
        //如果if后面没有跟else，则默认else的值是Unit，也用()表示，类似于java中的void或者null
        var a, b, c = 0;
        if (a < 10) {
            b = b + 1;
            c = c + 1
        }
        val d = if (a < 10) {
            b = b + 1;
            c + 1
        }

        println(adult)
        println(isAdult(age))
        println(a + " " + b + " " + c + " " + d)
    }

    def isAdult(age: Int): String = {
        if (age > 18) {
            "adult"
        } else if (age > 12) "teenager" else "children"
    }

    // todo 无法读取
    @Test
    def gameTest(): Unit = {
        //游戏厅门禁
        val name = readLine("Welcome to Game House. Please tell me your name: ")
        print("Thanks. Then please tell me your age: ")
        val age = readInt()
        if (age > 18) {
            printf("Hi, %s, you are %d years old, so you are legel to come here!", name, age)
        } else {
            printf("Sorry, boy, %s, you are only %d years old. you are illegal to come here!", name, age)
        }
    }

    @Test
    def whileTest(): Unit = {
        //循环
        //Scala有while do循环，基本语义与Java相同。
        var n = 10
        while (n > 0) {
            println(n)
            n -= 1
        }
    }

    @Test
    def forTest(): Unit = {
        //Scala没有for循环，只能使用while替代for循环，或者使用简易版的for语句
        val n = 10;

        for (i <- 1 to n) println(i)

        //使用until，表式不达到上限(1-9)
        for (i <- 1 until n) println(i)

        //对字符串进行遍历，类似于java的增强for循环
        for (c <- "Hello World") print(c)
    }

    @Test
    def breakTest(): Unit = {
        //scala没有提供类似于java的break语句。但是可以使用boolean类型变量、return或者Breaks的break函数来替代使用。
        import scala.util.control.Breaks._
        breakable {
            var n = 10
            for (c <- "Hello World") {
                if (n == 5) break;
                print(c)
                n -= 1
            }
        }
    }

    @Test
    def doubleForTest(): Unit = {
        //多重for循环：九九乘法表
        for (i <- 1 to 9; j <- 1 to 9) {
            if (j == 9) {
                println(i * j)
            } else {
                print(i * j + " ")
            }
        }
    }

    @Test
    def ifGuardTest(): Unit = {
        //if守卫：取偶数
        for (i <- 1 to 100 if i % 2 == 0) print(i + " ")
        println()

        //for推导式：构造集合
        //for循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。
        val vector = for (i <- 1 to 10) yield i
        print(vector)
    }

    //函数
    @Test
    def funcTest(): Unit = {
        sayHello1("zy", 30)

        sayHello2("lx")
    }

    //在Scala中定义函数时，需要定义函数的 函数名、参数、函数体。
    //Scala要求必须给出所有参数的 类型，但是不一定给出函数 返回值的类型
    //只要函数体中不包含递归的语句，Scala就可以自己根据表达式推断出返回类型。
    private def sayHello1(name: String, age: Int) = {
        if (age > 18) {
            printf("hi %s, you are a big boy
", name);
            age
        }
        else {
            printf("hi %s, you are a little boy
", name);
            age
        }
    }

    //单行的函数 Unit相当于void
    def sayHello2(name: String): Unit = print("Hello, " + name)

    @Test
    def fabTest(): Unit = {
        println(fab(10))
    }

    //如果在函数体内递归调用函数自身，则必须手动给出函数的返回类型。
    //斐波那契数列
    def fab(n: Int): Int = {
        if (n <= 1) 1
        else fab(n - 1) + fab(n - 2)
    }

    @Test
    def paramTest(): Unit = {
        //在调用函数时，也可以 不按照函数定义的参数顺序 来传递参数，而是使用带名参数的方式来传递。
        println(sayHello3(firstName = "胡", lastName = "宪", middleName = "宗"))
        //还可以 混合使用未命名参数和带名参数，但是未命名参数必须排在带名参数前面。
        println(sayHello3("胡", lastName = "宪", middleName = "宗"))
        //传入名字，年龄默认
        sayHello4("萌萌")
    }

    //在Scala中，有时我们调用某些函数时，不希望给出参数的具体值，而希望使用参数自身默认的值，此时就定义在定义函数时使用默认参数。
    private def sayHello3(firstName: String, middleName: String = "William", lastName: String = "Croft") = firstName + " " + middleName + " " + lastName

    def sayHello4(name: String, age: Int = 20) {
        print("Hello " + name + ", your age is " + age)
    }

    @Test
    def sumTest(): Unit = {
        println(sum(1, 2, 3, 4, 5))
        //如果想要将一个已有的序列直接调用变长参数函数，是不对的。比如val s = sum(1 to 5)。
        // 此时需要使用Scala特殊的语法将参数定义为序列，让Scala解释器能够识别。这种语法非常有用！
        // 一定要好好注意，在spark的源码中大量地使用到了。
        // _*将1 to 5转化为参数序列
        val s = sum(1 to 5: _*)
        println(s)
    }

    //在Scala中，有时我们需要将函数定义为参数个数可变的形式，则此时可以使用变长参数定义函数。
    def sum(nums: Int*) = {
        var res = 0
        for (num <- nums) res += num
        res
    }

    //使用递归函数实现累加
    def sum2(nums: Int*): Int = {
        if (nums.length == 0) 0
        else nums.head + sum2(nums.tail: _*)
    }

    @Test
    def lazyTest(): Unit = {
        //在Scala中，提供了lazy值的特性，也就是说，如果将一个变量声明为lazy，则只有在第一次使用该变量时，变量对应的表达式才会发生计算。
        //这种特性对于特别耗时的计算操作特别有用，比如打开文件进行IO，进行网络IO等。
        //即使文件不存在，也不会报错，只有第一个使用变量时会报错，证明了表达式计算的lazy特性。
        import scala.io.Source._
        lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
        println(lines)
    }

    @Test
    def exceptionTest(): Unit = {
        //在Scala中，异常处理和捕获机制与Java是非常相似的。
        import java.io.IOException
        try {
            throw new IOException("user defined exception")
        } catch {
            case e1: IllegalArgumentException => println("illegal argument")
            case e2: IOException => println("io exception")
        }
    }

}

补充：Scala的数据类型

Scala 与 Java有着一些相同的数据类型，下表列出了 Scala 支持的数据类型：

数据类型	描述
Byte	8位有符号补码整数。数值区间为 -128 到 127
Short	16位有符号补码整数。数值区间为 -32768 到 32767
Int	32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float	32位IEEE754单精度浮点数
Double	64位IEEE754单精度浮点数
Char	16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String	字符序列
Boolean	true或false
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null 或空引用
Nothing	Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
Any	Any是所有其他类的超类
AnyRef	AnyRef类是Scala里所有引用类(reference class)的基类