scala集合

scala集合

集合简介

Scala的集合有三大类： 序列Seq、集Set、映射Map， 所有的集合都扩展自Iterable特质

对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本， 分别位于以下两个包

• 不可变集合 scala.collection.immutable
• 可变集合 scala.collection.mutable

scala不可变集合，就是指该集合不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于Java中的String对象

可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象，类似于Java中的StringBuilder对象

建议：在操作集合的时候，不可变用符号，可变用方法

不可变集合继承范围：

可变集合继承范围

数组

不可变数组

定义： val arr1 = new Array[Int](10)

object ImmutableArray01 {
  def main(args: Array[String]): Unit = {
    // 创建数组
    val arr: Array[Int] = new Array[Int](5)
    // 另一种创建方式
    val arr2 = Array(1,2,3)
    println(arr2(0))  // 1
    arr2(0) = 77
    // 增强for
    for (x <- arr2){
      println(x)
    }
    // for
//    for (i <- 0 until  arr2.length){
//      println(arr2(i))
//    }
    for (i <- arr2.indices){
      println(arr2(i))
    }
    // 迭代器
    val iter = arr2.iterator
    while (iter.hasNext){
      println(iter.next())
    }

    // foreach
    arr2.foreach( println)

    // 数组转 String
    println(arr2.mkString("--"))
        
    // 添加元素
    val newArr = arr2.:+(9)
    println(newArr.mkString("--"))  // 77--2--3--9

    val newArr2 = arr2.+:(9)
    println(newArr2.mkString("--"))  // 9--77--2--3

    val newArr3 = arr2 :+ 40
    println(newArr3.mkString("--")) // 77--2--3--40
    val newArr4 = 40 +: arr2
    println(newArr4.mkString("--")) //40--77--2--3
  }
}

可变数组

object mutableArrayBuffer02 {
  def main(args: Array[String]): Unit = {
    // 创建可变数组
    val arr1 = new ArrayBuffer[Int]()
    val arr2 = ArrayBuffer(1,2,3,4)

    println(arr1.mkString("--"))
    println(arr2.mkString("--")) // 1--2--3--4
    println(arr2)  // ArrayBuffer(1, 2, 3, 4)

    // 访问元素
    println(arr2(0)) // 1
    // 添加元素
    val newArr1 = arr2 :+ 9
    println(newArr1)
    arr2 += 9
    println(arr2) // ArrayBuffer(1, 2, 3, 4, 9)
    77 +=: arr2
    println(arr2) // ArrayBuffer(77, 1, 2, 3, 4, 9)
    arr2.append(31)
    arr2.prepend(22)
    arr2.insert(1, 32)
    println(arr2)  // ArrayBuffer(22, 32, 77, 1, 2, 3, 4, 9, 31)
    arr2.insertAll(1,arr1)
    println(arr2)  // ArrayBuffer(22, 32, 77, 1, 2, 3, 4, 9, 31)

    // 删除
    arr2.remove(1)
    println(arr2)  // ArrayBuffer(22, 77, 1, 2, 3, 4, 9, 31)
    arr2.remove(1, 4)
    println(arr2)  // ArrayBuffer(22, 4, 9, 31)
    arr2 -= 9
    println(arr2) // ArrayBuffer(22, 4, 31)
  }
}

可变数组和不可变数组转换

val arr2 = ArrayBuffer(1,2,3,4)
   val newArr = arr2.toArray  // 可变转不可变
   val newArr2 = newArr.toBuffer // 不可变转可变

二维数组

// 创建二维数组
    val array: Array[Array[Int]] = Array.ofDim[Int](2,3)

    // 访问二维数组
    array(0)(2) = 4
//    println(array(1)(1))
    array(1)(1) = 5
//    println(array(1)(1))

//    for (i <- 0 until array.length; j <- 0 until  array(i).length){
//      println(array(i)(j))
//    }
    for (i <- array.indices; j <- array(i).indices){
      print(array(i)(j) + "\t")
      if (j == array(i).length - 1){
        println()
      }
    }
    array.foreach(_.foreach(println))

List

不可变列表

list 创建、遍历、添加、合并

