Scala是什么?

Scala是一种基于函数式编程和面向对象的高级语言。它开发了Spark等大型应用。它和Java有效集成,底层也是支持JVM的。

它有六大特性:

无缝JAVA互操作

Scala在JVM上运行,因此Java和Scala堆栈可以自由混合以实现完全无缝的集成。

类型推断

根据变量自动推断变量类型,我们只需要定义var(可修改)和val(不可修改)即可。

并发与分配

可以对集合数据进行并行操作,有效支持了集群。

特质

将Java风格接口的灵活性和类的功能结合在一起。提供了多重继承。

模式匹配

类似于Java的swatch...case...,但可以同时匹配类型和类型值。

高阶函数

可以将函数作为参数进行传递。

Scala由谁发起?

Scala是由 Martin Odersky 发起,下面是有关他的一些简介。

Martin是EPFL(瑞士领先的技术大学)编程研究组的教授。他在整个职业生涯中一直不断追求着一个目标:让写程序这样一个基础工作变得高效、简单、且令人愉悦。他可能比世界上任何一个人写过更多的Java和Scala代码。他编写了javac,这是大部分Java程序员所使用的编译器。他也编写了Scala编译器scalac,可谓是Scala社区飞速发展的基石。他著有《Programming in Scala》一书,是最畅销的Scala书籍。他曾经就职于IBM研究院、耶鲁大学、卡尔斯鲁厄大学以及南澳大利亚大学。在此之前,他在瑞士苏黎世联邦理工学院追随Pascal创始人Niklaus Wirth学习,并于1989年获得博士学位。

Scala环境准备

安装

  1. 确保您具有Java 8 JDK(也称为1.8)

    • javac -version在命令行上运行,并确保您看到 javac 1.8.___
    • 如果您没有版本1.8或更高版本,请安装JDK
  2. 接下来,下载并安装IntelliJ Community Edition
  3. 然后,在启动IntelliJ之后,您可以按照有关如何安装IntelliJ插件的说明下载并安装Scala插件 (在插件菜单中搜索“ Scala”)。

创建项目时,我们将安装最新版本的Scala。注意:如果要打开现有的Scala项目,则可以 在启动IntelliJ时单击“ 打开”

创建项目

  1. 打开IntelliJ并单击File => New => Project
  2. 在左侧面板上,选择Scala。在右侧面板上,选择“ IDEA”。
  3. 将该项目命名为HelloWorld
  4. 假设这是您第一次使用IntelliJ创建Scala项目,则需要安装Scala SDK。在Scala SDK字段的右侧,单击“ 创建”按钮。
  5. 选择最高的版本号(例如2.13.1),然后单击“ 下载”。这可能需要几分钟,但是后续项目可以使用相同的SDK。
  6. 创建SDK后,您将返回“新建项目”窗口,点击完成

在Linux配置Scala环境

如果要在LInux服务器运行基于scala的应用程序,又不想全量打包的话,这个时候需要手动配置下Linux环境。

选择版本进行下载,注意下载以.tgz结尾的。

在服务器创建一个目录,比如/opt/scala,然后将文件上传到scala目录。

配置环境变量:

$ vim /etc/profile

export SCALA_HOME=/opt/scala/scala-2.12.10
PATH=$SCALA_HOME/bin

最后注意要使用source /etc/profile 重新加载配置文件。

验证是否配置成功:

$ scala

Welcome to Scala 2.12.10 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_221).
Type in expressions for evaluation. Or try :help. scala>

出现类似上面的信息,则证明配置成功了。

Scala之旅

1.基础

1.主方法

主方法是一个程序的入口点。JVM要求一个名为main的主方法,接受一个字符串数组的参数。

通过使用对象,你可以如下所示来定义一个主方法。

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

  }
2.表达式

表达式是可计算的语句。

 println(2 + 5) //7
3.代码块(Blocks)

你可以组合几个表达式,并且用{}包围起来。我们称之为代码块(block)。

代码块中最后一个表达式的结果,也正是整个块的结果。

    println({
val y = 2 * 4
y + 1
})//9
4.函数

函数是带有参数的表达式。

你可以定义一个匿名函数(即没有名字),来返回一个给定整数加一的结果

  (x: Int) =>x * 2

=>左边代表参数,右边是一个包含参数的表达式。

var double= (x: Int) =>x * 2  //注意位置
println(double(1))//2

函数可带有多个参数。

  val add=(x:Int,y:Int)=>x+y
println(add(1,2))//3

或者不带参数。

  var getTheAnswer = () => 11
println(getTheAnswer())//11
5.方法

方法的行为和函数非常类似,但是它们之间还是有一些关键差别。

方法由def进行定义,后面跟方法名,参数,返回值类型,等号和方法体。

    def addOne(x: Int) = x + 1
println(addOne(11))

方法可以接受多个参数列表。

    def addThenMultiple(x: Int, y: Int)(multiplier: Int) = (x + y) * multiplier

    println(addThenMultiple(3, 4)(4))

