scala 语法

发表于 | 分类于 | 阅读次数:
字数统计: 1.8k | 阅读时长 ≈ 7

1.类

scala 的类大致可以分为三种，分别是 class ，object ，trait。

class 就是正常的和其他语言一样类

object 是为了弥补 scala 中没有静态属性而产生的单例类型。若使用 object 定义则不需要 new 也能使用里面的方法和属性，这等于就是将类直接实例化以此来顶替 static

trait 差不多就是一个接口。

具体实现代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
object demo2 {
//main 方法必须写在 object 类中
  def main(args: Array[String]): Unit = {
    student("cc",22)

    study.show()
    val p = new play1
    p.show()
  }

//形参中的变量必须注明类型，类型在变量后以:(冒号)分隔
  def student(name:String,age:Int): Unit ={

    println("name:"+name+",age:"+age)

  }

}
//单例类，内部方法可以直接调用
object study{

    def show(): Unit ={
      print("I'm learning")
    }
}

trait play{
    def show()
}
//感觉和接口没啥区别
class play1 extends play{
  override def show(): Unit = {
    print("I'm playing")
  }
}

2.变量

scala 的变量声明分为 val 和 var 两种，var 声明的是可变变量，val 声明的是不可变变量。scala 的变量类型会自动匹配，所有在声明变量时不需要指定变量类型。如果要指定变量类型，则放在变量后以冒号分隔。

3.函数

scala 的函数有以下特点：

(1)如果没有参数，括号可以省略

(2)如果没有返回值，Unit可以省略，Unit代表没有返回值的函数类型

(3)如果函数内部只有一行代码，则大括号可以省略

(4)如果函数最后一行为返回值，则可以没有 return

(5)函数的返回值类型定义和变量相同，都是放在后面用”:”分隔

(6)利用元组可以做到一次返回多个值，元组元素(a)的提取使用：a._1 为第一个元素，以此类推

具体实例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
object demo3 {

  def main(args: Array[String]): Unit = {

    test1
    test2("test2")
    println(test3)
    var a=test4("test4",1)
    println(a._1+","+a._2)

  }
//省略小括号
  def test1: Unit ={
    println("test")
  }
//省略大括号
  def test2(a:String): Unit = println(a)
//省略 return
  def test3:String= "test3"
//返回多个参数
  def test4(x:String,y:Int):(String,Int)=(x+"test4",y+1)

}

4.高阶函数

高阶函数指以函数作为参数或返回值的函数，这很好地体现了 scala 面向对象的特点。高阶函数的具体实例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
object demo4 {
  def main(args: Array[String]): Unit = {


    def fun(x: String): String = {
      x + "fun"
    }
    //fun1接受一个函数f，此函数参数为String，返回值也为String

    def fun1(f: String => String): String = {
    //fun1内部为函数f赋值

      var s = f("scala")
      s + "fun1"
    }

    def fun2(f: String): String = f + "fun2"

    //任何参数为String，返回值为String的函数都可以作为fun1的函数
    val a = fun1(fun)
    println(a)
    //首先将函数fun2传入fun1进行赋值操作，之后将结果传入fun函数进行操作

    println(fun(fun1(fun2)))

  }
}

对比上述语句可以发现=>的作用是指定作为参数的函数输入值类型和函数的返回值的类型。当函数作为参数传递时，传递目标是高级函数则传递的是函数，若传递目标是一般函数则传递的是函数的返回值

5.匿名函数

形如 (x:String)=>x+"demo" 的就是匿名函数，匿名函数可以用来直接给高阶函数传参。

1
2
3
4
5
6
7
8
//fun1接受一个函数f，此函数参数为String，返回值也为String
 def fun1(f: String => String): String = {
 //fun1内部为函数f赋值
 var s = f("scala")
 s + "fun1"
 }
 fun1(x=>x+"匿名函数")
 运行结果为：scala匿名函数fun1

