变量的定义
强类型语言：Java
int num=10;
char ch=”a”;
Double num2=11.11;
弱类型语言：JS、Scala
var x=111;
var y=11.11;
var z=”hello”;
val f=58;
var定义变量；val定义常量
object VariableTest {
def main(args: Array[String]) {
//使用val定义的变量值是不可变的，相当于java里用final修饰的变量
val i = 1
//使用var定义的变量是可变的，在Scala中鼓励使用val
var s = "hello"
//Scala编译器会自动推断变量的类型，必要的时候可以指定类型
//变量名在前，类型在后
val str: String = "world"
}
条件表达式
If
If else（单分支）
If else if else（多分支）
def main(args: Array[String]): Unit = {
val x = 1
//判断x的值，将结果赋给y
val y = if (x > 0) 1 else -1
//打印y的值
println("y=" + y)
//支持混合类型表达式
val z = if (x > 1) 1 else "error"
//打印z的值
println("z=" + z)
//如果缺失else，相当于if (x > 2) 1 else ()
val m = if (x > 2) 1
println("m=" + m)
//在scala中每个表达式都有值，scala中有个Unit类，写做(),相当于Java中的void
val n = if (x > 2) 1 else ()
println("n=" + n)
scala> val y = if(1>1) 1 else "error"
y: Any = error
当y的值类型既可能为Int又可能为String时，它的类型被定义为Any，是Int和String的父类。
scala> val y = if(x>1) 1
y: AnyVal = ()
没有else时，会默认为else （），
y的类型被定义为AnyVal
类型的转换
val num = "11"
val num_int = num.toInt
println(num_int+22)
块表达式
def main(args: Array[String]): Unit = {
val x = 0
val result = {
if(x < 0)
1
else if(x >= 1)
-1
else
"error"
}
println(result)
}
for循环
scala>for (i <- 1 to 10) println(i)
打印1到10
scala> 1 to 10
res6: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala>for (i <- 1 until 10) println(i)
打印1到9
//包含开头不包含结尾
scala> 1 until 10
res0: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)
遍历字符串：
相当于java中的fore
scala> val str = "hello"
str: String = hello
scala> for(c <- str) println(c)
h
e
l
l
通过下标遍历字符串：
scala> for (i <- 0 until str.length) println(str.charAt(i))
h
e
l
l
o
遍历数组：
scala> val arr = Array(1,2,3,4,5,6)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> for(a <- arr) println(a)
1
2
3
4
5
6
通过下标遍历数组：
scala> for(i <- 0 until arr.length) println(arr(i))
1
2
3
4
5
6
while循环
while循环：基本语义与Java相同。
var n = 10
while(n > 0) {
println(n)
n -= 1
}
do while循环
至少被执行一次。
var n =1
do{
println(n)
n+=2
}while(n<10)
方法的定义
定义一个m方法：
scala> def m(x : Int,y : Int):Int = { x + y }
m: (x: Int, y: Int)Int
scala> m(10,20)
res14: Int = 30
可以不写返回值类型，会自动将方法体的最后一行作为返回值，并推导出其类型。
但是递归方法一定要写返回值类型。
scala> def add(x : Int,y: Int)= x + y
add: (x: Int, y: Int)Int
scala> add(20,20)
res16: Int = 40
如果显示的指明了没有返回值，即使方法体的最后一行有返回值，也不会有值返回。
def func1(x:Int,y:Int):Unit = {
x+y
}
定义无参的方法：
scala> def sayHi(){println("Hi~")}
sayHi: ()Unit
方法名 参数 返回值类型
scala> sayHi()
Hi~
scala> sayHi
Hi~
无返回值的三种定义方法：
scala> def sayHi():Unit = {println("Hi~")}
sayHi: ()Unit
可以不用写Unit
scala> def sayHi() = {println("Hi~")}
sayHi: ()Unit
可以不写=
scala> def sayHi(){println("Hi~")}
sayHi: ()Unit
如果方法中没有参数的话。那么小括号是可以省略的，但是调用的时候，不能加括号了
def m = println("hello world!")
变长参数：
在Scala中，有时我们需要将方法定义为参数个数可变的形式，则此时可以使
用变长参数定义方法。
def sum(nums: Int*) = {
var res = 0
for (num <- nums)
res += num
res
}
sum(1, 2, 3, 4, 5)
函数的定义
函数里的参数最多只能放22个。要使用更多的话，可以使用变长参数。
scala> val f1 = (x:Int,y:Int) => x+y
f1: (Int, Int) => Int = <function2>
scala> f1(10,10)
res19: Int = 20
匿名函数：
scala> (x:Int,y:Int) => x+y
res20: (Int, Int) => Int = <function2>
匿名函数用的最多的就是直接放在方法里面
无参函数
scala> () => 2
res12: () => Int = <function0>
定义函数的方式：
scala> val f1 = (x:Int,y:Int) => x+y // =>左边是参数，右边是函数体
f1: (Int, Int) => Int = <function2>
scala> val f2:(Int,Int) => Int = {(x,y) => x+y} //参数类型，返回值类型，参数，函数体
f2: (Int, Int) => Int = <function2>
一个参数的函数
scala> val f1 : Int => Double = { x => x.toDouble }
f1: Int => Double = <function1>
scala> val f2 = (x:Int) => x.toDouble
f2: Int => Double = <function1>
空参函数
scala> val f1 = () => println("hello")
f1: () => Unit = <function0>
scala> f1()
hello
函数的说明
scala> val f = (x:Int) => x*x
f: Int => Int = <function1>
scala> f(5)
res22: Int = 25
scala> val arr = Array(1,2,3,4,5,6)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.map(f)
res23: Array[Int] = Array(1, 4, 9, 16, 25, 36)
传入匿名函数：
scala> arr.map((x : Int) => x*x)
res24: Array[Int] = Array(1, 4, 9, 16, 25, 36)
简单的函数：
scala> arr.map(x => x*x)
res25: Array[Int] = Array(1, 4, 9, 16, 25, 36)
更简单的函数：
scala> arr.map(_ * 10)
res26: Array[Int] = Array(10, 20, 30, 40, 50, 60)
求奇数
scala> val f = (x:Int) => x%2!=0
f: Int => Boolean = <function1>
scala> arr.filter(f)
res27: Array[Int] = Array(1, 3, 5)
简单的：
scala> arr.filter(x => x%2!=0)
res28: Array[Int] = Array(1, 3, 5)
更简单的：
scala> arr.filter(_%2!=0)
res29: Array[Int] = Array(1, 3, 5)
object HelloScala {
def main(args: Array[String]): Unit = {
val arr = Array(1,2,3,4,5,6)
val r = arr.map(x => x*x)
println(r.toBuffer)
}
}