还可以不带参数。

    def getAnswer()="hello"
println(getAnswer())
6.类

可以用class定义一个类,后面跟它的名字和构造参数。

  class Person(addRess: String, name: String) {
def say(word: String) = {
println(s"${addRess}的${name}说:${word}")
}
}

调用

    val person=new Person("地球","刘星雨")
person.say("我是火星派过来拯救你们的~") //地球的刘星雨说:我是火星派过来拯救你们的~
7.对象

对象是它们自己定义的单实例,你可以看作类的单例。

你可以使用object关键字来定义对象。

object IdFactory {
private var counter = 0 def create() = {
counter += 1
counter
}
}

调用

    println(IdFactory.create()) //1
8.特质(Trait)

特质相当于接口。特质包含某些字段和方法类型。可以组合多个特质。

你可以使用trait关键字来定义特质。

trait Say {
def name = "hello"
}
object Test extends Say {
override def name: String = "world"
def main(args: Array[String]): Unit = { }
}
//其中上面的name方法可以重写,也可以不重写。
9.for循环
for(i<-0 until 10){
println(i)
}

循环0到9

10.Scala调用Java代码

Java代码:

public class Test {
public static void say(){
System.out.println("gogogogo");
}
public void walk(){
System.out.println("走路中...");
} }

Scala代码:

object Test  {

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

    val t3=new Test
t3.walk()
//走路中...
}
}

二. 统一类型

1.Scala类型结构

结构图如下:(箭头之间代表继承关系)

    val list: List[Any] = List(
"hello",
123,
12.11f,
true,
() => "What's happen"
)
2.类型转换

类型转换可以按照下面的方向进行转换:

3.Nothing和Null

Nothing是所有类型的子类型,没有一个值是 Nothing类型的,它的用途之一是非正常终结信号,如抛异常,程序退出或者无限循环。

Null是所有引用类型的子类型,它有一个单例由null所定义。Null主要使得Scala满足和其它JVM语言的 互操作性的。

三.Class

class 类名{实例方法。}

1.类定义

一个最简单的类定义是class+标识符,类名首字母应大写。

class User

但是通常里面都定义方法。

  class User{
def say(name:String)={
println("我叫"+name)
}
}
2.构造器

构造器可以通过一个默认值来拥有可选参数。

  class User(x: Int = 0, y: Int = 0) {
def defaultPoint = {
println("x=" + x + ",y=" + y)
}
}

调用

    val point1=new Point(1,2)
val point2=new Point
point1.defaultPoint //x=1,y=2
point2.defaultPoint //x=0,y=0
3.私有成员Getter和Setter的用法

成员默认是公有的public。使用private访问修饰符可以在类外部隐藏它们。

  class Number(val y: Int) {
private var _x = 0 def x = _x def x_=(newValue: Int) = {
_x = newValue
}
def getNumber = {
println(_x)
}
}

调用

    val number = new Number(2)
number.x = 10
number.getNumber

四.Trait(特质)

特质(Traits)用于在类之间共享接口(Interface)和字段(Fields)。它们类似于Java 8的接口。类和对象(Ojbects)可以扩展特质,但是特质不能被实例化,因为特质没有参数。

1.定义一个特质

最简单的特质就是trait关键字+标识符

trait Color

特质也可以定义泛型

trait Color[C] {
def defaultColor(): C def getColor: C = {
defaultColor()
}
}
2.使用特质
class MyColor extends Color[String] {
override def defaultColor: String = "红色" override def getColor: String = {
defaultColor
} }

调用

    val color = new MyColor();
println(color.getColor) //红色
3.子类型

凡是需要特质的地方,都可以用子类型来替换。

trait Person {
def name: String
} class ZhangSan extends Person {
override def name: String = "张三"
} class LiSi extends Person {
override def name: String = "李四"
}

调用

    val zhangSan = new ZhangSan
val liSi = new LiSi
var person = ArrayBuffer.empty[Person]
person.append(zhangSan)
person.append(liSi)
person.foreach(p => println(p.name))

五.Tuple(元组)

在Scala中元组是一个可以容纳不同类型元素的类。元组是不可变的。

当我们从函数返回多个值时,元组会派上用场。

元组可以创建如下:

 val ingredient=(12,"hello",1.1):Tuple3[Int,String,Double]

这将创建一个包含Int元素,一个String元素和一个Double元素的元组。

Scala包含一系列元素:Tuple1,Tuple10等,直到Tuple22。因此我们创建一个n个 元素(n位于1~22之间)的元组时,Scala基本上从上述一组实例中实例化一个类,使用组成元素进行参数化。

1.访问元素

使用下划线来访问元组中的元素。'tuple._n'取出了第n个元素。

调用上面的实例

println(ingredient._2) //hello
2.解构元素数组
    val ingredient=(12,"hello",1.1)
val(age,word,num)=ingredient
println(age) //12
println(word) //hello