// 创建list
   val list = List(1,2,3)
   println(list)   // List(1, 2, 3)
   println(list(1))  // 2

   // 添加元素
   val list2 = list :+ 10
   val list3 = 10 +: list
   println(list2)  // List(1, 2, 3, 10)
   println(list3)  // List(10, 1, 2, 3)
   val list4 = list.::(51)
   println(list4)  // List(51, 1, 2, 3)
   val list5 = Nil.::(18)
   println(list5)  // List(18)
   val list6 = 17 :: Nil
   val list7 = 1 :: 4 :: 7 :: 9 :: Nil
   println(list7)  // List(1, 4, 7, 9)
      val list8 = list6 :: list7
   println(list8) // List(List(17), 1, 4, 7, 9)
   val list9 = list6 ::: list7
   println(list9) // List(17, 1, 4, 7, 9)
   val list10 = list6 ++ list7
   println(list10) // List(17, 1, 4, 7, 9)

可变列表

//创建
    val list1 = new ListBuffer[Int]
    val list2 = ListBuffer(12,34,56)
    println(list1)  // ListBuffer()
    println(list2)   // ListBuffer(12, 34, 56)

    // 添加
    list1.append(13)
    list2.prepend(14)
    println(list1)  // ListBuffer(13)
    println(list2)  // ListBuffer(14, 12, 34, 56)

    list1 += 16  += 25
    println(list1)  // ListBuffer(13, 16, 25)
    21 +=: list1 += 77
    println(list1)  // ListBuffer(21, 13, 16, 25, 77)
    // 合并
    val list3 = list1 ++ list2
    println(list3)  //ListBuffer(21, 13, 16, 25, 77, 14, 12, 34, 56)
    list1 ++=: list2
    println(list1)  // ListBuffer(21, 13, 16, 25, 77)
    println(list2)  // ListBuffer(21, 13, 16, 25, 77, 14, 12, 34, 56)

    // 修改
    list2(0) = 9
    println(list2)
    // 删除
    list2.remove(2)
    list2 -= 77
    println(list2)  // ListBuffer(9, 13, 25, 14, 12, 34, 56)

Set

默认情况下，Scala使用的是不可变set， 如果想使用可变set需要引入 scala.collection.mutable.Set包

不可变集合

// 创建
    val set1 = Set(1,2,3,1,2)
    println(set1) //Set(1, 2, 3)
    // 添加
    val set2 = set1 + 9
    println(set2)  // Set(1, 2, 3, 9)
    // 合并集合
    val set3 = Set(4,5,6)
    val set4 = set2 ++ set3
    println(set4) // HashSet(5, 1, 6, 9, 2, 3, 4)
    // 删除
    val set5 = set3 - 5
    println(set5)  // Set(4, 6)

可变集合

// 创建
  val set1 = mutable.Set(1,2,3,1,2)
  println(set1) //Set(1, 2, 3)
  // 添加
  set1.add(10)
  println(set1)  // HashSet(1, 2, 10, 3)
  set1.addOne(6)
  println(set1)  // HashSet(1, 2, 3, 6)
  set1 += 7
  println(set1)  // HashSet(1, 2, 3, 6, 7)
  // 删除
  set1 -= 10
  println(set1)  //HashSet(1, 2, 3, 6, 7)
  set1.remove(7)
  println(set1)  // HashSet(1, 2, 3, 6)
  // 合并集合
  val set3 = mutable.Set(4,5,6)
  val set4 = set1 ++ set3
  println(set1) //HashSet(1, 2, 3, 6)
  println(set4) // HashSet(1, 2, 3, 4, 5, 6)
  set1 ++= set3
  println(set3) // HashSet(4, 5, 6)
  println(set1) // HashSet(1, 2, 3, 4, 5, 6)

Map

不可变集合

val map = Map("a" -> 12, "b" -> 13)
  // println(map("g"))
   println(map)
   map.foreach((kv: (String, Int)) => println(kv))
   println(map.get("a"))  // Some(12)
   println(map.get("a").get)   // 12
   println(map.getOrElse("c", 0))  // 0

可变集合

// 创建
  val map = mutable.Map("a" -> 12, "b" -> 13)
  // 添加元素
  map.put("c", 6)
  map.put("d", 9)
  println(map)  // HashMap(a -> 12, b -> 13, c -> 6, d -> 9)
  map += (("e", 7))
  println(map)  // HashMap(a -> 12, b -> 13, c -> 6, d -> 9, e -> 7)
  // 删除
  map.remove("e")
  println(map)  // HashMap(a -> 12, b -> 13, c -> 6, d -> 9)
  map -= "d"
  println(map)  // HashMap(a -> 12, b -> 13, c -> 6)
  // 合并
  val map2 = Map("aa" -> 10, "bb" -> 20)
  map ++= map2
  println(map)  // HashMap(aa -> 10, bb -> 20, a -> 12, b -> 13, c -> 6)

