Scala笔记

解压文件

vim /etc/profile

source /etc/profile

对应版本下载plugins

install plugins from disk

重启，创建maven项目

add framework support

静态语言与动态语言

静态类型语言与动态类型语言

解释型语言与编译型语言

代码示例

使用object关键字声明

声明main方法

基本语法

注意事项

Any

图示

规则

自动类型转换（implicit conversion）

强制类型转换

整数除只保留整数部分

==

!=

<

>

<=

>=

True Or False

if-else

类Switch分支

嵌套分支

Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容.

Scala中没有三元运算符

基本循环

循环守卫

循环返回值

多行逻辑小括号变大括号

循环步长

while循环中的Break操作

def 函数名（参数列表） ： 函数返回值类型 = {

函数体

}

def f2(name : String) : String = {

"Name :" + name

}

def f3(name : String) = {

"Name :" + name

}

def f4(name : String) = "Name" + name

def f5 = "abc"

如果函数的参数列表已声明，那么调用时可以使用小括号，也可以不使用

如果函数的参数列表未声明，那么调用时不能使用小括号

def f6() : Int = {

return 2

}

def f7() : Unit = {

return 2

}

def f8(){

return 3

}

()->{println("xxxxxxxx")}

val f9 = (i : Int)=>{println("xxxxx")}

柯里化指的是将原来接受多个参数的函数变成新的接受一个参数的函数的过程,

新函数的参数接受原来的第二个参数为唯一参数

如果有n个参数, 就是把这个函数分解成n个新函数的过程

如果函数中使用外部变量，为了防止变量数据丢失，将变量包含到函数的内部，形成闭合的效果，形成闭包，改变变量的生命周期

闭包就是一个函数和与其相关的引用环境（变量/值）组合的一个整体(实体)。

代码实例

函数自己调用自己

函数应该有跳出递归的逻辑

函数调用自身的深度不要太深

递归函数在调用时，需要传递的参数有规律

Scala中，递归函数不能省略返回值类型