元素数组也可以用于模式匹配。

 val personList = List(("张三", 22), ("李四", 24), ("王五", 20))
  personList.foreach(p => {
p match {
case ("张三", distance1) => println("我是张三") //我是张三
case p if (p._1 == "李四") => println("我是李四") //我是李四
case _ => println("我是无名氏") //我是无名氏
}
})

或者,在'for'表达式中。

    for (x <- personList) {
println(x._1 + "," + x._2)
}

输出:

张三,22

李四,24

王五,20

六.通过混入(mixin)来组合类

当某个特质被用于组合类时,被称为混入。

abstract class A {
val message: String
} class B extends A {
val message = "hello"
} trait C extends A {
def upperMessage = message.toUpperCase()
}
class D extends B with C

调用

    val d = new D
println(d.message)
println(d.upperMessage)

七.高阶函数

高阶函数是指使用其它函数作为参数、或者返回一个函数作为结果的函数。

最常见的一个例子是scala集合类(collections)的高阶函数map

 	val listNum = Seq(1, 2, 3)
val addOne = (x: Int) => x + 1
val result=listNum.map(addOne)
result.foreach(println) //2 3 4
1.强制转换方法为函数

你同样可以传入一个方法作为高阶函数的参数,这是因为Scala编译器会将方法强制转换成一个函数。

 val listNum = Seq(1, 2, 3)
def addTwo(x:Int)=x+2
val addTwoResult=listNum.map(addTwo)
addTwoResult.foreach(println)
2.接收函数作为参数的函数

有的时候你需要将函数作为参数减少代码冗余。

  //定义一个处理方法
private def add(listNum: List[Int], addFunction: Int => Int) = listNum.map(addFunction)
//定义加1计算
def addOne(listNum: List[Int]) = {
add(listNum, x => x + 1)
}
//定义加2计算
def addTwo(listNum: List[Int]) = {
add(listNum, x => x + 2)
}

调用

    val listNum = List(1, 2, 3, 4)
val addOneResult = addOne(listNum)
val addTwoResult = addTwo(listNum)
addOneResult.foreach(println) //2 3 4 5
addTwoResult.foreach(println) //3 4 5 6
3.返回函数的参数

有的时候方法需要返回一个函数

  //定义一个方法让x和y相加,然后返回一个带z参数的函数。
def add(x: Int, y: Int) = (z: Int) => x + y + z

调用

    var addResult = add(1, 2)
var result = addResult(3)
println(result)//6

八.嵌套方法

在Scala中可以嵌套定义方法,例如下面对象提供了一个factorial方法计算给定的阶乘:

  def factorial(x: Int): Int = {
def fact(x: Int, accumulator: Int): Int = {
if (x <= 1) accumulator
else fact(x - 1, x * accumulator)
} fact(x, 1)
}

调用

println("Factorial of 3: " + factorial(3))//6

九.多参数列表

方法可以定义多个参数, 当使用较少的参数列表调用多参数列表的方法时,会产生一个新的函数,该函数接收剩余的参数列表作为其参数。这被称为柯里化

下面是一个例子,在Scala集合 trait TraversableOnce 定义了 foldLeft

def foldLeft[B](z: B)(op: (B, A) => B): B

调用

    val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val res = numbers.foldLeft(1)((m,n)=>m*n)
println(res) //3628800
1.单一的函数参数

在某些情况下存在单一的函数参数时,例如上述例子foldLeft中的op,多参数列表可以使得传递匿名函数作为参数的语法更为简洁。如果不使用多参数列表,代码可能像这样:

    numbers.foldLeft(0,{(m:Int,n:Int)=>m+n})
2.隐式(IMPLICIT)参数

如果要指定参数列表中的某些参数为隐式(implicit),应该使用多参数列表。例如:

def execute(arg: Int)(implicit ec: ExecutionContext) = ???

十.Case Class(案例类)

案例类(Case Class)和普通类差不多,也是通过new创建,但是案例类非常适合不可变的数据。

1.定义一个案例类

一个最简单的案例类由关键字case class

case class Test()

调用

    val test1 = Test//直接调用
val test2 = new Test//使用new调用

可以看到方法是可以直接不通过new进行调用的,这是因为case类默认有个apply方法来负责创建对象。

2.比较
case class Test1(x: Int, y: Int) //定义一个case类
class Test2(x: Int, y: Int) //定义一个普通类

调用

    val test1_1 = Test1(2, 4)
val test1_2 = Test1(2, 4)
if (test1_1 == test1_2) println("两个类数据相同") else println("两个类是数据不相同")//两个类数据相同
val test2_1 = new Test2(2, 4)
val test2_2 = new Test2(2, 4)
if (test2_1 == test2_2) println("两个类数据相同") else println("两个类是数据不相同")//两个类是数据不相同

通过演示可以看到,case 类比较的是具体的值,而普通类比较的是引用。

3.拷贝
case class Test(name: String, age: Int)

调用

    val test = Test("张三", 18)
