从Java到Scala，Scala快速入门(1)

参考

https://www.runoob.com/scala/scala-tutorial.html

目标：对熟悉java语法的人，快速入门到scala

环境安装

1. 安装jdk环境
2. 安装scala : http://www.scala-lang.org/downloads

运行代码

运行方式和java一样，scalac编译，scala运行

object HelloWorld {

   def main(args: Array[String]) = {
      println("Hello, world!") // 输出 Hello World
   }
}

注意

Scala 基本语法需要注意以下几点：

• 区分大小写 - Scala是大小写敏感的，这意味着标识Hello 和 hello在Scala中会有不同的含义。

• 类名 - 对于所有的类名的第一个字母要大写。

• 驼峰命名规则（类名，变量名等）

• 保存文件时，应该保存它使用的对象名称（记住Scala是区分大小写），并追加".scala"为文件扩展名。 （如果文件名和对象名称不匹配，程序将无法编译）。
  示例: 假设"HelloWorld"是对象的名称。那么该文件应保存为’HelloWorld.scala"

• def main(args: Array[String]) - Scala程序从main()方法开始处理，这是每一个Scala程序的强制程序入口部分。

变量

Scala 与 Java有着相同的数据类型，Scala是纯面向对面的，没有基本数据类型int，只有Int类，其他也一样，Int也是有方法调用的

• Unit 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
• Null null 或空引用
• Nothing Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。
• Any Any是所有其他类的超类（类型Object）
• AnyRef AnyRef类是Scala里所有引用类(reference class)的基类

String

在 Scala 中，字符串的类型实际上是 Java String，它的类型为 String (java.lang.String)，它本身没有 String 类。

数组

定义

var z = Array("Runoob", "Baidu", "Google")
var z:Array[String] = new Array[String](3)

访问

z(0) = "Runoob"; z(1) = "Baidu"; z(4/2) = "Google"

遍历

var myList = Array(1.9, 2.9, 3.4, 3.5)
 // 输出所有数组元素
 for ( x <- myList ) {
    println( x )
 }

多维数组

val myMatrix = Array.ofDim[Int](3, 3)

创建范围数组

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,13)//10,11,12
   }
}

定义变量

val a= 1//常量，不可变
var b = "xx" //变量，自动判断类型
var string : String="123"//指定类型

运算符

和java一样，但是没有a++

if else

和java一样

循环语句

有while和do while 和java一样
for循环比较特殊
以下是几种常见的用法
单循环

object Test {
   def main(args: Array[String]) {
      var a = 0;
      // for 循环
      for( a <- 1 to 10){
         println( "Value of a: " + a );
      }
   }
}

双循环

object Test {
   def main(args: Array[String]) {
      var a = 0;
      var b = 0;
      // for 循环
      for( a <- 1 to 3; b <- 1 to 3){
         println( "Value of a: " + a );
         println( "Value of b: " + b );
      }
   }
}

遍历集合

for( x <- List ){
   statement(s);
}

循环+判断

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for 循环
      for( a <- numList
           if a != 3; if a < 8 ){
         println( "Value of a: " + a );
      }
   }
}

for+yeild

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for 循环
      var retVal = for{ a <- numList 
                        if a != 3; if a < 8
                      }yield a

      // 输出返回值
      for( a <- retVal){
         println( "Value of a: " + a );
      }
   }
}

函数（Scala 也是一种函数式语言，所以函数是 Scala 语言的核心。）

语法和java有很大不同

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

例子

object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
}

//可以末尾不加return关键字也可以
object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      sum
   }
}

// 返回类型也可以不写，自动推断
object add{
   def addInt( a:Int, b:Int ) = {
      var sum:Int = 0
      sum = a + b
      sum
   }
}

此外，可变参数，函数传名调用，递归调用，默认参数都很简单

高阶函数

不太懂
https://www.runoob.com/scala/higher-order-functions.html

函数嵌套

我们可以在 Scala 函数内定义函数，定义在函数内的函数称之为局部函数。

object Test {
   def main(args: Array[String]) {
      println( factorial(0) )
      println( factorial(1) )
      println( factorial(2) )
      println( factorial(3) )
   }

   def factorial(i: Int): Int = {
      def fact(i: Int, accumulator: Int): Int = {
         if (i <= 1)
            accumulator
         else
            fact(i - 1, i * accumulator)
      }
      fact(i, 1)
   }
}

匿名函数

def add2 = new Function1[Int,Int]{  
    def apply(x:Int):Int = x+1;  
} 
//箭头左边是参数列表，右边是函数体。
var inc = (x:Int) => x+1 // 这是一个函数变量
var x = inc(7)-1 //调用
var mul = (x: Int, y: Int) => x*y
var userDir = () => { System.getProperty("user.dir") }

偏应用函数

我们可以使用偏应用函数优化以上方法，绑定第一个 date 参数，第二个参数使用下划线(_)替换缺失的参数列表，并把这个新的函数值的索引的赋给变量。以上实例修改如下：

import java.util.Date

object Test {
   def main(args: Array[String]) {
      val date = new Date
      val logWithDateBound = log(date, _ : String)

      logWithDateBound("message1" )
      Thread.sleep(1000)
      logWithDateBound("message2" )
      Thread.sleep(1000)
      logWithDateBound("message3" )
   }

   def log(date: Date, message: String)  = {
     println(date + "----" + message)
   }
}

函数柯里化(Currying)

首先我们定义一个函数:
def add(x:Int,y:Int)=x+y
那么我们应用的时候，应该是这样用：add(1,2)
现在我们把这个函数变一下形：
def add(x:Int)(y:Int) = x + y
那么我们应用的时候，应该是这样用：add(1)(2),最后结果都一样是3，这种方式（过程）就叫柯里化。
其本质是普通函数+匿名函数，2次调用
def add(x:Int)=(y:Int)=>x+y
所以可以分开调用2次也可以

val result = add(1) 
val sum = result(2)

闭包

https://www.runoob.com/scala/scala-closures.html