元组

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据，说的简单点，就是将多个无关的数据封装为一个整体，称为元组

注意：元组中最大只能有22个元素

声明方式： (元素2,元素2,元素3)

// 创建
  val tuple = ("hello", 100, 'q', true)
  println(tuple) // (hello,100,q,true)
  // 访问
  println(tuple._1)  // hello
  // 遍历
  for (elem <- tuple.productIterator){
    println(elem)
  }
  // 嵌套元组
  val mulTuple = (12,3,5,"chen", (9,20,"hello"))
  println(mulTuple._5._3)  // hello

集合常用函数

基本常用操作

val list = List(1,2,4,6,8)
    val set = Set(1,2,4,6,8)
    // 获取集合长度
    println(list.length)  // 5
    // 获取集合大小
    println(set.size)  // 5
    println(list.size)  // 5
    // 循环遍历
    for(elem <- list){
      println(elem)
    }
    set.foreach(println)
    //迭代器
    for (elem <- list.iterator)println(elem)
    // 生成字符串
    println(list)
    println(set)
    println(list.mkString("--"))  // 1--2--4--6--8
    // 是否包含
    println(list.contains(2))  // true

衍生集合

val list1 = List(1,2,4,6,8)
   val list2 = List(10,20,40,60,80)
   // 获取集合的头
   println(list1.head) // 1
   // 获取集合的尾（不是头就是尾）
   println(list1.tail)  // List(2, 4, 6, 8)
   // 获取最后一个元素
   println(list1.last) // 8
   // 集合初始数据（不包含最后一个）
   println(list1.init) // List(1, 2, 4, 6)
   // 反转
   println(list1.reverse) // List(8, 6, 4, 2, 1)
   // 取前(后)n个元素
   println(list1.take(3)) // List(1, 2, 4)
   println(list1.takeRight(3)) // List(4, 6, 8)
   // 去掉前(后)n个元素
   println(list1.drop(3))  // List(6, 8)
   println(list1.dropRight(3)) // List(1, 2)

   // 并集
   val union = list1.union(list2)
   println(union)  // List(1, 2, 4, 6, 8, 10, 20, 40, 60, 80)
   println(list1 ::: list2) // List(1, 2, 4, 6, 8, 10, 20, 40, 60, 80)
   // 交集
   val intersection = list1.intersect(list2)
   println(intersection) // List()
   // 差集
   val diff = list1.diff(list2)
   println(diff) // List(1, 2, 4, 6, 8)
   // 拉链
   println(list1.zip(list2)) // List((1,10), (2,20), (4,40), (6,60), (8,80))
   // 滑窗
   for (elem <- list1.sliding(3))print(elem + "\t") // List(1, 2, 4)	List(2, 4, 6)	List(4, 6, 8)

集合计算简单函数

val list1 = List(5,2,4,7,-3,8)
   val list2 = List(("a", 6),("b",8),("c",0),("d",5))
   // 求和
   var sum = 0
   for (elem <- list1){
     sum += elem
   }
   println(sum) // 23
   println(list1.sum) // 23
   // 求乘积
   println(list1.product) // -6720
   // 最大值
   println(list1.max)  // 8
   println(list2.max)  // (d,5)
   println(list2.maxBy(_._2)) // (b,8)
   // 最小值
   println(list1.min) // -3
   // 排序
   println(list1.sorted) // 从小到大 List(-3, 2, 4, 5, 7, 8)
   println(list1.sorted(Ordering[Int].reverse)) // 从大到小  List(8, 7, 5, 4, 2, -3)

高级计算函数