try {

val r = 10 / 0

} catch {

case ex: ArithmeticException=> println(“捕获了除数为零的算术异常")

case ex: Exception => println("捕获了异常")

} finally {

// 最终要执行的代码

println("scala finally...")

}

当使用偏函数时，会遍历集合的所有元素，编译器执行流程时先执行isDefinedAt()如果为true ,就会执行 apply, 构建一个新的Int 对象返回

执行isDefinedAt() 为false 就过滤掉这个元素，即不构建新的Int对象.

完整版

简化版

参数是函数

函数参数没有输入值也没有返回值

def myRunInThread(f1: => Unit): Unit = { 11; new Thread {11; override def run(): Unit = {11; f1 11; }11; }.start()11;}11;myRunInThread { //说明11; println("干活咯！5秒完成...") Thread.sleep(5000)11; println("干完咯！")11;}

Java面向对象编程

Scala面向对象编程

Java包的作用

Scala包的作用

域名的反写 + 项目名 + 模块 + 程序类型

import java.util._

import java.util.{ArrayList,HashMap}

import java.util

import sacala.collection.mutable._

import java.util.{HashMap=>_,_}

import java.util.{HashMap=>JavaHashMap,_}

new _root_.java.util.HashMap

属性

方法

class 类名(形参列表) { // 主构造器

// 类体

def this(形参列表) { // 辅助构造器

}

def this(形参列表) { //辅助构造器可以有多个...

}

}

定义

细节

定义

实例

子类与父类

动态绑定机制

抽象类

匿名子类

分支主题

在伴生对象中定义apply方法，可以实现： 类名(参数) 方式来创建对象实例.

Scala中伴生对象采用object关键字声明，伴生对象中声明的全是 "静态"内容，可以通过伴生对象名称直接调用。

伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。

伴生对象中的属性和方法都可以通过伴生对象名直接调用访问

从语法角度来讲，所谓的伴生对象其实就是类的静态方法和静态变量的集合

从技术角度来讲，scala还是没有生成静态的内容，只不过是将伴生对象生成了一个新的类，实现属性和方法的调用。

从底层原理看，伴生对象实现静态特性是依赖于 public static final MODULE$ 实现的。

伴生对象的声明应该和伴生类的声明在同一个源码文件中(如果不在同一个文件中会运行错误!)，但是如果没有伴生类，也就没有所谓的伴生对象了，所以放在哪里就无所谓了。

如果 class A 独立存在，那么A就是一个类， 如果 object A 独立存在，那么A就是一个"静态"性质的对象[即类对象], 在 object A中声明的属性和方法可以通过 A.属性 和 A.方法 来实现调用

trait 特质名 {

trait体

}

如果类存在父类，首先初始化父类

如果类存在特质，那么会首先初始化特质

特质初始化后，才会进行类的初始化

父类初始化完成后，类存在多个特质，从左到右依次初始化

执行特质中的功能时，从右往左

特质只会初始化一次

动态混入是Scala特有的方式（java没有动态混入），可在不修改类声明/定义的情况下，扩展类的功能，非常的灵活，耦合性低

在构建对象时混入特质，扩展对象的功能

implicit def f1(d: Double): Int = {11; d.toInt11;}

object Scala01 {

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

val num1 : Int = 3.5

val num2 : Int = 4.6

println(num1)

println(num2)

}

}

class MySQL{

def insert(): Unit = {

println("insert")

}

}

class DB {

def delete(): Unit = {

println("delete")

}

}

implicit def addDelete(mysql:MySQL): DB = {

new DB //

}

val mysql = new MySQL

mysql.insert()

mysql.delete()

扩展功能

其所带的构造参数有且只能有一个

隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是 顶级的(top-level objects)。

隐式类不能是case class（case class在后续介绍 样例类）

作用域内不能有与之相同名称的标识符

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

//DB1会对应生成隐式类

implicit class DB1(val m: MySQL1) {

def addSuffix(): String = { //方法

m + " scala"

}

}

val mysql1 = new MySQL1

mysql1.sayOk()

println(mysql1.addSuffix())

}

class MySQL1 {

def sayOk(): Unit = {

println("sayOk")

}

}

可变不可变

三大类

访问通过_顺序号，顺序号从1开始

遍历

数组-定长数组（声明泛型）

数组-变长数组(声明泛型)

定长变长数组转换

Scala数组和Java数组的转换

Scala的List可以直接存放数据，就是一个object

空集合的运用

List元素的追加

ListBuffer

基本概述

创建

基本概述

基本概述

创建

实例应用1

实例应用2

实例应用

定义解释

在使用时map会将一个长度为N的RDD转换为另一个长度为N的RDD；而flatMap会将一个长度为N的RDD转换成一个N个元素的集合，然后再把这N个元素合成到一个单个RDD的结果集。

可以理解为flatmap比map多了一个flatten操作

图示

代码示例

val list = List(1,20,30,4,5)

println(list.reduceLeft((x, y) => (x + y)))

println(list.reduceLeft(_ + _))

fold函数将上一步返回的值作为函数的第一个参数继续传递参与运算，直到list中的所有元素被遍历。

foldLeft /:

foldRight :\

对某个集合的所有元素做fold操作，但是会把产生的所有中间结果放置于一个集合中保存

stream是一个集合。这个集合，可以用于存放无穷多个元素，但是这无穷个元素并不会一次性生产出来，而是需要用到多大的区间，就会动态的生产，末尾元素遵循lazy规则(即：要使用结果才进行计算的) 。

case中对象的unapply方法(对象提取器)返回Some集合则为匹配成功

返回none集合则为匹配失败

val namesString = "Alice,Bob,Thomas"

namesString match {

case Names(first, second, third) => {

println("three people's names")

// 打印字符串

println(s"$first $second $third")

}

case _ => println("nothing matched")

}

[T <: A]

[T >: A]