一、 :: , +: , :+ , ::: , ++
- :: 该方法可向队列头部追加数据，创造新的列表
val aa = List(1, 2, 3) //> aa : List[Int] = List(1, 2, 3)
aa.::(3.14) //> res0: List[AnyVal] = List(3.14, 1, 2, 3)
val b = "x" :: "y" :: "z" :: Nil //> b : List[String] = List(x, y, z)
val bb = "scala" :: 3.3 :: 'h :: Nil //> bb : List[Any] = List(scala, 3.3, 'h)
- :+ 和 +: 其中
:+方法用于在尾部追加元素，+:方法用于在头部追加元素
val ac = 1 +: 2.2 +: 'f +: Nil //> ac : List[Any] = List(1, 2.2, 'f)
val ca = Nil :+ "scala" :+ 2 :+ true //> ca : List[Any] = List(scala, 2, true)
- ::: 与 ++ 其中
:::方法只能连接集合，++方法除了连接集合还可以连接字符串
ac ++ ca //> res1: List[Any] = List(1, 2.2, 'f, scala, 2, true)
"scala" ++ "java" //> res2: String = scalajava
ca ::: ac //> res3: List[Any] = List(scala, 2, true, 1, 2.2, 'f)
二、 <: , >: , - , +
- <: 和 >: 其中
<:代表类型上界，>:代表类型下界
object SymbolTest {
def t[T <: B](x: Seq[T]) = x //> t: [T <: test.B](x: Seq[T])Seq[T]
t(Seq(new B, new C)) //> res4: Seq[test.B] = List(test.B@3796751b, test.C@67b64c45)
t(Seq(new B, new C)).map(_.say) //> BBBBB
//| CCCCC
//| res5: Seq[Unit] = List((), ())
}
class A {
def say(){
println("AAAAA")
}
}
class B extends A {
override def say() = {
println("BBBBB")
}
}
class C extends B {
override def say() = {
println("CCCCC")
}
}
注： 其中方法
t[T <: B](x: Seq[T])调用时，只能使用类B的本身及其子类，否则如：t(Seq(new B, new C, new A))是会报错的，无法通过编译，而>:则恰恰相反
- - 与 + 在此要引用泛型，在泛型类型中
+表示协变，而-表示逆变
-
S[+T]: 如果 B 是 A 的子类，那么 S[B] 是 S[A] 的子类。——协变 -
S[-T]: 如果 B 是 A 的子类，那么 S[A] 是 S[B] 的子类。——逆变 -
S[T]: 无论 A 和 B 是什么关系， S[A] 和 S[B] 都没有从属关系。
object SymbolTest {
var s = new S[B] //> SSSSS
//| s : test.S[test.B] = test.S@edf4efb
s = new S[C] //> SSSSS
//s = new S[A] //协变只能调用本类及其子类的引用，无法调用父类的引用、逆变则与之相反
}
class S[+T]{
println("SSSSS")
}
class A {
def say() {
println("AAAAA")
}
}
class B extends A {
override def say() = {
println("BBBBB")
}
}
class C extends B {
override def say() = {
println("CCCCC")
}
}
注：在Scala规定中，协变类型只能作为方法的返回类型，而逆变类型只能作为方法的参数类型，即
函数的参数类型是逆变的，而函数的返回类型是协变的
三、 /: , :\
/: 与 :\ 分别对应 foldLeft 和 foldRight 函数，是它们的缩写。详解：Scala:fold,foldLeft和foldRight区别与联系
val a = List(1, 2, 3, 4) //> a : List[Int] = List(1, 2, 3, 4)
def ss(x: List[Int]): (Int, Int, Int) =
x./:((0, 0, 0))((t, v) => (t._1 + 2, t._2 + v, t._3 + v * v))
//> ss: (x: List[Int])(Int, Int, Int)
ss(a) //> res0: (Int, Int, Int) = (8,10,30)
注：
x./:((0, 0, 0))((t, v) => (t._1 + 2, t._2 + v, t._3 + v * v))表示对集合x进行循环，其中(0,0,0)代表函数(t._1 + 2, t._2 + v, t._3 + v * v)的初始值，t作为一个记录结果的值，而v代表每次传进来的集合x的值
- 第一次循环：0+2,0+1,0+1
- 第二次循环：2+2,1+2,1+4
- 第三次循环：4+2,3+3,5+9
- 第四次循环：6+2,6+4,14+16