Scala学习笔记-0-语法规则&与Java的异同

目录

• 基本概念
• 附代码

基本概念

• 既面向函数又面向对象
• scalac对应javac，scala对应java，同时支持常用的java启动参数
• void对应Unit
• 支持交互式命令，类似python和node.js
• 变量定义

// 使用type inference
val msg = "Hello,World"
// 直接定义
String msg = "Hello,World"

• 函数定义

def max(a: Int, b: Int): Int = {
  if (a > b) {
    a
  } else {
    b 
  }
}

• 每个 Scala 表达式都有返回结果，因此函数返回结果无需使用 return 语句，函数的最后一个表达式的值就可以作为函数的结果作为返回值。在 Scala 代码应当尽量避免使用 return 语句。
• Scala 不支持＋＋i,i++ 运算符，因此需要使用 i＋＝1 来加一。类似python
• Scala访问数组的语法是使用()而非[]
• Scala常用的循环foreach、for

args.foreach(arg => println(arg))
// 如果一个函数只有一个参数并且只包含一个表达式，那么你无需明确指明参数
args.foreach( println)
for (arg <-args)
  println(arg)

• 类型参数，类似于java的泛型

val greetStrings =new Array[String](3)

• Scala 的一个基本规则，如果一个方法只有一个参数，你可以不用括号和. 来调用这个方法。

val greetStrings = new Array[String](3)
greetStrings(0) = "Hello"
greetStrings(1) = ","
greetStrings(2) = "world!
"
for(i <- 0 to 2)
  print(greetStrings(i))
// 这里的 0 to 2, 其实为（0）.to(2) 调用的为整数类型的 to 方法，to 方法使用一个参数。

• Scala 中所有的基本数据类型也是对象（和 Java 不同），因此 0 可以有方法。(实际上 Scala 中表达式 1+2,最终解释为 (1).+(2) + 也是 Int 的一个方法)
• 和 Java 不同的是，Scala 对方法的名称没有太多的限制，你可以使用符合作为方法的名称。
• Array数组

// 数组在 Scala 中并不某种特殊的数据类型，和普通的类没有什么不同
val greetStrings = new Array[String](3)

// 这里的greetStrings(1)其实是greetStrings.apply(i)
val a = greetStrings(1)

// 下面这一行其实是greetStrings.update(1, "hello scala")
greetStrings(1) = "hello scala"

// 快速初始化
val greetStrings = Array("Hello",",","World
")
// 本质是
val greetStrings = Array.apply("Hello",",","World
")

• Lists--不可以修改的序列（元素不可以修改，但是可以追加）

val oneTwo = List(1,2)
val threeFour = List(3,4)
// 此处创建了新的 List 对象 oneTwoThreeFour 来保存两个列表连接后
val oneTwoThreeFour = oneTwo ::: threeFour
println (oneTwo + " and " + threeFour + " were not mutated.")
println ("Thus, " + oneTwoThreeFour + " is a new list")

// List 也提供了一个::方法用来向 List 中添加一个元素
// Scala 中规定所有以：开头的操作符都是右操作符，因此::方法（操作符）是右操作符
val oneTowThree = 1 :: 2 ::3 :: Nil
// 等同于
val oneTowThree =  Nil.::(3).::(2).::(1)

• List高级用法--head, last,length, reverse,tail
  todo
• Tuples元组

// Scala 中另外一个很有用的容器类为 Tuples，和 List 不同的 Tuples 可以包含不同类型的数据，而 List 只能包含同类型的数据。Tuples 在方法需要返回多个结果时非常有用。
// 元组的索引从 1 开始
val pair=(99,"Luftballons")
println(pair._1)
println(pair._2)
// 目前 Scala 支持的元祖的最大长度为 22

• Sets 和 Maps
  

var jetSet = Set ("Boeing","Airbus")
jetSet +="Lear"
println(jetSet.contains("Cessna"))
// 缺省情况 Set 为 Immutable Set，如果你需要使用可修改的集合类（ Set 类型），你可以使用全路径来指明 Set，比如 scala.collection.mutalbe.Set 。

val romanNumeral = Map ( 1 -> "I" , 2 -> "II",
  3 -> "III", 4 -> "IV", 5 -> "V")
println (romanNumeral(4))

• 函数编程风格
  一个简单的原则，如果代码中含有 var 类型的变量，这段代码就是传统的指令式编程，如果代码只有 val 变量，这段代码就很有可能是函数式代码，因此学会函数式编程关键是不使用 vars 来编写代码。
• 引入多个类，Scala 使用 “_” 而非 “*”
• 读取文件

import scala.io.Source
if (args.length >0 ){
  for( line <- Source.fromFile(args(0)).getLines())
    println(line.length + " " + line)
}
   else
      Console.err.println("Please enter filename")

• Scala 的缺省修饰符为 public
• val不可以修改参数的值，区别于var

附代码

package day01

object HelloWord {

  // 入口函数
  def main(args: Array[String]): Unit = {
    println("Hello Word!")

    // 不可修改的变量
    val a = 1

    // 可以修改的变量
    var b = 1

    // 不支持++b b++等操作
    b += 1

    // 只有一个参数的方法，调用可以不加.和括号
    HelloWord test "6666666666"

    // 定义数组，带类型参数（类似泛型）
    var greetStrings = new Array[String](10)

    // 快速初始化
    greetStrings = Array("Hello", ",", "World
")

    // 访问数组
    println(greetStrings(2))
    // 本质
    println(greetStrings.apply(2))

    // 设置数值
    greetStrings(1) = "0"
    // 本质
    greetStrings.update(1, "0")

    // 循环
    greetStrings.foreach(println)
    for (arg <- greetStrings)
      println(arg)

    // Scala 中所有的基本数据类型也是对象（没有int和Integer的区分），所以即使是数字1也有方法
    println(1.+(1))

    // Scala对方法名没有限制
    println(HelloWord +++ 0)

    // List不可修改的序列（初始化之后将无法修改，也无法添加删除数据）
    val l1 = List(1, 2, 3)
    println(l1)

    // List连接（产生的是新对象）
    println(l1 ::: l1)

    // Scala规定所有以:开头的方法都是右操作方法（右边的对象来调，包括自定义方法也适用这个规则）
    val l2 = 1 :: 2 :: 3 :: 4 :: Nil
    println(l2)

    // Tuples元组，可以用来保存不通的数据类型，最大长度22
    val t1 = (1, "Hello", 1.0, HelloWord, null, None)
    println(t1)

    // Sets 和 Maps，都有两种类型，可变与不可变
    // 缺省情况 Set 为 Immutable Set，如果你需要使用可修改的集合类（ Set 类型），你可以使用全路径来指明 Set，比如 scala.collection.mutable.Set 。
    var jetSet = Set("Boeing", "Airbus")
    jetSet += "Lear"
    println(jetSet.contains("Cessna"))

    // 同上
    val romanNumeral = scala.collection.mutable.Map(1 -> "I", 2 -> "II",
      3 -> "III", 4 -> "IV", 5 -> "V")
    romanNumeral(9) = "AAA"
    println(romanNumeral(4))
    println(romanNumeral)

    var m1 = scala.collection.mutable.Map("aaa" -> "AAA")
    println(m1)
    m1 = scala.collection.mutable.Map()
    println(m1)
  }

  // 定义函数
  def sum(a: Int, b: Int): Int = {
    // 不需要返回值，函数的最后一个表达式的值就可以作为函数的结果作为返回值，尽量不要用return
    a + b
  }

  def test(a: String): Unit = {
    println(a)
  }

  // Scala对方法名没有限制
  def +++(a: Int): Int = {
    a + 3
  }
}