参考
https://www.runoob.com/scala/scala-tutorial.html
目标:对熟悉java语法的人,快速入门到scala
运行方式和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
也是有方法调用的
在 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++
和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 );
}
}
}
语法和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)
}
}
首先我们定义一个函数:
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