val test2 = test.copy(name = "李四")//将test值copy给test2,并覆盖name
println(test2.name)//李四
println(test2.age)//18

十一.模式匹配

模式匹配是校验某个值(value)是否匹配一个模式的机制,一个成功的匹配同时会将值解构成其组成成分。它是Java中switch的升级版,同时会代替一系列if/else语句。

1.语法

一个模式匹配包含特定的值,match关键字,以及至少一个case

    var x: Int =11
def matchTest = x match {
case 1 => "one"
case 2 => "two"
case 3 => "three"
case _=>"no"
}
println(matchTest)//no,如果不定义_=>则匹配不到11会报异常。
2.案例类(case classses)的匹配

案例类非常适用于模式匹配。

abstract class Person

case class ZhangSan(msg: String) extends Person //继承Person
case class LiSi(msg: String) extends Person //继承Person

调用

    def talk(person: Person) = person match { //
case ZhangSan(msg) => "张三说" + msg
case LiSi(message) => "李四说" + message
} val zhangSan = new ZhangSan("我吃饭了")
val lisi = new LiSi("一起去打羽毛球")
println(talk(zhangSan))
println(talk(lisi))
3.模式守卫(Pattern gaurds)

为了让匹配更具体,可以加上模式守卫,也就是在case 后面加上if。例如还是上面案例经过简单改造:

    def talk(person: Person) = person match { //
case ZhangSan(msg,isShow) if isShow => "张三说" + msg //加了个控制是否显示的参数
case LiSi(message,isShow) if isShow => "李四说" + message//加了个控制是否显示的参数
case other=>"我什么也没说"
}
    val zhangSan = new ZhangSan("我吃饭了",false)
val lisi = new LiSi("一起去打羽毛球",true)
println(talk(zhangSan))//我什么也没说
println(talk(lisi))//李四说一起去打羽毛球
4.仅匹配类型

上面的匹配的实例,也可以仅仅匹配类型。

case class ZhangSan(msg: String) extends Person //继承Person
case class LiSi(msg: String) extends Person //继承Person
    def talk(person: Person) = person match { //
case p: ZhangSan => "张三说" + p.msg //仅匹配ZhangSan类型
case p: LiSi => "李四说" + p.msg //仅匹配LiSi类型
}
val zhangSan = new ZhangSan("我吃饭了")
val lisi = new LiSi("一起去打羽毛球")
println(talk(zhangSan))//张三说我吃饭了
println(talk(lisi))//李四说一起去打羽毛球
5.密封类

特质(trait)和类(class)都可以用sealed标记为密封的,这意味着所有子类必须和定义类在相同文件中,从而保证所有子类都是已知的。

sealed abstract class Person

十二.Object

Object属于一种单例对象,在Scala中是没有Static类的,Object充当了静态类,里面的方法能直接通过Object名称.方法名调用。

Main方法是定义在Object里面的,Class里面是不能定义Main的,只能进行编译,然后被调用。

object MyObj{静态方法。}

1.定义一个Object对象
object Test {
def googleEmial(userName: String): String = s"${userName}@Google.com"
}
object Test2 {
def main(args: Array[String]): Unit = {
println(googleEmial("zhangsan"))//zhangsan@Google.com
}
}
2.伴生对象

伴生类是存在同名的两个Object和Class,它们的私有成员可以共享。下面举例:

object Person {
private def say(userName: String) = println(userName)
} class Person() {
var userName = "张三 "
val result=Person.say(userName)//这里就可以调用私有方法打印了
}

调用

    val person=new Person
person.result

十三.正则表达式模式

正则表达式是找出数据中指定的字符串。.r方法可使任意字符串变成一个正则表达式。

    val numberPartten = "[0-9]".r

    def numP(str: String) = numberPartten.findFirstMatchIn(str) match {
case Some(_) => println("ok")
case None => println("no")
} numP("12d") //ok ,因为带有数字中的0~9
numP(str = "d") //no,因为

十四.提取器对象

提取器是一个包含unapply方法的单利对象,apply方法就像一个构造器,接收参数并返回方法,反之unapply方法接收一个实例对象然后返回最初创建它所用的参数。提取器常用在模式匹配和偏函数中。

import scala.util.Random

object CustomerID {

  def apply(name: String) = s"$name--${Random.nextLong}"

  def unapply(customerID: String): Option[String] = {
val stringArray: Array[String] = customerID.split("--")
if (stringArray.tail.nonEmpty) Some(stringArray.head) else None
}
} val customer1ID = CustomerID("Sukyoung") // Sukyoung--23098234908
customer1ID match {
case CustomerID(name) => println(name) // prints Sukyoung
case _ => println("Could not extract a CustomerID")
}

十五.for表达式

Scala是一个轻量级的标记方式用来表示列的推导。推导使用形势为for(enumerator) yield e 的for表达式。此处 enumerators 指一组以分号分割的枚举器。一个enumerator要么是 一个产生新变量的枚举器,要么是一个过略器。for表达式在枚举器每一次绑定中都会计算e值,并在循环结束后返回这些组成的序列。

