一、 :: , +: , :+ , ::: , ++

:: 该方法可向队列头部追加数据，创造新的列表

  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 的值