Scala基本语法

文章目录

1、数据类型
2、变量声明
3、元组Tuple
4、强制类型转换
5、迭代
6、流程控制和循环
7、函数

1、数据类型

Scala有8种数据类型:
Boolean:true/false
Byte:8位,有符号
Short:16位,有符号
Int:32位,有符号
Long:64位,有符号
Char:16位,无符号
Float:32位,单精度浮点数
Double:64位,双精度浮点数

Scala 中所有值都是类对象,所有的类都继承统一的根类 Any

在这里插入图片描述

Null 是所有引用类型的子类型 , nothing是所有类型的子类型.

2、变量声明

val/var 名称：数据类型=值
val（常量声明）:不可变（val修饰的，值不可改变）
var（变量声明）:可变
如果后面赋值了，那么可以不用给定数据类型，scala可以自动推导
内置变量：res0,1,2,3…

scala> val name:String="17"
name: String = 17

scala> var money:Int=10000
money: Int = 10000

scala> name="18" //报错，因为是val修饰的，值不可改变
<console>:12: error: reassignment to val
       name="18"
           ^
scala> money=100
money: Int = 100

scala> val x="zhagnsan"
x: String = zhagnsan    //自动推导出数据类型

scala> 1+2
res0: Int = 3  //内置变量

scala> res0+3
res1: Int = 6

val 和var关键字只标识引用本身是否可以指向另外一个不同的对象,他们并没有表明所引用的对象是否可变. 为了减少可变性引起的bug,应该尽量使用不可变变量。
val 和var在声明变量时都必须初始化。

scala> val array = Array(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)

scala> array(0) = 5

scala> array
res3: Array[Int] = Array(5, 2, 3, 4)

事实上，var 修饰的对象引用可以改变，val 修饰的则不可改变，但对象的状态却是可以改变的

3、元组Tuple

Tuple可以作为集合存储不同类型的数据，初始化实例如下：
Tuple 下标访问从1开始，需要用下划线。

scala> val tuple = (1,3,3.14,"aa")
tuple: (Int, Int, Double, String) = (1,3,3.14,aa)

scala> val third = tuple._3
third: Double = 3.14

给多个变量名赋值，tuple会自行推导数据类型

scala> val (first,second,third,forth) = tuple
first: Int = 1
second: Int = 3
third: Double = 3.14
forth: String = aa

4、强制类型转换

to               tochar      toFloat       toLong          toShort
toBinaryString   to@R_502_4413@   toHexString   toOctalString   toString
toByte           todouble    toInt         toradians

举例：

scala> val a:Int=10
a: Int = 10

scala> a.todouble
res4: Double = 10.0

isinstanceOf 判断对象是否为指定类的对象，如果是的话，则可以使用 asInstanceOf 将对象转换为指定类型

scala> a.asInstanceOf[Int]
res6: Int = 10

scala> a.isinstanceOf[Double]
res7: Boolean = false

scala> a.isinstanceOf[Int]
res8: Boolean = true

5、迭代

to(左闭右闭)

scala> 1 to 5
res12: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)

scala> 1.to(5)  //“.”点，是用来调用函数的
res13: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)

Range（左闭右开）
until（左闭右开）

scala> Range(1,10)
res14: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> Range(1,10,1)  //每间隔1
res17: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> Range(1,10,2)  //2表示步长,步长不能为0
res18: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)

scala> Range(10,1,-1)
res19: scala.collection.immutable.Range = Range(10, 9, 8, 7, 6, 5, 4, 3, 2)

6、流程控制和循环

语法和java一样的，这里不多赘述
流程控制

三种方式
if
if...else
if...else if...else

循环

while
do...while
for
语法结构for (i <- 表达式)

scala> for(i <- 1 to(10)) print(i+"\t")
1       2       3       4       5       6       7       8       9       10

//大于5的偶数
scala> for(i <- 1 to(10) if(i>5) if(i%2==0)) print(i+"\t")
6       8       10

scala> for(i <- 1 to(2) ;j <- 1 to(i)) print(i+j+"\t")
2       3       4

for(i<-1 to 10 if i%2==0){
	println(i)
}

7、函数

定义函数用关键字：def
函数名称：如max，求最大值
两个参数：x:Int,y:Int，这里有两个参数
返回值：若是:Unit表示无返回值，:Int ，这里有返回值，是Int类型
=号：方法体

def max(x:Int,y:Int):Int={
	if(x>y){
		x
	}else{
		y
	}
}

//调用函数
main方法
println(max(1,2))

匿名函数
(形参)=>{函数体}

scala> val y=(text:String) => println(text)
y: String => Unit = <function1>

scala> y("hello,world")
hello,world

偏应用表达式
如果要在字符串里引用变量，要在前面加上“s”，然后变量用$符号

    def age(x:Int)={
      println(s"我今年 $x 岁了") 
    }

有参无返回值

scala> def text1(x:Int):Unit={println("x:"+x)}
text1: (x: Int)Unit

scala> text1(1)
x:1

有参有返回值
如果最后没有 return语句，最后一条表达式的值会自动返回给函数的调用者

scala> def test2(x:Int):Int={x}
test2: (x: Int)Int

scala> test2(2)
rES10: Int = 2

无参无返回值

scala> def test3={println("hello world")}
test3: Unit

scala> test3
hello world

参数有默认值

  def sayName(name: String = "zhangsan"): Unit = {
    println(name)
  }

//调用
main
sayName()  //不传递参数就是默认值
sayName("lisi")  //也可以传递参数值

可变长参数

    def sum(nums: Int*) = {
      var result = 0
      for(num <- nums) {
        result += num
      }
      result
    }

main
println(sum(1,2,3,4))

//：_*  强转符号
println(sum(1 to 5 : _*))

柯里化函数
柯里化函数把具有多个参数的函数转换为一条函数链，每个节点上都是单一函数

def add(x:Int)(y:Int)=x+y
//等价
def add(x:Int,y:Int)=x+y