case class Person(name: String, age: Int)

调用

    val personList = List(Person("张三", 11),
Person("李四", 20),
Person("赵六", 66)
)
val filterPerson = for (p <- personList if (p.age > 18))
yield p
filterPerson.foreach(x=>println("name:"+x.name+",age:"+x.age))// name:李四,age:20 name:赵六,age:66

十六.泛型类

泛型类是可以使用类型参数的类。

1.定义一个泛型类
class Person[T] {
def get(t: T) = t
}
2.使用
    val person1 = new Person[String]
val result1 = person1.get("hello")
println(result1)//hello
val person2=new Person[Int]
val result2=person2.get(2)
println(result2)//2

十七.型变

型变是复杂类型的子类型关系与其组件类型的子类型关系的相关性。 Scala支持泛型类的类型参数的型变注释,允许它们是协变的,逆变的,或在没有使用注释的情况下是不变的。 在类型系统中使用型变允许我们在复杂类型之间建立直观的连接,而缺乏型变则会限制类抽象的重用性。

1.协变

子类型转换成父类型就叫协变。

使用注释 +A,可以使一个泛型类的类型参数 A 成为协变。 对于某些类 class List[+A],使 A 成为协变意味着对于两种类型 AB,如果 AB 的子类型,那么 List[A] 就是 List[B] 的子类型。 这允许我们使用泛型来创建非常有用和直观的子类型关系。

考虑以下简单的类结构:

abstract class Animal {
def name: String
}
case class Cat(name: String) extends Animal
case class Dog(name: String) extends Animal
object CovarianceTest extends App {
def printAnimalNames(animals: List[Animal]): Unit = {
animals.foreach { animal =>
println(animal.name)
}
} val cats: List[Cat] = List(Cat("Whiskers"), Cat("Tom"))
val dogs: List[Dog] = List(Dog("Fido"), Dog("Rex")) printAnimalNames(cats)
// Whiskers
// Tom printAnimalNames(dogs)
// Fido
// Rex
}
2.逆变

父类型转换成子类型就叫逆变。

通过使用注释 -A,可以使一个泛型类的类型参数 A 成为逆变。 与协变类似,这会在类及其类型参数之间创建一个子类型关系,但其作用与协变完全相反。 也就是说,对于某个类 class Writer[-A] ,使 A 逆变意味着对于两种类型 AB,如果 AB 的子类型,那么 Writer[B]Writer[A] 的子类型。

考虑在下例中使用上面定义的类 CatDogAnimal

abstract class Printer[-A] {
def print(value: A): Unit
}
class AnimalPrinter extends Printer[Animal] {
def print(animal: Animal): Unit =
println("The animal's name is: " + animal.name)
} class CatPrinter extends Printer[Cat] {
def print(cat: Cat): Unit =
println("The cat's name is: " + cat.name)
} object ContravarianceTest extends App {
val myCat: Cat = Cat("Boots") def printMyCat(printer: Printer[Cat]): Unit = {
printer.print(myCat)
} val catPrinter: Printer[Cat] = new CatPrinter
val animalPrinter: Printer[Animal] = new AnimalPrinter printMyCat(catPrinter)
printMyCat(animalPrinter)
}

这个程序的输出如下:

The cat's name is: Boots
The animal's name is: Boots
3.不变

子类型和父类型不能互相转换叫不变。

class Container[A](value: A) {
private var _value: A = value
def getValue: A = _value
def setValue(value: A): Unit = {
_value = value
}
}
val catContainer: Container[Cat] = new Container(Cat("Felix"))
val animalContainer: Container[Animal] = catContainer
animalContainer.setValue(Dog("Spot"))
val cat: Cat = catContainer.getValue // 糟糕,我们最终会将一只狗作为值分配给一只猫

十八.类型上界

在Scala中,类型参数和抽象类型都可以有个类型约束。这种类型边界在限制取值的同时,还能展露更多信息,比如T<:A,这样声明的类型上界T应该是A的子类。

