大数据系列修炼-Scala课程09

Option使用和实现内幕源码揭晓

　　1.Option中的sealed关键字解析:Option中用了sealed，定义的case class与case object必须在同一个文件中。Option在模式匹配中匹配项

　　2.Option使用内幕实战解析:Some表示匹配项，如果没有就在None中找

//sealed 表示封闭式抽象类
sealed abstract class Option[+A] extends Product with Serializable {}
//而some也是继承了Option对象 case class
final case class Some[+A](x: A) extends Option[A] {
  def isEmpty = false
  def get = x
}
//case object None继承了Option
case object None extends Option[Nothing] {
  def isEmpty = true
  def get = throw new NoSuchElementException("None.get")
}

    val scores = Map("Alice" -> 99, "Spark" -> 100)
    scores.get("Alicde") match {
    case Some(score) => println(score)
    case None => println("No score")
    }

List的基本操作实战与基于模式匹配的List排序算法实现

　　1.List的基本操作：isEmpty(),head，tail，排序

　　2.基于模式模式的List排序算法实现：用函数的方式排序

     //定义两个常量list
    val bigData = List("Hadoop" , "Spark")
    val data = List(1 , 2 , 3)

    //：：来连接两个list
    val bigData_Core = "Hadoop" :: ("Spark" :: Nil)
    val data_Int = 1 :: 2 :: 3 :: Nil
    //isEmpty()方法判断是否为空
    println(data.isEmpty)
    //head方法list的第一个元素
    println(data.head)
    //tail表示除了第一个元素的元素类型为list
    println(data.tail.head)
    //把第一个赋值给a，第二个赋值给b
    val List(a,b) = bigData
    println("a : " + a + " === " + " b: " + b)
    //把第一个赋值给x，把第二个赋值给y 以后的元素赋值给rest rest为list类型
    val x :: y :: rest = data
    println("x : " + x + " === " + " y: " + y + " === " + rest )

    val shuffledData = List(6,3,5,6,2,9,1)
    //sortList排序
    println(sortList(shuffledData))
    //定义一个sortList排序函数 如果list为空就返回空的list -->否则就list的头元素与后面的list进行比较
    def sortList(list : List[Int]): List[Int] = list match{
      case List() => List()
      case head :: tail  => compute (head, sortList(tail))
    }
    //定义一个函数compute计算 从小到大
    def compute(data : Int , dataSet : List[Int]) : List[Int] = dataSet match{
      case List() => List(data)
      case head :: tail  => if (data <= head) data :: dataSet
        else  head :: compute(data, tail)
    }

List中的一阶函数操作实现

　　1.List中的drop、take、splitAt、apply、indices、tostring、mkstring等实战

　　2.List的toIterator、toArray、copyToArray实现

    //：：用于连接两个list的组成新的list
    println(List (1,2,3,4) ::: List (4,5,6,7,8) ::: List (10,11))
    println(List (1,2,3,4) ::: (List (4,5,6,7,8) ::: List (10,11)))
    println(List (1,2,3,4).length)

    val bigData = List("Hadoop" , "Spark" , "Kaffka")
    //last表示最后一个元素
    println(bigData.last)
    //init除了最后一个的元素
    println(bigData.init)
    //reverse 表示翻转
    println(bigData.reverse)
    println(bigData)
    //take表示获取前n个元素
    println(bigData take 2)
    //drop截掉第n个元素
    println(bigData drop 1)
    //sqlitAt表示在n个元素的地方分割
    println(bigData splitAt 2)
    //获取序列为n的元素 开始为0
    println(bigData apply 2)
    //这与apply效果一样
    println(bigData(2))

    val data=List('a' ,'b', 'c', 'd', 'e', 'f')
    //indoces 获取系列号
    println(data.indices)
    //zip与indices按照序列组合成元素
    println(data.indices zip data)
    //zipwithIndex zip在前
    println(data.zipWithIndex)
    //转换为字符串
    println(data.toString)
    //组合成指定的元素
    println(data.mkString ("[", ",,", "]"))
    println(data.mkString ("******"))
    println(data mkString)

    //stringbuilder表示可变的元素
    val buffer = new StringBuilder
    data addString (buffer, "(", ";;", ")")
    println(buffer)
    println(data)
    //list转换为array
    val array = data.toArray
    println(array.toList)
    //转换为char类型的数组
    val new_Array = new Array[Char](10)
    data.copyToArray(new_Array,3)
    new_Array.foreach(print)
    println
    //转换为迭代器进行遍历
    val iterator = data.toIterator
    println(iterator.next)
    println(iterator.next)

对List进行高效的排序和倒序代码实现

　　1.对List进行排序实现

　　2.对List进行倒序排序实现

    //定义一个归并排序函数 [T]使用泛型
    def mergedsort[T] (less: (T, T) => Boolean) (input: List[T]): List[T] = {

      /**
     * @param xList 要合并的有序列表
     * @param yList 要合并的有序列表
     * @return 合并后的列表
     */
      //基本思想是把list分为两个list进行排序，先把两个list进行排序
    def merge(xList: List[T], yList: List[T]): List[T] =
      (xList, yList) match {
      case (Nil, _) => yList
      case (_, Nil) => xList
      case (x :: xtail, y :: ytail) =>
        if (less(x, y)) x :: merge(xtail, yList)
        else y :: merge(xList, ytail)
    }
    val n = input.length / 2
    if (n == 0) input
    else {
      val (x, y) = input splitAt n //把要排序的列表input平均分成两个列表
      merge(mergedsort(less)(x), mergedsort(less)(y))  //先对分后的两个列表归并排序，再对排好的有序表进行归并
    }
  }
    println(mergedsort((x: Int, y: Int) => x < y) (List (3, 7, 9, 5)))
　　//定义一个倒序的归并排序
    val reversed_mergedsort=mergedsort((x: Int, y: Int) => x > y) _
    println(reversed_mergedsort(List(3, 7, 9, 5)))

今天主要的内容是关于list的基本操作！明天继续.............

希望大家关注王家林老师的视频微信号(18610086859)

最新地址75讲：http://pan.baidu.com/s/1dDFDRmL

百度云地址31-34讲：http://pan.baidu.com/s/1mgiV7Vq