Scala 变量和数据类型

Scala 变量和数据类型

注释

• Scala注释使用和Java完全一样。注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

单行注释

object ScalaComment{
    def main(args: Array[String]): Unit = {
        // 单行注释
    }
}

多行注释

object ScalaComment{
    def main(args: Array[String]): Unit = {
        /*
           多行注释
         */
    }
}

文档注释

/**
  * doc注释
  */
object ScalaComment{
    def main(args: Array[String]): Unit = {
    }
}

变量

变量是一种使用方便的占位符，用于引用计算机内存地址，变量创建后会占用一定的内存空间。基于变量的数据类型，操作系统会进行内存分配并且决定什么将被储存在保留内存中。因此，通过给变量分配不同的数据类型，你可以在这些变量中存储整数，小数或者字母。

语法声明

变量的类型在变量名之后等号之前声明。

object ScalaVariable {
    def main(args: Array[String]): Unit = {
        // var | val 变量名 ：变量类型 = 变量值
        // 用户名称
        var username : String = "zhangsan"
        // 用户密码
        val userpswd : String = "000000" 
    }
}

变量的类型如果能够通过变量值推断出来，那么可以省略类型声明，这里的省略，并不是不声明，而是由Scala编译器在编译时自动声明编译的。

object ScalaVariable {
    def main(args: Array[String]): Unit = {
        // 因为变量值为字符串，又因为Scala是静态类型语言，所以即使不声明类型
        // Scala也能在编译时正确的判断出变量的类型，这体现了Scala语言的简洁特性。
        var username = "zhangsan"
        val userpswd = "000000" 
    }
}

变量初始化

object ScalaVariable {
    def main(args: Array[String]): Unit = {
        var username // Error
        val username = "zhangsan" // OK
    }
}

可变变量

object ScalaVariable {
    def main(args: Array[String]): Unit = {
        // 用户名称
        var username : String = "zhangsan"
        username = "lisi" // OK
        username = true // Error
    }
}

2.2.4 不可变变量

object ScalaVariable {
    def main(args: Array[String]): Unit = {
        // 用户名称
        val username : String = "zhangsan"
        username = "lisi" // Error
        username = true // Error
    }
}

标识符

Scala 可以使用两种形式的标志符，字符数字和符号。 字符数字使用字母或是下划线开头，后面可以接字母或是数字，符号"$"在Scala中也看作为字母。然而以"$“开头的标识符为保留的 Scala 编译器产生的标志符使用，应用程序应该避免使用”$"开始的标识符，以免造成冲突。
Scala 的命名规范采用和 Java 类似的 camel 命名规范，首字符小写，比如toString。类名的首字符还是使用大写。此外也应该避免使用以下划线结尾的标志符以避免冲突。
Scala内部实现时会使用转义的标志符，比如:-> 使用 $colon$minus$greater 来表示这个符号。 和Java一样的标识符命名规则

val name = "zhangsan" // OK
val name1 = "zhangsan0"   // OK
//val 1name = "zhangsan0" // Error
val name$ = "zhangsan1" // OK
val $name = "zhangsan2" // OK
val name_ = "zhangsan3" // OK
val _name = "zhangsan4" // OK
val $ = "zhangsan5"     // OK
val _ = "zhangsan6"     // OK
//val 1 = "zhangsan6"     // Error
//val true = "zhangsan6"  // Error