abstract class Person {//定义父类
def name: String
} abstract class On extends Person {} class ZhangSan extends On {
override def name: String = "张三"
} class LiSi extends On {
override def name: String = "李四"
} class WangWu extends Person {//这个继承的是Person,注意和以上继承的区别
override def name: String = "王五"
} class OnContainer[oc <: On](o: On) {//限制参数范围只能是On的子类 }

调用

    val zhangSan = new OnContainer[ZhangSan](new ZhangSan)
val liSi = new OnContainer[LiSi](new LiSi)
var wangWu = new OnContainer[WangWu](new WangWu) //超出限定,所以会报错

十九.类型下界

类型上界 将类型限制为另一种类型的子类型,而 类型下界 将类型声明为另一种类型的超类型。 术语 B >: A 表示类型参数 B 或抽象类型 B 是类型 A 的超类型。 在大多数情况下,A 将是类的类型参数,而 B 将是方法的类型参数。

二十.内部类

在Scala中一个类可以作为另一个类的内部成员。

class Person() {

  class LiSi() {
def name: String = "我是李四"
} class WangWu() {
def name = "我是王五"
} }

调用

    val person = new Person
val liSi: person.LiSi = new person.LiSi
val wangWu: person.WangWu = new person.WangWu
println(liSi.name)
println(wangWu.name)

二十一.抽象类型(T)

特质(trait)和抽象类(abstract class)可以包含一个抽象类成员,意味着实际类型可由具体实现来确定。

trait Person {
type T
val elements: T
} class ZhangSan extends Person {
override type T = Int
override val elements: Int = 11
}

调用

    val zhangSan = new ZhangSan
println(zhangSan.elements)//11

二十二.复合类型

有时要表名一个类型是其它类型的子类型。这Scala中,这也可以表示成复合类型,及多个类型的交集。

假设我们有两个特质 CloneableResetable

trait Cloneable extends java.lang.Cloneable {
override def clone(): Cloneable = {
super.clone().asInstanceOf[Cloneable]
}
}
trait Resetable {
def reset: Unit
}

现在假设我们要编写一个方法 cloneAndReset,此方法接受一个对象,克隆它并重置原始对象:

def cloneAndReset(obj: ?): Cloneable = {
val cloned = obj.clone()
obj.reset
cloned
}

这里出现一个问题,参数 obj 的类型是什么。 如果类型是 Cloneable 那么参数对象可以被克隆 clone,但不能重置 reset; 如果类型是 Resetable 我们可以重置 reset 它,但却没有克隆 clone 操作。 为了避免在这种情况下进行类型转换,我们可以将 obj 的类型同时指定为 CloneableResetable。 这种复合类型在 Scala 中写成:Cloneable with Resetable

以下是更新后的方法:

def cloneAndReset(obj: Cloneable with Resetable): Cloneable = { //这里就同时拥有clone和reset了。
//...
}

二十三.自类型

自类型用于声明一个特质必须混入其它特质。

trait Person {
def userName: String
} trait Cls {
this: Person =>
def say = println(userName)
} class ZhangSan extends Person with Cls {
override def userName: String = "张三"

调用

    val zhangSan = new ZhangSan
zhangSan.say //张三

二十四.隐式参数

自动匹配隐式类型进行传递。

abstract class Monoid[A] {
def add(x: A, y: A): A
def unit: A
} object ImplicitTest {
implicit val stringMonoid: Monoid[String] = new Monoid[String] {
def add(x: String, y: String): String = x concat y
def unit: String = ""
} implicit val intMonoid: Monoid[Int] = new Monoid[Int] {
def add(x: Int, y: Int): Int = x + y
def unit: Int = 0
} def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
if (xs.isEmpty) m.unit
else m.add(xs.head, sum(xs.tail)) def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3))) // uses IntMonoid implicitly
println(sum(List("a", "b", "c"))) // uses StringMonoid implicitly
}
}

二十五.隐式转换

一个从类型 S 到类型 T 的隐式转换由一个函数类型 S => T 的隐式值来定义,或者由一个可转换成所需值的隐式方法来定义。

隐式转换在两种情况下会用到:

  • 如果一个表达式 e 的类型为 S, 并且类型 S 不符合表达式的期望类型 T
  • 在一个类型为 S 的实例对象 e 中调用 e.m, 如果被调用的 m 并没有在类型 S 中声明。

例如,当调用一个接受 java.lang.Integer 作为参数的 Java 方法时,你完全可以传入一个 scala.Int。那是因为 Predef 包含了以下的隐式转换:

import scala.language.implicitConversions

implicit def int2Integer(x: Int) =
java.lang.Integer.valueOf(x)

二十六.多态方法

Scala可以按值和类型进行参数化。语法和泛型类似。类型参数括在方括号中,而值参数在圆括号中。

def listOfDuplicates[A](x: A, length: Int): List[A] = {
if (length < 1)
Nil
else
x :: listOfDuplicates(x, length - 1)
}
println(listOfDuplicates[Int](3, 4)) // List(3, 3, 3, 3)
println(listOfDuplicates("La", 8)) // List(La, La, La, La, La, La, La, La)

二十七.类型推断

Scala编译器通常可以推断出表达式的类型,因此你不必显示声明它。

1.省略类型
    val name1="张三"//省略类型,编译器会根据"张三"自动推断出是String类型
val name2:String="张三"//不省略类型
2.参数
Seq(1,2,3).map(x=>x*2)
3.何时不要依赖类型推断
  • 通常认为,公公访问的 API应该具有显示类型声明以具有可读性
  • 针对重新复制的 情况
    var test = "hello"
test = 1//会报错

二十八.运算符

在Scala中运算符即是方法。任何具有单个参数的方法都可以用 中缀运算符(我们平时用的最多的那种。)

1.定义和使用运算符
      println(10 + 1)//11
2.优先级
* / %
+ -
:
= !
< >
&
^
|

