Scala学习继续篇
常用集合
--------------
1.list
val list = List(1,2,3,4)
list.head //1
list.tail //List(2,3,4)
list.tail.tail.tail.tail//Nil
def sum(list:List[Int]):Int = if (list == Nil) 0 else list.head + sum(list.tail)
sum(1::2::3::4::Nil) //10
Array(1,2,3).toList ::: list //
list.slice(1,3) //[1,3)
list.reverse() //倒序
2.Set
不重复,默认使用hash
val s1 = Set(1,2,3)
val s2 = Set(2,3,4)
s1.intersect(s2) //交集, s1 & s2 (2,3)
s1.union(s2) //并集 ,s1 + s2
s1.diff(s2) //差集 , s1 -s2
s1 | s2 //并集
s1 & s2 //交集
s1 &~ s2 //差集
s1 ++ s2 //并集
s1 -- s2 //差集
3.集合的化简与折叠
3.1)reduceLeft
val list = List(1,2,3,4)
list.reduceLeft(_+_)
3.2)foldLeft(init)(op)
/:
和reduceLeft相似,但是带有一个初始值。
list.foldLeft(10)(_-_)
(10 - 1) - 2 ) - 3 4 = 0
3.3)foldRight
:\
foldRight(10)(_-_)
1 2 3 4 10 //8
1 2 3 10 4 //-4
3.4)zipWithIndex
list.map(_ * 100).zipWithIndex
4.并行集合
val list = (1 to 10).toList
list.map(e=>{
val tname = Thread.currentThread().getName()
println(tname + " : " + e)
e * 2
})
list.par.map(e=>{
val tname = Thread.currentThread().getName()
println(tname + " : " + e)
e * 2
})
模式匹配和样例类
-----------------
1.模式匹配
等价于java的switch case
val c = '+'
c match{
case '+' => println(111)
case '-' => println(222)
case _ => println(0)
}
//匹配常量
val color = Color.RED
val x = color match{
case Color.RED => 1
case Color.GREEN=> 2
case _ => 0
}
println(x)
//守卫条件
val x = c match{
case '+' => 1
case '-' => -1
case _ if Character.isDigit(c) => 'N'
case _ => 'X'
}
//使用变量
val str = "hello"
str(0) match{
case '+' => println(1)
case '-' => println(2)
case ch => println(ch)
}
//常量问题,大写会识别成常量,
//小写是变量,如果让小写也是常量,使用``标出
val str = "hello"
val ch = 'h'
str(0) match{
case '+' => println(1)
case '-' => println(2)
case `ch` => println(`ch`)
}
//类型匹配
val x:Any = "abc"
x match{
case a:Int => println(1)
case a:String => println(2)
case a:Float => println(3)
case _ => println(0)
}
//匹配数组
val arr = Array[Int](1,2,3)
arr match{
//case Array(0) => println(1) //精确匹配(0)
case Array(x,y) => println(2) //匹配2个元素
case Array(0,_*) => println(3) //匹配0开始
case _ => println(4) //
}
//匹配集合
val list = 0::1::2::Nil
list match{
case 0::Nil => println(1) //0
case x::y::Nil => println(2) //x,y
case 0::tail => println(3) //0,...
case _ => println(4)
}
//匹配元组
val t = (1,2)
t match{
case (0,_) => println(1)
case (y,0) => println(2)
case _ => println(3)
}
//提取器unapply / unapplySeq
val arr = Array(1,2,3)
arr match{
case Array(x,y,z)=> printf("x=%d,y=%d,z=%d" , x , y ,z)
case _ => println("0")
}
//多个变量声明模式
val (x,y,z) = (1,2,3)
x = 1
y = 2
z = 3
//抽取前两个元素依次赋值
val Array(x,y,_*) = Array(1,2,3,4,5)
val map = Map(1->"tom1" , 2->"tom2",3->"tom3")
for((k,_) <- map) println(k)
for(t <- map) println(t._1)
样例类
------------------
特殊类,经过了优化处理,经常用于模式匹配。
好处是内置实现了众多scala常用的功能,比如serializable、
compare、apply、unapply
abstract class Dog
case class Jing8(var name:String) extends Dog
case class Shapi(var name:String) extends Dog
$scala>:javap -p Dog
$scala>:javap -p Jing8
$scala>:javap -p Jing8$
$scala>:javap -p Shapi
$scala>:javap -p Shapi$
val jing8 = Jing8("ttt")
val Jing8(y) = jing8
val d:Dog = Jing8("tom")
d match{
case Jing8(n) => println("jing8: " + n)
case Shapi(n) => println("Shapi : " + n)
case _ => println("nothing")
}
密封样例类
-------------------
必须将样例子类和父类定义在一个scala文件中。
sealed abstract class Dog
case class Jing8(var name:String) extends Dog
case class Shapi(var name:String) extends Dog
偏函数
-------------------
包含在{}内的一组case语句是偏函数(PartialFunction[A,B])。
该函数有两个方法,apply()对匹配到的模式进行计算,isDefinedAt()
判断定义了指定的情况。
让模式匹配语句重用成为可能。
val f :PartialFunction[Char , Int] = {
case '+' => 1
case '-' => -1
case c if (Character.isDigit(c)) => 9
}
f('+') //1
f('-') //-1
f('1') //9
f('x') //异常
f.isDefinedAt('x')
f.apply('+')
f('+')
尾递归
-------------------
可以进行优化,将递归转换成循环实现,避免栈的溢出。
def sum(args:Seq[Int]):BigInt = {
if(args.isEmpty) 0 else args.head + sum(args.tail)
}
sum(1 to 10000) //溢出
//实现了尾递归
def sum2(x:Seq[Int] , part :BigInt):BigInt = {
if(x.isEmpty) part else sum2( x.tail ,x.head + part)
}
sum2(1 to 100000 , 0) //ok
def out(str:String):Unit= {
out(str)
println(str)
}
泛型
-------------------
1.类上泛型
class Pair[T,S](var first:T , var second:S)
val p = new Pair[Int,String](100,"tom")
val p = new Pair(100,"tom")
2.方法上泛型
def mid[T](arr:Array[T]) = arr(arr.length / 2)
mid[Int](Array(2,3,4))
mid(Array(2,3,4))
3.类型上限界定
class Pair[T <: Comparable[T]] (var a:T ,var b:T)
val p = new Pair("100","100")
4.类型下限界定
class Pair[T >: Jing8](var a:T ,var b:T)
???
5.视图界定
class Pair[T <% Comparable[T]] (var a:T , var b:T)
val p = new Pair(100,200)
6.型变
6.1)协变
class Pair[+A]
6.2)逆变
class Pair[-A]
隐式转换
------------------
1.隐式转换函数
object Utils{
implicit def int2Fraction(n:Int) = {
Fraction( n, 1)
}
}
import Utils._
3 * Fraction(1,2)
2.隐式参数
def dec(str:String)(implicit pre:String)
3.隐式值
implicit val xx:String = "<<<"
def dec("hello")
4.SAM
single abstract method
json
------------------
{"id":1 , "name":"tom"}
[
{},
{}
]