本篇博客纯属个人草稿,本着好读书不求甚解的态度,对于自己以往的学习进行简单的整理。博主会在文章开头写明大致脉络,欢迎指正错误,谢谢!
文章目录
1、安装scala与idea编辑器
2、scala基础
3、scala数据结构
4、scala面向对象
5、akka示例
1、安装scala与idea编辑器
操作简单,可自行百度
2、scala基础
2.1 声明变量
object VariableTest {
def main(args: Array[String]) {
//使用val定义的变量值是不可变的,相当于java里用final修饰的变量
val i = 1
//使用var定义的变量是可变得,在Scala中鼓励使用val
var s = "hello"
//Scala编译器会自动推断变量的类型,必要的时候可以指定类型
//变量名在前,类型在后
val str: String = "world"
}
}
2.2 常用类型
scala和Java一样,有7种数值类型 Byte Char Short Int Float Double Boolean
2.3 条件表达式
object ConditionTest{
def main(args: Array[String]) {
val x = 1
//判断x的值,将结果赋给y
val y = if (x > 0) 1 else -1
//打印y的值
println(y)
//支持混合类型表达式
val z = if (x > 1) 1 else "error"
//打印z的值
println(z)
//如果缺失else,相当于if (x > 2) 1 else ()
val m = if (x > 2) 1
println(m)
//在scala中每个表达式都有值,scala中有个Unit类,写做(),相当于Java中的void
val n = if (x > 2) 1 else ()
println(n)
//if和else if
val k = if (x < 0) 0
else if (x >= 1) 1 else -1
println(k)
}
}
2.4 块表达式
object BlockExpressionTest {
def main(args: Array[String]) {
val x = 0
//在scala中{}中课包含一系列表达式,块中最后一个【表达式】的值就是块的值
//下面就是一个块表达式
val result = {
if (x < 0) {
-1
} else if (x >= 1) {
1
} else {
"error"
}
}
//result的值就是块表达式的结果
println(result)
}
}
2.5 循环
object ForTest {
def main(args: Array[String]) {
//for(i <- 表达式),表达式1 to 10返回一个Range(区间)
//每次循环将区间中的一个值赋给i
for (i <- 1 to 10)
println(i)
//for(i <- 数组)
val arr = Array("a", "b", "c")
for (i <- arr)
println(i)
//高级for循环
//每个生成器都可以带一个条件,注意:if前面没有分号
for (i <- 1 to 3; j <- 1 to 3 if i != j)
print((10 * i + j) + " ")
println()
//for推导式:如果for循环的循环体以yield开始,则该循环会构建出一个集合
//每次迭代生成集合中的一个值
val v = for (i <- 1 to 10) yield i * 10
println(v) // Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
}
}
2.6 调用方法和函数
Scala中的+ - * / %等操作符的作用与Java一样,位操作符 & | ^>> <<也一样。只是有
一点特别的:这些操作符实际上是方法。例如:
a + b
是如下方法调用的简写:
a.+(b)
a 方法 b可以写成a.方法(b)
2.7 方法和函数
简记:方法有def 函数时火箭 =>
object MethodAndFunctionTest {
//定义一个方法
//方法m2参数要求是一个函数,函数的参数必须是两个Int类型
//返回值类型也是Int类型
def m1(f: (Int, Int) => Int): Int = {
f(2, 6)
}
//不管是方法还是函数,都必须有数据类型
//定义一个函数f1,参数是两个Int类型,返回值是一个Int类型
val f1 = (x: Int, y: Int) => x + y
//再定义一个函数f2
val f2 = (m: Int, n: Int) => m * n
//main方法
def main(args: Array[String]) {
//调用m1方法,并传入f1函数
val r1 = m1(f1)
println(r1)
//调用m1方法,并传入f2函数
val r2 = m1(f2)
println(r2)
}
}
2.8 方法与函数的互操作
scala> def m1(x:Int,y:Int):Int = x* y
m1: (x: Int, y: Int)Int
scala> val f1 = (x:Int,y:Int)=>x*y
f1: (Int, Int) => Int = $$Lambda$1050/280397810@55f4887d
scala> val f2 = m1 _ //仅需一个 _ 就能够将方法转为lambda函数
f2: (Int, Int) => Int = $$Lambda$1057/358849801@4fba8eec
3、scala数据结构
3.1 数组
3.1.1 定长数组和边长数组
import scala.collection.mutable.ArrayBuffer
object ArrayTest {
def main(args: Array[String]) {
//初始化一个长度为8的定长数组,其所有元素均为0
val arr1 = new Array[Int](8)
//直接打印定长数组,内容为数组的hashcode值
println(arr1)
//将数组转换成数组缓冲,就可以看到原数组中的内容了
//toBuffer会将数组转换长数组缓冲
println(arr1.toBuffer)
//注意:如果new,相当于调用了数组的apply方法,直接为数组赋值
//初始化一个长度为10的定长数组
val arr2 = Array[Int](10)
println(arr2.toBuffer)
//定义一个长度为3的定长数组
val arr3 = Array("hadoop", "storm", "spark")
//使用()来访问元素
println(arr3(2))
//
//变长数组(数组缓冲)
//如果想使用数组缓冲,需要导入import scala.collection.mutable.ArrayBuffer包
val ab = ArrayBuffer[Int]()
//向数组缓冲的尾部追加一个元素
//+=尾部追加元素
ab += 1
//追加多个元素
ab += (2, 3, 4, 5)
//追加一个数组++=
ab ++= Array(6, 7)
//追加一个数组缓冲
ab ++= ArrayBuffer(8,9)
//打印数组缓冲ab
//在数组某个位置插入元素用insert
ab.insert(0, -1, 0)
//删除数组某个位置的元素用remove
ab.remove(8, 2)
println(ab)
}
}
3.1.2 遍历数组
object ForArrayTest {
def main(args: Array[String]) {
//初始化一个数组
val arr = Array(1,2,3,4,5,6,7,8)
//增强for循环
for(i <- arr)
println(i)
//好用的until会生成一个Range
//reverse是将前面生成的Range反转
for(i <- (0 until arr.length).reverse)
println(arr(i))
}
}
3.1.3 数组转换
object ArrayYieldTest {
def main(args: Array[String]) {
//定义一个数组
val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
//将偶数取出乘以10后再生成一个新的数组
val res = for (e <- arr if e % 2 == 0) yield e * 10
println(res.toBuffer)
//更高级的写法,用着更爽
//filter是过滤,接收一个返回值为boolean的函数
//map相当于将数组中的每一个元素取出来,应用传进去的函数
val r = arr.filter(_ % 2 == 0).map(_ * 10)
println(r.toBuffer)
}
}
3.1.4 数组常用算法
scala> val arr = Array(2,5,1,4,3)
arr: Array[Int] = Array(2, 5, 1, 4, 3)
scala> arr.sum
res0: Int = 15
scala> arr.max
res1: Int = 5
scala> arr.sorted
res2: Array[Int] = Array(1, 2, 3, 4, 5)
3.2 映射(字典)
scala> val scores = Map("tom"-> 85,"jerry"->99,"kitty"->90)
scores: scala.collection.immutable.Map[String,Int] = Map(tom -> 85, jerry -> 99, kitty -> 90)
scala> val scores = Map(("tom",85),("jerry",99),("kitty",90))
scores: scala.collection.immutable.Map[String,Int] = Map(tom -> 85, jerry -> 99, kitty -> 90)
scala> scores("jerry") = 80
<console>:13: error: value update is not a member of scala.collection.immutable.Map[String,Int]
scores("jerry") = 80
scala> scores += ("kim"->12)
<console>:13: error: value += is not a member of scala.collection.immutable.Map[String,Int]
Expression does not convert to assignment because receiver is not assignable.
scores += ("kim"->12)
scala> val scores = scala.collection.mutable.Map(("tom",85),("jerry",99),("kitty",90))
scores: scala.collection.mutable.Map[String,Int] = Map(tom -> 85, kitty -> 90, jerry -> 99)
scala> scores("jerry") = 80
scala> scores += ("kim"->12)
res9: scores.type = Map(tom -> 85, kitty -> 90, kim -> 12, jerry -> 80)
3.3 元组
scala> val t = (1,2.0,"tom")
t: (Int, Double, String) = (1,2.0,tom)
scala> t._1
res11: Int = 1
scala> t._3
res12: String = tom
scala> val arr = Array(("tom",85),("jerry",99))
arr: Array[(String, Int)] = Array((tom,85), (jerry,99))
scala> arr.toMap
res13: scala.collection.immutable.Map[String,Int] = Map(tom -> 85, jerry -> 99)
scala> val names = Array("tom","sam","kim")
names: Array[String] = Array(tom, sam, kim)
scala> val scores = Array(10,20,30)
scores: Array[Int] = Array(10, 20, 30)
scala> val ns = names.zip(scores)
ns: Array[(String, Int)] = Array((tom,10), (sam,20), (kim,30))
scala> ns.toMap
res14: scala.collection.immutable.Map[String,Int] = Map(tom -> 10, sam -> 20, kim -> 30)
3.4 集合
Scala的集合有三大类:序列Seq、集Set、映射Map,所有的集合都扩展自Iterable特质在Scala中集合有可变(mutable)和不可变(immutable)两种类型,immutable类型的集合初始化后就不能改变了(注意与val修饰的变量进行区别)
3.4.1 序列
不可变的序列 import scala.collection.immutable._
在Scala中列表要么为空(Nil表示空列表)要么是一个head元素加上一个tail列表。
9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
注意::: 操作符是右结合的,如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil)
object ImmutListTest {
def main(args: Array[String]) {
//创建一个不可变的集合
val lst1 = List(1,2,3)
//将0插入到lst1的前面生成一个新的List
val lst2 = 0 :: lst1
val lst3 = lst1.::(0)
val lst4 = 0 +: lst1
val lst5 = lst1.+:(0)
//将一个元素添加到lst1的后面产生一个新的集合
val lst6 = lst1 :+ 3
val lst0 = List(4,5,6)
//将2个list合并成一个新的List
val lst7 = lst1 ++ lst0 (这个常用)
//将lst0插入到lst1前面生成一个新的集合
val lst8 = lst1 ++: lst0
//将lst0插入到lst1前面生成一个新的集合
val lst9 = lst1.:::(lst0)
println(lst9)
}
}
object MuListTest {
def main(args: Array[String]): Unit = {
//构建一个可变列表,初始有3个元素1,2,3
val lst0 = ListBuffer[Int](1, 2, 3)
//创建一个空的可变列表
val lst1 = new ListBuffer[Int]
//向lst1中追加元素,注意:没有生成新的集合
lst1 += 4
lst1.append(5)
//将lst1中的元素最近到lst0中, 注意:没有生成新的集合
lst0 ++= lst1
//将lst0和lst1合并成一个新的ListBuffer 注意:生成了一个集合
val lst2 = lst0 ++ lst1
//将元素追加到lst0的后面生成一个新的集合
val lst3 = lst0 :+ 5
}
}
4、scala面向对象
4.1 lazy特性
scala> import scala.io.Source
import scala.io.Source
scala> val file = Source.fromFile("./test.csv")
java.io.FileNotFoundException: ./test.csv (No such file or directory)
at java.io.FileInputStream.open0(Native Method)
at java.io.FileInputStream.open(FileInputStream.java:195)
at java.io.FileInputStream.<init>(FileInputStream.java:138)
at scala.io.Source$.fromFile(Source.scala:91)
at scala.io.Source$.fromFile(Source.scala:76)
at scala.io.Source$.fromFile(Source.scala:54)
... 28 elided
scala> lazy val file = Source.fromFile("./test.csv")
file: scala.io.BufferedSource = <lazy>
scala> for (line <- file )
| println(line)
java.io.FileNotFoundException: ./test.csv (No such file or directory)
at java.io.FileInputStream.open0(Native Method)
at java.io.FileInputStream.open(FileInputStream.java:195)
at java.io.FileInputStream.<init>(FileInputStream.java:138)
at scala.io.Source$.fromFile(Source.scala:91)
at scala.io.Source$.fromFile(Source.scala:76)
at scala.io.Source$.fromFile(Source.scala:54)
at .file$lzycompute(<console>:12)
at .file(<console>:12)
... 29 elided
scala>
4.2 类与对象
4.3 继承
5.模式匹配和样例类
6.偏函数
object PartialFuncDemo {
/*被包在花括号内没有match的一组case语句是一个偏函数,它是PartialFunction[A, B]的一个实例,A代表参数类型,B代表返回类型,常用作输入模式匹配*/
def func1: PartialFunction[String, Int] = {
case "one" => 1
case "two" => 2
case _ => -1
}
def func2(num: String): Int = num match {
case "one" => 1
case "two" => 2
case _ => -1
}
def main(args: Array[String]) {
println(func1("one"))
println(func2("one"))
}
}