月度归档： 2020 年 9 月

单词count统计这个经典的问题可以算得上是Spark大数据统计的 hello world问题，但是，打蚊子何需动用Spark这门大炮。鉴于Spark是基于Scala的，我们就用Scala本身来实现这个经典的问题，从而达到举一反三的目的。

val str = "hello world,Hello scala"
val split1 = str.split(" ")
var split2 = split1.flatMap(_.split(","))
val res = split2.map(_.toLowerCase()).map((_,1)).groupBy(_._1).map(kv=>(kv._1,kv._2.size))
res.foreach(println)

因为字符串中包含两种分隔符，所以先用空格符进行第一次分割，这时split1是一个string类型的java原生数组，然后再用逗号进行第二次分割，这时需要注意，如果用普通的map去循环分割，最后split2会得到一个二位数组，增加计算的复杂度，所以flatMap上场了，分割后仍然是一个一维数组，相当于在原基础上把数组压平了，后面会对flatMap进行重新实现，以便对其的作用有一个更直观的理解。

这时的split2看起来是这个样子的

List(hello,world,Hello,scala)

因为还涉及到大小写，所以对其进行小写转换，再转换成对偶元祖，经过两次map操作后，这是的临时数据看起来是这样的

List((hello,1),(world,1),(hello,1),(scala,1))

然后使用groupBy进行分组，_._1表示进行归并分组，最后返回得到一个map，键名用每个元祖的第一个元素

