Scala基础

最新推荐文章于 2025-02-26 16:51:45 发布

原创最新推荐文章于 2025-02-26 16:51:45 发布 · 510 阅读

0 ·

CC 4.0 BY-SA版权

Scala 专栏收录该内容

13 篇文章

订阅专栏

数据类型

Byte(8位)、Short(16位)、Int(32位)、Long(64位)、Double(64位)、Float(64位)、Boolean、Char、String
与Java中的数据类型相对应，除了String是java.lang.String，其它的都是scala包自己的类。

变量定义

Scala有两种变量，val与var。val类似java中的final变量，而var类似java中的非final变量。
定义变量两种方式：val a:Int = 1 或 val a = 1
前者指明了变量类型，也可以不指明，例如后者，Scala会做类型推断。

Object

Scala不能定义静态成员，而是代之以定义单例对象。当单例对象与某一类共享同一个名称时，它就被称为这个类的伴生对象。类和它的伴生对象必须定义在一个源文件里，并可以互相访问对方私有成员。这里定义一个单例ScalaTest来运行第一个scala程序。

object ScalaTest {
    def main(args: Array[String]): Unit = {
        println("Hello Scala!")
    }
}

函数定义

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

例如def定义一个max函数，函数的每个参数都必须带有前缀冒号的类型标注，参数列表后有”: Int”类型标注，这里表示max函数的返回值类型。在Scala中如果函数有返回值，那么函数块中最后一次计算得到的值即返回结果。当然也可以显式的使用return。
有时候Scala编译器需要函数结果类型的定义，比如函数是递归的，那么必须明确的指明函数结果类型。但是针对如上示例，即使不指明结果类型，编译器也能做类型推断。下面的函数定义也是可以的：

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

如果函数没返回值，”=”也可以省去。
传递给方法的任何参数都可以在方法内部使用。Scala里方法参数的一个重要特征是它们都是val，不是var。如果想在方法里面给参数重新赋值，结果是编译失败。

使用数组Array

val strArray = new Array[String](2)
strArray(0) = "hello"
strArray(1) = "zero"

for (i <- 0 to 1) {
println(strArray(i))
}

for (item <- strArray) {
    print(item + " ")
}

这里使用了String数组，当然可以使用如下方式声明数组：

val strArr : Array[String] =  new Array[String](2)

示例中，箭头（<-）左边定义了一个val，而不是var，右边是一个生成器表达式，to是仅带一个Int参数的方法：def to(end: Int)，0 to 1 被转换成方法调用0.to(1)，范围包含了下界(0)和上界(1)。如果用until()方法替换to()方法就可以从范围内排除上界。strArray(0) = "hello"实际上转换成了strArray. update(0, "hello")方法，def update(i: Int, x: String)。而strArray(i)实际上调用了strArray.apply(i): def apply(i: Int)。

数组的声明和定义也可以使用如下简单方式：

val strArr = Array("hello", "zero");

这里实际上是调用了Array的伴生对象（相当于名为Array的静态类）的apply工厂方法（相当于apply静态方法）,即Array.apply("hello", "zero")：

def apply[T: ClassTag](xs: T*): Array[T] = {
    val array = new Array[T](xs.length)
    var i = 0
    for (x <- xs.iterator) { array(i) = x; i += 1 }
    array
}

使用列表List

val one = List(1, 2)
val two = List(3, 4)
val three = one ::: two //连接操作,two.:::(one)
println(three) //List(1, 2, 3, 4)

val four = 5 :: three //three.::(5)
println(four) //(5, 1, 2, 3, 4)

val five = four.+:(6)
println(four) //(5, 1, 2, 3, 4)
println(five) //(6, 5, 1, 2, 3, 4)

val six = four ::: five ::: Nil //Nil是空列表List()的简写
println(six) //(5, 1, 2, 3, 4, 6, 5, 1, 2, 3, 4)

值得注意的是，Scala的scala.List不同于Java的java.util.List，是不可变的对象，如果需要可变的List可使用scala.MutableList。

使用元组Tuple

元组是很用的容器对象，与列表一样，元组也是不可变的，但是与列表不同，元组可以包含不同类型的元素。

val tuple1 = (123, "String");
println(tuple1._1) //123
println(tuple1._2) //String

val tuple2 = (1, 3, "String")
val f = tuple2._1
val (s, t) = (tuple2._1, tuple2._3)
val (_, _, a) = tuple2
println(s) //1
println(a) //String

元组无法用访问列表的方式来访问元组，如tuple1(0)。那是因为列表的apply方法始终返回同样的类型，但是元组里的类型不尽相同。

使用Set和Map

var set1 = Set("zero", "one")
set1 + "two"
println(set1) //Set(zero, one)
set1 += "two"
println(set1) //Set(zero, two, one)

这里的Set是scala.collection.immutable.Set，当需要使用” +=”时变量不能是val只能是var。如果需要可变Set需要引入scala.collection.mutable.Set，而当需要使用” +=”时变量也可以是val。

val set1 = Set("zero", "one")
set1 + "two"
println(set1) //Set(zero, one)
set1 += "two"
println(set1) //Set(zero, two, one)

也可以直接使用显示指明为HashSet： var set1 = HashSet("zero", "one")

val mutableMap = Map[String, String]()
mutableMap += ("a" -> "zero")
mutableMap.+=("b" -> "one")
println(mutableMap) //Map(b -> one, a -> zero)

val map = Map("a" -> "zero", "b" -> "one")
println(map("b")) //one

for ((k, v) <- map)
    println("key = " + k + ", value = " + v)

for ((k, _) <- map) { //_占位符
    println("key = " + k)
}

val map1 = Map("a" -> 3)
val map2 = for ((k, v) <- map1) yield (k, v + 3)
println(map2) //Map(a -> 6)

val map3 = scala.collection.mutable.Map("a" -> 3)
println(map3.getOrElse("a", 4)) //3
println(map3.getOrElse("aa", 4)) //4
map3 += ("b" -> 5)
map3 -= "a"
println(map3) //Map(b -> 5)

使用Zip

val aa = Array("a", "b")
val bb = Array(1, 2)
val pairs = aa.zip(bb)
for ((x, y) <- pairs)
    print(x + "-" + y + "  ") //a-1  b-2

使用String

Scala可以创建多行字符串，并允许在字符串里嵌入双引号。Scala会将三个双引号里的内容保持原样，即保持原始字符串。Scala可以自动把String转换成scala.runtime.RichString,可以使用RichString的stripMargin(),把字符串的缩进去掉（会去掉每行开始的管道符前所有的空白，如果出现在其它地方，就会保留管道符）。

val str = """zero: "HELLO
    ZERO!" """
println(str)
/*zero: "HELLO
              ZERO!"
*/

val str1 = """zero: "HELLO
    |ZERO| !" """.stripMargin
println(str1)
/*zero: "HELLO
  ZERO| !"
*/