val list1 = List(1,2,3,4,5,6,7,8,9)
    // 过滤
    println(list1.filter(_ % 2 == 0))  // List(2, 4, 6, 8)
    // 转化/映射 (将集合中的每一个元素映射到某一个函数)
    println(list1.map(_ * 2) ) // List(2, 4, 6, 8, 10, 12, 14, 16, 18)
    // 扁平化
    val nestedList: List[List[Int]] = List(List(1,2,3), List(4,5), List(6,7))
    println(nestedList.flatten)  // List(1, 2, 3, 4, 5, 6, 7)
    // 扁平化 + 映射 (flatMap 相当于先进行map操作， 在进行flatten操作， 集合中的每一个元素的子元素映射到某个函数并返回新的集合
    // 将一组字符串进行分词，并保存成单词的列表
    val strings: List[String] = List("hello world", "hello scala", "hello java", "we study")
    val splitList: List[Array[String]] = strings.map(_.split(" "))  // 分词
    val flattenList = splitList.flatten // 扁平化
    println(flattenList) // List(hello, world, hello, scala, hello, java, we, study)
    val flattenList2 = strings.flatMap(_.split(" "))
    println(flattenList2) // List(hello, world, hello, scala, hello, java, we, study)
    // 分组
    val groupmap = list1.groupBy(_ % 2)
    println(groupmap) // HashMap(0 -> List(2, 4, 6, 8), 1 -> List(1, 3, 5, 7, 9))
    val groupmap2 = list1.groupBy(data => if(data % 2 == 0) "偶数" else "奇数")
    println(groupmap2) // HashMap(偶数 -> List(2, 4, 6, 8), 奇数 -> List(1, 3, 5, 7, 9))
    // 归约
    val reduce01 = list1.reduce(_+_)
    println(reduce01)  // 45
    val list2 = List(3,4,5,8,10)
    println(list2.reduce(_ - _))  // -24
    println(list2.reduceRight(_ - _))  // 6    3 - (4 - (5 - (8 - 10)))
    // 折叠
    println(list1.fold(10)(_ + _))  // 55
    println(list1.foldLeft(10)(_ - _))  // -35
    println(list2.foldRight(10)(_ - _))  // -4   3 - (4 - (5 - (8 - (10 - 10))))

归约合并map

val map1 = Map("a" -> 1, "b" -> 2, "c" -> 3)
   val map2 = mutable.Map("a" -> 6, "b" -> 4, "c" -> 7, "d" -> 1)
   println(map1 ++ map2)  // Map(a -> 6, b -> 4, c -> 7, d -> 1)
   val map3 = map1.foldLeft(map2)((mergedMap, kv) => {
     val key = kv._1
     val value = kv._2
     mergedMap(key) = mergedMap.getOrElse(key, 0) + value
     mergedMap
   })
   println(map3) // HashMap(a -> 7, b -> 6, c -> 10, d -> 1)

单词计数

经典版

 val stringList: List[String] = List("hello", "hello world","hello java" ,"hello scala","hello scala from scala","hello flink from scala")
    // 对字符串按空格进行切分，得到一个所有单词的列表
//    val worldList1 = stringList.map(_.split(" "))
//    val worldList2 = worldList1.flatten
//    println(worldList2)
    val worldList = stringList.flatMap(_.split(" "))
    println(worldList) // List(hello, hello, world, hello, java, hello, scala, hello, scala, from, scala, hello, flink, from, scala)
    // 形同的单词进行分组
    val strignToMap = worldList.groupBy(world => world)
    println(strignToMap) // HashMap(world -> List(world), java -> List(java), flink -> List(flink), hello -> List(hello, hello, hello, hello, hello, hello), scala -> List(scala, scala, scala, scala), from -> List(from, from))
    // 对分组之后的list取长度
    val countMap: Map[String, Int] = strignToMap.map(kv => (kv._1, kv._2.length))
    println(countMap) // HashMap(world -> 1, java -> 1, flink -> 1, hello -> 6, scala -> 4, from -> 2)
    // 将map转化为list，并排序取前三
    val sortList: List[(String, Int)] = countMap.toList
      .sortWith(_._2 > _._2)
      .take(3)
    println(sortList) // List((hello,6), (scala,4), (from,2))

复杂版