二十九.传名参数

传名参数仅在被使用时触发实际参数的求值运算。它们与传值参数正好相反。要将一个参数变为传名参数,只需在它的类型前加上=>

def whileLoop(condition: => Boolean)(body: => Unit): Unit =
if (condition) {
body
whileLoop(condition)(body)
} var i = 2 whileLoop (i > 0) {
println(i)
i -= 1
} // prints 2 1

方法 whileLoop 使用多个参数列表来分别获取循环条件和循环体。 如果 condition 为 true,则执行 body,然后对 whileLoop 进行递归调用。 如果 condition 为 false,则永远不会计算 body,因为我们在 body 的类型前加上了 =>

现在当我们传递 i > 0 作为我们的 condition 并且 println(i); i-= 1 作为 body 时,它表现得像许多语言中的标准 while 循环。

如果参数是计算密集型或长时间运行的代码块,如获取 URL,这种延迟计算参数直到它被使用时才计算的能力可以帮助提高性能。

三十.注解

注解将元信息与定义进行关连。例如,方法之前的注解 @deprecated 会导致编译器在该方法被使用时打印警告信息。

object DeprecationDemo extends App {
@deprecated("deprecation message", "release # which deprecates method")
def hello = "hola" hello
}
1.确保编码正确性的注解

如果不满足条件,某些注解实际上会导致编译失败。

import scala.annotation.tailrec

def factorial(x: Int): Int = {

  @tailrec
def factorialHelper(x: Int, accumulator: Int): Int = {
if (x == 1) accumulator else factorialHelper(x - 1, accumulator * x)
}
factorialHelper(x, 1)
}

方法 factorialHelper 使用注解 @tailrec 确保方法确实是尾递归的。 如果我们将方法 factorialHelper 的实现改为以下内容,它将编译失败:

import scala.annotation.tailrec

def factorial(x: Int): Int = {
@tailrec
def factorialHelper(x: Int): Int = {
if (x == 1) 1 else x * factorialHelper(x - 1)
}
factorialHelper(x)
}

我们将得到一个错误信息 “Recursive call not in tail position”.

2.影响代码生成的注解

@inline 这样的注解会影响生成的代码 。

三十一.默认参数值

scala可以定义默认参数值,这样调用者就可以忽略这些默认值的参数。

  def person(name: String = "", age: Int = 18): Unit = {
println(name + "" + age + "岁了")
}

调用

    person("张三")//张三18岁了
person("李四", 11)//李四11岁了

三十二.命名参数

当调用方法时,实际名称可以通过其对应形式的参数的名称来标记。

  def person(name: String = "", age: Int = 18): Unit = {
println(name + "" + age + "岁了")
}

调用

    person(name="王五")//王五18岁了

三十三.包和导入

Scala使用包资源来创建命名空间,从而允许你创建模块化程序。

1.创建包
package users {
package administrators {
class NormalUser
}
package normalusers {
class NormalUser
}
}
2.导入
import endTest._ //导入endTest包下所有成员
import endTest.Test //导入类Test

三十四.包对象

Scala 提供包对象作为在整个包中方便的共享使用的容器。

包对象中可以定义任何内容,而不仅仅是变量和方法。 例如,包对象经常用于保存包级作用域的类型别名和隐式转换。 包对象甚至可以继承 Scala 的类和特质。

按照惯例,包对象的代码通常放在名为 package.scala 的源文件中。

每个包都允许有一个包对象。 在包对象中的任何定义都被认为是包自身的成员。

看下例。 假设有一个类 Fruit 和三个 Fruit 对象在包 gardening.fruits 中;

// in file gardening/fruits/Fruit.scala
package gardening.fruits case class Fruit(name: String, color: String)
object Apple extends Fruit("Apple", "green")
object Plum extends Fruit("Plum", "blue")
object Banana extends Fruit("Banana", "yellow")

包对象与其他对象类似,这意味着你可以使用继承来构建它们。 例如,一个包对象可能会混入多个特质:

package object fruits extends FruitAliases with FruitHelpers {
// helpers and variables follows here
}

系列传送门