如果匿名函数是作为一个变量传递时需要指定匿名函数内变量类型，如果是直接用来处理数据的则可以不指定数据类型。

6.foreach

使用 foreach 来进行遍历操作，示例如下：

1
2
3
4
5
6
7
8
9
10
val list = List(1,2,3,4,5)
//对数据进行操作，不需要指定变量类型

list.foreach(x=>println(x))
//这里"_"代指遍历时的每个元素

list.foreach(println(_))
//这个好像是 println 函数的特殊性有关，没看源码搞不清

list.foreach(println)

7.reduce

reduce 是一个聚合函数，用于对集合中的数据进行处理，reduce包含reduceLeft和reduceRight，reduce默认使用reduceLeft。所谓聚合就是将集合中的元素按照一定的顺序依次相加。具体示例如下：

1
2
3
val list = List(1,2,3,4,5)
 println(list.reduce(_+_))
 显示结果为：15

8.<- (for循环)

此符号在 Scala 中主要放在循环语句中，用于将集合中的元素映射到变量中，类似于 python 中的 in 。示例如下：

1
2
3
4
5
6
7
//单元素循环
for (x<- 1 to 10)
      println(x)
//多元素循环
for (x <- 1 to 6; y <- 1 to 6) {
      println(x, y)
    }

9.列表操作

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//创建列表
val list = List(1,2,3,4,5,6)
//遍历列表
//1.foreach 无返回值
list.foreach(x=>println(x*2))
//2.map 有返回值
list = list.map(x=>x*2)
println(list)
//获取列表长度
lenth=list.length
//截取列表
    //1.保留列表前两位
    list1 = list.take(2)
    //2.删除列表前两位
    list2 = =list.drop(2)
//反转列表
list3 = list.reverse
//将列表内的元素以指定字符串分割转换成字符串
str = list.mkString(",")
//将字符串转化成列表
list4 = str.split(",").toList

9.1 列表添加元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//由于 scala 中的 List 添加元素是地址添加而不是值添加，因此每次添加都需要重新创建对象，效率不高，
//因此选择使用 ListBuffer 来进行元素添加操作，添加后再将 ListBuffer 转成 List
val lb = new ListBuffer[Int]
//插入一个元素
lb.+=(1)
//插入多个元素
lb.++=(List(2,3,4,5,6))
//从前面插入元素
lb.+=:(7)
//从后面插入元素
lb.+=(0)
//插入到指定位置,第一个参数为插入位置
lb.insert(0,0)
//删除元素,删掉两个0的其中一个
lb.-=(0)
//将ListBuffer转成List
lb.toList

10.map集合

map 集合是存储键值对的数据类型，用法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//变量赋值
val map = Map("java"->"scala","hadoop"->"Hive","Python"->"Scripy")
//根据 key 获取 value
val v = map.get("java") //此处得到的是一个 Option 对象
val a = v.get //此处得到 Option 对象内的值，也就是说根据 key 获取 value需要经过两次处理
//使用上述语句来查找 value 时可能会出现空指针异常，为此可以使用 getOrElse 方法
//该方法根据 key 查找对应 value，若 value 存在则返回 value，若不存在则返回默认值
val b = map.getOrElse("java","默认值")
//遍历 map
map.foreach(kv=>{
    val k=kv._1
    val v=kv._2
    println(s"key:$k,value+$v")
})

11.match 模式匹配

match 和 java 中的 witch 差不多，多用在 map 操作中，防止空指针异常。具体用法如下：

1
2
3
4
5
6
7
8
val map = Map("java"->"scala","hadoop"->"Hive","Python"->"Scripy")

 val a = map.get("java1") match {
      case b:Some[String]=>b.get//如果元素存在则取出值

      case None => "默认值"//如果元素不存在则返回默认值

    }//此处相当于 getOrElse
-----------本文结束感谢您的阅读-----------
0%