val stringList: List[(String, Int)] = List(
   ("hello", 1),
   ("hello world", 2),
   ( "hello java", 3) ,
   ( "hello scala", 1),
   ("hello scala from scala", 2),
   ("hello flink from scala", 3))

 val preCountList: List[(String, Int)] = stringList.flatMap(kv => {
   val strArr = kv._1.split(" ")
   strArr.map(world => (world, kv._2))
 })
 println(preCountList) // List((hello,1), (hello,2), (world,2), (hello,3), (java,3),......
 val recountMap: Map[String, List[(String, Int)]] = preCountList.groupBy(_._1)
 println(recountMap) // HashMap(world -> List((world,2)), java -> List((java,3))......
 val countMap: Map[String, Int] = recountMap.map(kv => {
   (kv._1, kv._2.map(tuple => tuple._2 ).sum)
 })
 println(countMap) // HashMap(world -> 2, java -> 3, flink -> 3, hello -> 12, scala -> 8, from -> 5)
 val resultuple = countMap.toList.sortBy(_._2)(Ordering[Int].reverse).take(3)
 println(resultuple ) // List((hello,12), (scala,8), (from,5))

并行

Scala 2.13之后，并行集合模块变成了外部库，直接像Scala 2.12那样写并行集合计算代码，IDE会报“Cannot resolve symbol par”

解决方法:
1,在maven项目的pom.xml中手动导入如下依赖

<dependencies>
        <dependency>
            <groupId>org.scala-lang.modules</groupId>
            <artifactId>scala-parallel-collections_2.13</artifactId>
            <version>0.2.0</version>
        </dependency>
</dependencies>

2, 步骤2: 在使用的并行集合的.scala 文件中引入

import scala.collection.parallel.CollectionConverters._

示例：

val result = (1 to 100).map(
      x => Thread.currentThread().getId
    )
    println(result)

    val result2 = (1 to 100).par.map(
      x => Thread.currentThread().getId
    )
    println(result2)

模式匹配

模式匹配语法中，采用match关键字声明，每个分支采用case关键字进行声明，当需要匹配时，会从第一个case分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断，如果所有case都不匹配，那么会执行case_分支，类似于Java中的default语句

基本语法

// 基本定义语法
    val x: Int = 5
    val y: String = x match {
      case 1 => "one"
      case 2 => "two"
      case _ => "other"
    }
    println(y)

模式守卫

def abs(num: Int): Int = {
      num match {
        case i if i >= 0 => i
        case i if i < 0 => -i
      }
    }
    println(abs(9))
    println(abs(-9))

示例：

def describeConst(x: Any): String = x match {
      case 1 => "Num one"
      case "hello" => "String hello"
      case true => "boolean true"
      case _ => "无匹配"
    }

    def descType(x: Any): String = x match {
      case i: Int => "int " + i
      case i: String => "string " + i
      case i: List[String] => "List " + i
      case i: Array[Int] => "Array " + i.mkString(",")
      case a => "something else"
    }
  println(descType(35))
  println(descType("hello"))
  println(descType(List("sd")))
  println(descType(List(5)))  // List List(5) (泛型擦除)
  println(descType(Array(4)))
  println(descType(Array("a")))  // something else (array不存在泛型擦除)

数组匹配

// 匹配数组
   for(arr <- List(
     Array(0),
     Array(1,0),
     Array(0,1,0),
     Array(1,1,0),
     Array(2,3,7,17),
     Array("hello", 20, 30),
   )){
     val result = arr match {
       case Array(0) => "0"
       case Array(1,0) => "Array(1,0)"
       case Array(x,y) => "Array: " + x + " , " + y
       case Array(0, _*) => "以0开头的数组"
       case Array(x, 1, z) => "中间为1的三元素数组"
       case _ => "something else"
     }
     println(result)
   }

列表匹配

// 匹配数组
    for(arr <- List(
      List(0),
      List(1,0),
      List(0,1,0),
      List(1,1,0),
      List(2,3,7,17),
      List("hello", 20, 30),
    )){
      val result = arr match {
        case List(0) => "0"
        case List(1,0) => "Array(1,0)"
        case List(x,y) => "Array: " + x + " , " + y
        case List(0, _*) => "以0开头的list"
        case List(x, 1, z) => "中间为1的三元素list"
        case _ => "something else"
      }
      println(result)
    }

元组匹配

// 匹配元组
for(arr <- List(
  (0, 1),
  (1,0),
  (0,1,0),
  (1,1,0),
  (2,3,7,17),
  ("hello", 20, 30),
)){
  val result = arr match {
    case (1,0) => "元组(1,0)"
    case (x,y) => "元组: (x,y)"
    case (0, _) => "以0开头的元组"
    case (x, 1, z) => "中间为1的三元素元组"
    case _ => "something else"
  }
  println(result)
}

