Scala学习

1. 注释（与JAVA一致）

单行//
多行/* */

2. 变量

1. 赋值格式

与JAVA不太相同
var 变量名 ：变量类型 = 变量值
var 表示可变变量
注意这里变量名在类型之前，而且中间是：分隔符

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

2. val (类似final常量，不可变)

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

3.$

在scala中，$被当做字母，而不是符号

4.JAVA访问Scala

1.访问单例对象

单例对象在Scala中相当于Java中的静态成员，它们没有实例并且可以通过完全限定名直接访问其公共成员。Scala编译器会为单例对象生成一个带有$后缀的类，并且有一个名为MODULE$的静态字段，通过这个字段可以获得单例对象的引用。
Scala

object ScalaSingleton {
  def someMethod(): Unit = println("Called from Scala singleton")
}

JAVA

import com.example.ScalaSingleton; // 假设包名为com.example
// 类$.MODULE$.对象
ScalaSingleton$.MODULE$.someMethod();

2.访问Scala类的实例(直接与JAVA一致)

Scala类编译后产生的.class文件可以直接在Java中实例化并调用其公共 方法 。
Scala

 class ScalaInstance {
  def instanceMethod(): Unit = println("Called from Scala instance.")
}

JAVA

import com.example.ScalaInstance; // 假设包名为com.example
ScalaInstance scalaObj = new ScalaInstance();
scalaObj.instanceMethod();

4.字符串处理

1. 字符串连接

与JAVA一致（+）

2. 字符串插值

s"" 表示这是一个字符串插值字符串

// 第二种写法与C差不多，真是，该死的回忆
// 第一种写法，感觉类似SQL那种$赋值
println(s"name=$name")  // 使用字符串插值
printf("name=%s\n", name)

3. 多行字符串

s"" 表示这是一个字符串插值字符串，其中 $name 是一个变量占位符，将在运行时被相应变量的值替换。
| 符号是用来设置多行字符串格式化的顶格符（margin）。在最终输出结果中，| 不会显示，因为在使用 .stripMargin 方法时，Scala 会移除所有以 | 符号开始的行的左侧空白字符。

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

3. 输入输出

1. 输入

object ScalaIn {
    def main(args: Array[String]): Unit = {
        // 控制台标准化屏幕输入
        //scala.io.StdIn.readInt()
        val age : Int = scala.io.StdIn.readInt()
        println(age)
        // 文件输入
        //scala.io.Source.fromFile("文件路径")
        scala.io.Source.fromFile("input/user.json").foreach(
            line => {
                print(line)
            }
        )
scala.io.Source.fromFile("input/user.json").getLines()
}
}

2. 输出

// 调用JAVA的IO操作对文件进行写操作
object ScalaOut {
    def main(args: Array[String]): Unit = {
      val writer = new PrintWriter(new File("output/test.txt" ))
      writer.write("Hello Scala")
      writer.close()
}
}

3. 网络

写和网络都是用JAVA的IO类

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()
    }
}

4. 数据类型

这里类似python 可以自动类型转换

5.运算符（eq与equal）

eq与equal
equals() 方法主要用于判断两个对象的内容是否相等。如果对象重写了 equals() 方法，那么它会根据重写后的逻辑来判断两个对象是否相等。在某些情况下（比如对于基本类型的包装类，如 Integer、Character 等），即使两个对象不是同一个实例，只要它们包含的值相同，equals() 方法也会返回 true。

eq() 方法则是判断两个对象是否是同一个实例，也就是说，它们是否指向内存中的同一位置。只有当两个引用指向的是堆内存中的同一对象时，eq() 方法才会返回 true。

6.循环（这里和JAVA差距很多）

1.循环条件

1. range(a,b) 包a不包b [a,b)
2. a to b 包a包b [a,b]
3. a until b [a,b)

object ScalaLoop {
    def main(args: Array[String]): Unit = {
    
        for ( i <- Range(1,5) ) { // 范围集合
            println("i = " + i )
        }
        for ( i <- 1 to 5 ) { // 包含5
            println("i = " + i )
        }
        for ( i <- 1 until 5 ) { // 不包含5
            println("i = " + i )
        }
    }
}

2.循环守卫（附加条件continue）

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5) if i != 3  ) {
            println("i = " + i )
        }
    }
}

3.循环步长

range 直接逗号加
to 跟by

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5,2) ) {
            println("i = " + i )
        }
        for ( i <- 1 to 5 by 2 ) {
            println("i = " + i )
        }
    }
}

4.嵌套循环

感觉第一种有点颠覆我的想象

1. 直接分号后面加

  for ( i <- Range(1,5); j <- Range(1,4) ) {
            println("i = " + i + ",j = " + j )
        }

2. 循环嵌套

for ( i <- Range(1,5) ) {

            for ( j <- Range(1,4) ) {
                println("i = " + i + ",j = " + j )
            }
        }

5. 添加变量

感觉分号后面的条件,直接就是循环里的条件

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5); j = i - 1 ) {
            println("j = " + j )
        }
    }

6. 返回值

使用yield返回

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        val result = for ( i <- Range(1,5) ) yield {
            i * 2
        }
        println(result)
    }
}

7. 循环中断

scala是完全面向对象的语言，所以无法使用break，continue关键字这样的方式来中断，或继续循环逻辑，而是采用了函数式编程的方式代替了循环语法中的break和continue
scala.util.control.Breaks.breakable {
scala.util.control.Breaks.break

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        scala.util.control.Breaks.breakable {
            for ( i <- 1 to 5 ) {
                if ( i == 3 ) {
                    scala.util.control.Breaks.break
                }
                println(i)
            }
        }
    }
}