Map(‘scala’->List((scala,1)),’world’->List((world,1)),’hello’->List((hello,1),(hello,1))

最后再进行修饰，只取长度值

Map(‘scala’->1,’world’->1,’hello’->2)

得到我们想要的统计结果。下面是flatMap的实现代码

def flatMap(arr:Array[String]): Array[String] ={
  var res = Array[String]()
  val temp = arr.map(_.split(","))
  temp.foreach((v)=>{
    v.foreach(v2=>{res = res :+ v2})
  })
  res
}

这里只给出了一个简单实现，系统的实现比这要复杂很多，读者可自行阅读SDK里的实现源码

附:（请一定要看完）

经过思考发现，groupBy只要传入一个函数参数即可对系列进行分组，那么为什么一定要把List的元素转化为元组再进行groupBy呢？直接groupBy可以不可以，其实是可以的。代码如下

split2.map(_.toLowerCase()).groupBy(v=>v).map(v=>(v._1,v._2.size))

这是精简后的代码，直接使用元素本身来进行分组，值得注意的是，这里的groupBy没法简写成groupBy(_)，但是却可以写成这样

groupBy(_*1)

目测简写为下划线后还需要跟其他操作符（点操作符或者四则运算）,不过具体细节需要阅读源码才能知晓其中的微妙了

网上针对这个例子大多是进行了元组转换操作，其实大可不必，而且也不太好理解，可见独立的深度思考非常重要，不可人云亦云

最后强烈建议新手不要随意使用简写形式，先按常规形式写全函数表达式，在可能的基础上再进行缩写，否则陡峭的Scala学习曲线会让你挫败感顿生。

(完结）

众所周知在很多面向对象的语言中，抽象类都是不可以直接实例化的，必须另写一个类继承实现这个抽象类之后再实例化这个子类，Scala也不例外。

abstract class Car{
  def drive()
  def color
}

val car1 = new Car {}

这段代码是无法编译通过的，因为在Scala中，无论是抽象类和特质，只要存在没有实现的方法或属性，都是无法直接实例化的。注意，这里提到了没有实现的方法和属性，可以看下面的代码

trait Car{
  def drive() = {}

  def color = "red"
}

val car1 = new Car {}

上面这段代码是可以编译通过的，因为虽然它是特质，但是方法和属性都实现了，就可以当作普通类来实例化

如果有时候的确需要直接实例化 “没有实现方法的抽象类或特质”，该怎么办呢？这就引出了今天的主角——匿名子类，用法如下

abstract class Car{
  def drive()
  def color
}

val car1 = new Car {
  override def drive(): Unit = {
    println("drive")
  }
  override var color = "red"
}

在new关键词后面直接跟上方法和属性的实现代码就可以了

匿名子类可以极大提高代码的灵活性，Scala中有广泛应用，如下所示

implicit val ord = new Ordering[String] {
  override def compare(x: String, y: String) : Int = {
    y.compareTo(x)
  }
}

val arr = Array("a", "g", "F", "B", "c")
val sortedArr = arr.sorted
sortedArr.foreach(println)

这段代码对array的元素进行排序，sorted会传入一个隐式参数，而这个隐式参数 ord 就是特质Ordering的一个匿名子类（实现了compare方法），其中compare可由开发者自行实现符合自己排序的逻辑，这也是精髓所在。

package com.datacrafts.digitalevers.test

class binaryFind(in:Array[Int]) {
  val src:Array[Int] = in

  /**
   * 给定一个整数 
   * 使用二分查找它在顺序数列中的位置
   * @param in
   * @return
   */
  def find(in:Int): Int = {
    var start_index = 0
    var end_index = src.length - 1
    var curr_index = (start_index + end_index) / 2
    //需要探测边界 否则无法检索到
    if(src(start_index) == in){
      return start_index
    }
    if(src(end_index) == in){
      return end_index
    }
    //查找中位数 如果没有查找到 继续循环这一过程 当开始节点靠近尾节点则跳出循环
    while(src(curr_index) != in && ((end_index - start_index) > 1)){
      if(src(curr_index) > in){
        end_index = curr_index
      } else {
        start_index = curr_index
      }
      curr_index = (start_index + end_index) / 2
    }
    //循环结束还没找到 说明不存在这一节点 以返回-1标识
    if(src(curr_index) != in){
      return -1
    }
    //查找到则返回该节点index索引
    curr_index
  }
}

object binaryFind{
  def main(args: Array[String]): Unit = {
    val bf = new binaryFind(Array(10,11,12,20))
    println(bf.find(21))
  }
}

上述算法对头尾节点进行了一次特殊的探测处理，因为如果目标值刚好落在头尾节点，最后当头尾节点相互靠近的时候，该算法的中间节点可能无法移动（会一直停留在头节点）从而导致死循环。为了避免死循环，故加上了靠近退出循环机制，但最后可能会无法查找到这个目标节点。

这种为特殊情况而加的代码处理使得整个算法看起来不再是一个“优秀”的算法，后来读到《编程珠玑》的算法，很巧妙地规避了这个问题——该书采取了将中间节点curr_index移动一位的做法，如果目标值比中间节点大，则curr_index往大方向移动一位，如果小，则反之往小的方向移动一位。这很好理解，也是很正确的做法。既然中间节点不是目标值，那为何还要将其作为新的起始节点呢

这种新算法不存在中间节点最后不移动的问题，所以也就不需要再对头尾节点进行探测处理了，并且也不需要再设置头尾节点靠近则退出循环的机制

精简后的代码如下

package com.datacrafts.digitalevers.test

class binaryFind(in:Array[Int]) {
  val src:Array[Int] = in

  /**
   * 给定一个整数
   * 使用二分查找它在顺序数列中的位置
   * @param in
   * @return
   */
  def find(in:Int): Int = {
      var start_index = 0
      var end_index = src.length - 1
      var curr_index = 0

      //查找中位数 如果没有查找到 继续循环这一过程 当开始节点靠近尾节点则跳出循环
      while(start_index <= end_index){
        curr_index = (start_index + end_index) / 2
        if(src(curr_index) > in){
          end_index = curr_index - 1
        } else if(src(curr_index) < in) {
          start_index = curr_index + 1
        } else {
          return curr_index
        }
      }
      //循环结束还没找到 说明不存在这一节点 以返回-1标识
      -1
  }
}

object binaryFind {
  def main(args: Array[String]): Unit = {
    val bf = new binaryFind(Array(10,11,12,20))
    println(bf.find(12))
  }
}