// 在变量声明时匹配
   val (x, y) = ( 10, "hello" )
   println(s"x: $x y: $y") // x: 10 y: hello
   println(x) // 10
   val List(first, second, _*) = List(23,3,45,34)
   println(s"$first  $second") // 23  3

   val  fir :: sec :: rest = List(23,3,45,34)
   println(s"$fir  $sec $rest") // 23  3 List(45, 34)

   // for推导式中进行模式匹配
   val list: List[(String, Int)] = List(("a", 12), ("b", 23))
   for (elem <- list){
     println(elem._1 + "___" + elem._2)
   }
   // 解构
   for((word, coutn) <- list){
     println(word + "___" + coutn)
   }
   // 不考虑某个位置的变量，只遍历key或value
   for((word, _) <- list){
     println(word + "___")
   }
   // 可以指定某个位置的值必须是多少
   for(("a", coutn) <- list){
     println("___" + coutn)
   }

对象匹配

object Patt02 {
  def main(args: Array[String]): Unit = {
    val student = new Student("chen", 18)
    val result = student match {
      case  Student("chen", 18) => "yes"
      case _ => "else"
    }
    println(result)
  }
}

// 定义类
class Student(val name: String , val age: Int)

// 伴生duixiang
object  Student{
  def apply(  name: String, age: Int): Student = new Student( name, age)
  // 必须实现一个unapply方法
  def unapply(student: Student): Option[(String, Int)] = {
    if (student == null){
      None
    }else {
      Some((student.name, student.age))
    }
  }
}

样例类方式

object Patt03 {
  def main(args: Array[String]): Unit = {
    val student =  Student1("chen", 18)
    val result = student match {
      case  Student1("chen", 18) => "yes"
      case _ => "else"
    }
    println(result)
  }
}
// 定义样例类
case class Student1( name: String ,  age: Int)

偏函数

val list = List(("a", 23), ("b", 56), ("c", 90), ("d", 78))
   val list2 = list.map(tuple => (tuple._1, tuple._2 * 2))

   val list3 = list.map(tuple => {
     tuple match {
       case (word, count) => (word, count* 2)
     }
   })
   // 偏函数
   val list4 = list.map{
       case (word, count) => (word, count* 2)
     }
   println(list3)

异常

object Catch01 {
  def main(args: Array[String]): Unit = {
    try{
      val a = 10 / 1
    }catch {
      case e: ArithmeticException =>{
        println("算数异常")
      }
      case e: Exception => {
        println("异常")
      }
    }finally {
      println("结束")
    }
  }
}

隐式转换

object Yin09 {
  def main(args: Array[String]): Unit = {
    // 隐式函数
    implicit def convert(n: Int): MyRichInt = new MyRichInt(n)
    println(12.myMax(24)) // 24


    // 隐式类
    implicit class MyRichInt2(val self: Int){
      // 自定义比较大小的方法
      def myMax2(n: Int): Int = {if (self > n) self else  n}
      def myMin2(n: Int): Int = {if (self < n) self else  n}
    }
    println(12.myMax2(24))  // 24

    // 隐式参数
    implicit val str: String = "chen"
    def sayhello(implicit name: String ): Unit = {
      println(s"hello $name")
    }
    def sayhello2(implicit name: String ): Unit = {
      println(s"hello $name")
    }
    sayhello   // hello chen
    sayhello2 // hello chen
  }
}
// 自定义类
class MyRichInt(val self: Int){
  // 自定义比较大小的方法
  def myMax(n: Int): Int = {if (self > n) self else  n}
  def myMin(n: Int): Int = {if (self < n) self else  n}
}

泛型

协变和逆变

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

    // 协变和逆变
    val child: Parent = new Child
   // val childList: MyCollection[Parent] = new MyCollection[Child]
    val childList: MyCollection[SubChild] = new MyCollection[Child]

  }
}

class Parent{}
class Child extends Parent{}
class SubChild extends Child{}

// 定义带泛型的集合类型
class MyCollection[-E]{}

泛型上下限

class PersonList[T <: Person]{} // 泛型上限

class PersonList[T >: Person]{} // 泛型下限

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

    def test[A <: Child](a: A): Unit = {
      println(a.getClass.getName)
    }
    test[Child](new Child)
    test[Child](new SubChild)
    test[SubChild](new SubChild)

  }
}

class Parent{}
class Child extends Parent{}
class SubChild extends Child{}