大数据8_02_Scala变量-字符串-输入输出

3 变量-字符串-输入输出

3.1 注释

Scala中的注释和Java中的注释一样。

//单行注释
/*多行注释*/
/**文档注释*/

单行注释的区别：

3.2 变量

①变量声明语法:

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

var可变变量 val不可变变量

②如果变量的类型可以通过变量值推断出来，那么可以省略变量类型：

object Variable {
  def main(args : Array[String]) : Unit = {
    //声明变量的语法：var | val 变量名 : 变量类型 = 变量值
    //对比Java的变量声明语法：变量类型 变量名 = 变量值
    val name : String = "Tom"
    //java: String  name = "Tom"

    var age : Int = 20
    //java : final int age = 20
    
    //通过变量值可以推断出来变量的类型，就可以省略类型
    val gender = "M"
    val num = 99
  }
}

③变量的初始化：scala必须显示初始化

object Variable2 {
  def main(args : Array[String]) : Unit = {
      //初始化不赋值就错误！
//    val name : String
    val name : String = "Tom"
  }
}

④可变变量VS不可变变量

• 可变变量 var
• 不可变变量 val 类似于java中的final

更推荐使用val

    //var 可变变量
    var name : String = "Tom"
    name = "Jerry"
    //不可变变量
    val age : Int = 10

//可变变量
var name : String = "AA"
//不可变变量
var username : String = "BB"

//常量：true，false，1，‘A’
/*
常量 不等于 不可变变量
*/

3.3 标识符

①字符数字：

Scala标识符可以使用字母或下划线开头，后面可以接字母或数字，符号$也被看所字母

$不能开头，因为Scala编译器对于一些特殊符号会编译冲突：比如：

Scala 内部实现时会使用转义的标志符，比如:-> 使用 $colon$minus$greater 来表示这个符号。

②符号：

// 和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
// 切记，能声明和能使用是两回事

③关键字或保留字

3.4 字符串

scala中的字符串实际上就是Java中的String类

object TestString {
  def main(args : Array[String]) : Unit = {
    val name : String = "Jerry"
    val subName : String = name.substring(1, 4)
    println(s"name = ${name}, subName = ${subName}")
  }
}

①字符串连接

②传值字符串

③插值字符串

④多行字符串

object TestString2 {
  def main(args : Array[String]) : Unit = {
    val name : String = "Tom"
    val age : Int = 20
    //1 字符串连接
    println("name = " + name + ", age = " + age)

    //2 传值字符串
    printf("name = %s, age = %d\n", name, age)

    //3 插值字符串
    println(s"name = ${name}, age = ${age}")

    //4 多行字符串
    println(
      """
        |select *
        |from student
        |where name like "T%"
        |""".stripMargin)
  }
}

/*
name = Tom, age = 20
name = Tom, age = 20
name = Tom, age = 20

select *
from student
where name like "T%"
*/

object StringPrint {
  def main(args: Array[String]): Unit = {
    //var 可变变量
    var name : String = "Tom"
    name = "Jerry"
    //不可变变量
    val age : Int = 10
    //传值字符串
    printf("name : %s \n", name)
    //插入字符串
    println(s"name = ${name}")
    //多行字符串
    println(
      s"""
        |Hello
        |name : ${name}
        |age : ${age}
        |""".stripMargin)

  }
}

3.5 输入输出

①从控制台获取输入

object TestInput {
  def main(args: Array[String]): Unit = {
    print("please enter your name: ")
    val name: String = scala.io.StdIn.readLine()
    println(s"your name is ${name}")
  }
}

②从文件获取输入

object TestIO2 {
  def main(args: Array[String]): Unit = {
    val source = scala.io.Source.fromFile(new File("input/word.txt"))
    //变量生成的快捷键加.var
    val strings = source.getLines()
    //获取迭代器
    while (strings.hasNext) {
      println(strings.next())
    }
  }

③输出到文件

object TestIO3 {
  def main(args: Array[String]): Unit = {
    val writer = new PrintWriter(new File("output/word.txt"))
    writer.write(
      """
        |Hello
        |World
        |Spark
        |""".stripMargin)

    writer.println("Scala")
    writer.flush()
    writer.close()
  }
}

④网络传输

传输字符：

object TestClient {
  def main(args: Array[String]): Unit = {

    val client = new Socket("localhost", 9090)
    val writer = new PrintWriter(new OutputStreamWriter(client.getOutputStream))

    while (true){
      println("输入对server的内容：")
      val str = scala.io.StdIn.readLine()
      writer.println(str)
      writer.flush()

    }
  }
}


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

传输对象：需要该类实现Serializable接口，这样才能在网络中传输对象。

object TestServer {
  def main(args: Array[String]): Unit = {
    val server = new ServerSocket(9090)

      val socket = server.accept()
      val stream = new ObjectInputStream(socket.getInputStream)
      val value = stream.readObject()
      println("接收对象："+ value)
      socket.close()
      server.close()
  }
}

object TestClient {
  def main(args: Array[String]): Unit = {
    val client = new Socket("localhost", 9090)

    val outputStream = new ObjectOutputStream(client.getOutputStream)
    outputStream.writeObject(new Student())
    outputStream.close()
    client.close()
  }
}

public class Student implements Serializable {
    private String name = "Tom";
    private int age = 10;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}