// 和Java不一样的标识符命名规则
val + = "lisi" // OK
val - = "lisi" // OK
val * = "lisi" // OK
val / = "lisi" // OK
val ! = "lisi" // OK
//val @ = "lisi" // Error
val @@ = "lisi" // OK
//val # = "lisi" // Error
val ## = "lisi" // OK
val % = "lisi" // OK
val ^ = "lisi" // OK
val & = "lisi" // OK
//val ( = "lisi" // Error
//val ( = "lisi" // Error
//val ) = "lisi" // Error
//val = = "lisi" // Error
val == = "lisi" // OK
//val [ = "lisi" // Error
//val ] = "lisi" // Error
//val : = "lisi" // Error
val :: = "lisi" // OK
//val ; = "lisi" // Error
//val ' = "lisi" // Error
//val " = "lisi" // Error
val "" = "lisi" // OK
val < = "lisi" // OK
val > = "lisi" // OK
val ? = "lisi" // OK
val | = "lisi" // OK
val \ = "lisi" // OK
//val ` = "lisi" // Error
val ~ = "lisi" // OK
val :-> = "wangwu" // OK
val :-< = "wangwu" // OK

字符串

在 Scala 中，字符串的类型实际上就是 Java中的 String类，它本身是没有 String 类的。
在 Scala 中，String 是一个不可变的字符串对象，所以该对象不可被修改。这就意味着你如果修改字符串就会产生一个新的字符串对象。

object ScalaString {
    def main(args: Array[String]): Unit = {
        val name : String = "scala"
        val subname : String = name.substring(0,2)
    }
}

字符串连接

object ScalaString {
    def main(args: Array[String]): Unit = {
        // 字符串连接
        println("Hello " + name)
    }
}

传值字符串

object ScalaString {
    def main(args: Array[String]): Unit = {
        // 传值字符串(格式化字符串)
        printf("name=%s\n", name)
    }
}

插值字符串

object ScalaString {
    def main(args: Array[String]): Unit = {
        // 插值字符串
        // 将变量值插入到字符串
        println(s"name=${name}")
    }
}

多行字符串

object ScalaString {
    def main(args: Array[String]): Unit = {
      
        println(
                    s"""
                      | Hello
                      | ${name}
        """.stripMargin)
}
}

输入输出

输入

object ScalaIn {
    def main(args: Array[String]): Unit = {
        // 标准化屏幕输入
        val age : Int = scala.io.StdIn.readInt()
        println(age)
}
}

• 从文件中获取输入

object ScalaIn {
def main(args: Array[String]): Unit = {
    // 请注意文件路径的位置
        scala.io.Source.fromFile("input/user.json").foreach(
            line => {
                print(line)
            }
        )
scala.io.Source.fromFile("input/user.json").getLines()
}
}

输出

Scala进行文件写操作，用的都是 java中的I/O类

object ScalaOut {
    def main(args: Array[String]): Unit = {
      val writer = new PrintWriter(new File("output/test.txt" ))
      writer.write("Hello Scala")
      writer.close()
}
}

网络

Scala进行网络数据交互时，采用的也依然是 java中的I/O类

object TestServer {
    def main(args: Array[String]): Unit = {
        val server = new ServerSocket(9999)
        while ( true ) {
            val socket: Socket = server.accept()
            val reader = new BufferedReader(
                new InputStreamReader(
                    socket.getInputStream,
                    "UTF-8"
                )
            )
            var s : String = ""
            var flg = true
            while ( flg  ) {
                s = reader.readLine()
                if ( s != null ) {
                    println(s)
                } else {
                    flg = false
                }
            }
        }
    }
}

...

object TestClient {
    def main(args: Array[String]): Unit = {
        val client = new Socket("localhost", 9999)
        val out = new PrintWriter(
            new OutputStreamWriter(
                client.getOutputStream,
                "UTF-8"
            )
        )
        out.print("hello Scala")
        out.flush()
        out.close()
        client.close()
    }
}

数据类型

Scala与Java有着相同的数据类型，但是又有不一样的地方

Java数据类型

Java的数据类型包含基本类型和引用类型

• 基本类型：byte,short,char,int,long,float,double,boolean
• 引用类型：Object，数组，字符串，包装类，集合，POJO对象等

Scala数据类型

Scala是完全面向对象的语言，所以不存在基本数据类型的概念，有的只是任意值对象类型（AnyVal）和任意引用对象类型(AnyRef)