入门大数据---Scala学习的更多相关文章

  1. 入门大数据---Flink学习总括

    第一节 初识 Flink 在数据激增的时代,催生出了一批计算框架.最早期比较流行的有MapReduce,然后有Spark,直到现在越来越多的公司采用Flink处理.Flink相对前两个框架真正做到了高 ...

  2. 大数据Hadoop学习之搭建hadoop平台(2.2)

    关于大数据,一看就懂,一懂就懵. 一.概述 本文介绍如何搭建hadoop分布式集群环境,前面文章已经介绍了如何搭建hadoop单机环境和伪分布式环境,如需要,请参看:大数据Hadoop学习之搭建had ...

  3. 大数据spark学习第一周Scala语言基础

    Scala简单介绍 Scala(Scala Language的简称)语言是一种能够执行于JVM和.Net平台之上的通用编程语言.既可用于大规模应用程序开发,也可用于脚本编程,它由由Martin Ode ...

  4. Spark大数据的学习历程

    Spark主要的编程语言是Scala,选择Scala是因为它的简洁性(Scala可以很方便在交互式下使用)和性能(JVM上的静态强类型语言).Spark支持Java编程,但对于使用Java就没有了Sp ...

  5. 入门大数据---Spark整体复习

    一. Spark简介 1.1 前言 Apache Spark是一个基于内存的计算框架,它是Scala语言开发的,而且提供了一站式解决方案,提供了包括内存计算(Spark Core),流式计算(Spar ...

  6. Java开发者想尝试转行大数据,学习方向建议?

      ​前言 相信很多Java开发者都对大数据有一定的了解,随着大数据时代的到来,也有很多Java程序员想要转行大数据.大数据技术中大多数平台使用的都是Java语言,因此,对于大数据技术的学习来说,Ja ...

  7. 布客·ApacheCN 编程/后端/大数据/人工智能学习资源 2020.11

    公告 我们始终与所有创作者站在一起,为创作自由而战.我们还会提供一切必要的技术支持. 我们全力支持科研开源(DOCX)计划.希望大家了解这个倡议,把这个倡议与自己的兴趣点结合,做点力所能及的事情. 我 ...

  8. 布客&#183;ApacheCN 编程/后端/大数据/人工智能学习资源 2020.9

    公告 ApacheCN 项目的最终目标:五年内备份并翻译 Github 上的所有教程(其实快被我们啃完了,剩下的不多了). 警告各位培训班:对 ApacheCN 宣传文章的举报,也将视为对 Apach ...

  9. 布客&#183;ApacheCN 编程/后端/大数据/人工智能学习资源 2020.7

    公告 我们的群共享文件有备份到 IPFS 的计划,具体时间待定. 我们的机器学习群(915394271)正式改名为财务提升群,望悉知. 请关注我们的公众号"ApacheCN",回复 ...

随机推荐

  1. PYTHON-函数调用函数名

    def fun1(x): print('......................') x() def fun2(): print('**********************') fun1(fu ...

  2. SpringCloud Eureka Client和Server侧配置及Eureka高可用配置

    一.Eureka注册中心和客户端配置Demo. 1.Server端 a.使用Idea创建Spring项目,如下所示: b.相关配置 application.yaml配置文件如下: # eureka本身 ...

  3. 震惊!Windows Service服务和定时任务框架quartz之间原来是这种关系……

    过场CG:   接到公司领导的文件指示,“小熊”需要在6月底去海外执行一个行动代号为[定时任务]的营救计划,这个计划关系到公司某个项目的生死(数据安全漏洞),作战部拟定两个作战方案: 方案一:使用务定 ...

  4. Java实现 蓝桥杯VIP 算法训练 最大质因数(暴力)

    试题 算法训练 最大质因数 问题描述 给出N个数字,求出有最大的最大质因数的那个数 输入格式 第一行:一个整数N. 接下来的N行,每行一个整数A_i,表示给出的那N个数字. 输出格式 第一行:一个整数 ...

  5. Java实现 LeetCode 481 神奇字符串

    481. 神奇字符串 神奇的字符串 S 只包含 '1' 和 '2',并遵守以下规则: 字符串 S 是神奇的,因为串联字符 '1' 和 '2' 的连续出现次数会生成字符串 S 本身. 字符串 S 的前几 ...

  6. Java实现 LeetCode 237 删除链表中的节点

    237. 删除链表中的节点 请编写一个函数,使其可以删除某个链表中给定的(非末尾)节点,你将只被给定要求被删除的节点. 现有一个链表 – head = [4,5,1,9],它可以表示为: 示例 1: ...

  7. Java实现 蓝桥杯VIP 算法提高 理财计划

    算法提高 理财计划 时间限制:1.0s 内存限制:256.0MB 问题描述 银行近期推出了一款新的理财计划"重复计息储蓄".储户只需在每个月月初存入固定金额的现金,银行就会在每个月 ...

  8. Java实现 LeetCode 99 恢复二叉搜索树

    99. 恢复二叉搜索树 二叉搜索树中的两个节点被错误地交换. 请在不改变其结构的情况下,恢复这棵树. 示例 1: 输入: [1,3,null,null,2] 1 / 3 \ 2 输出: [3,1,nu ...

  9. java实现奇怪的比赛

    ** 奇怪的比赛** 某电视台举办了低碳生活大奖赛.题目的计分规则相当奇怪: 每位选手需要回答10个问题(其编号为1到10),越后面越有难度.答对的,当前分数翻倍:答错了则扣掉与题号相同的分数(选手必 ...

  10. (四)SQLMap之Tamper篡改脚本的类型、作用、适用场景

    目录结构 一.SQLMap中tamper的简介 1.tamper的作用 2.tamper用法 二.适配不同数据库类型的测试tamper 三.SQLMap中tamper篡改脚本的功能解释 一.SQLMa ...