Scala语法细节03--double_happy

续集细节03

（8）抽象类

/**  
  * 抽象类:
  * 1） 类中有一个或者多个方法/属性的定义，没有实现
  * 2） 抽象类是不能直接new
  * 3） 使用时要有完全实现了抽象方法/属性的子类才行
  * 4） 子类重写父类方法或者属性时一定需要override吗  (不需要 可以加上 抽象类很神奇）
  */
object AbstractClassApp {

  def main(args: Array[String]): Unit = {
    val student = new Student2
    student.speak
    println(student.name)
  }

}

abstract class Person2 {
  def speak
  val name:String
}

class Student2 extends Person2 {
  def speak: Unit = {
    println("speak...")
  }

  val name: String = "若泽"
}

（9）数据结构
1.数组：长度可变、长度不可变

长度不可变： new 的方式创建
	1.String 类型的默认值是 null
	2.如果不指定是 Nothing

在这里插入图片描述

不用new的方式 ：
	集合里面不使用new 是调用 object的apply方法

在这里插入图片描述

底层调用的是 object的 apply方法：

/** Creates an array with given elements.
   *
   *  @param xs the elements to put in the array
   *  @return an array containing all elements from xs.
   */
  // Subject to a compiler optimization in Cleanup.
  // Array(e0, ..., en) is translated to { val a = new Array(3); a(i) = ei; a }
  def apply[T: ClassTag](xs: T*): Array[T] = {
    val array = new Array[T](xs.length)
    var i = 0
    for (x <- xs.iterator) { array(i) = x; i += 1 }
    array
  }

遍历：这里列出三种

val a = Array("double_happy","sxwang","xxx")

    for (el <- a ) {
      println(el)
    }

    println("----------------")

    a.foreach(println(_))

    println("-----------------")

    for(el <- 0 until a.size ) {
      println(a(el))
    }

在这里插入图片描述

其他知识点补充：
	元素反转 
	   使用reverse
	   不使用reverse

在这里插入图片描述

不适用reverse：
 val a = Array("double_happy","sxwang","xxx")


    //反转
    for(i <- a.size -1 to 0 by -1 ) {
      println(a(i))
    }

在这里插入图片描述

两个Array 相加：

在这里插入图片描述

mkString使用：查看数组内容

$!\[在这里插入图片描述\](https://img-blog.csdnimg.cn/20190907132515616.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU1NzUxMg==,si$

def mkString(start: String, sep: String, end: String): String =
    addString(new StringBuilder(), start, sep, end).toString

  def mkString(sep: String): String = mkString("", sep, "")

  def mkString: String = mkString("")

能不能用toString呢？
不能哈 toString 默认是打印包名类名hashcode
在这里插入图片描述
变长数组：ArrayBuffer

++  代表加的是类似的数据结构的

在这里插入图片描述

/** Inserts new elements at a given index into this buffer.
 *
 *  @param n      the index where new elements are inserted.
 *  @param elems  the traversable collection containing the elements to insert.
 *  @throws   IndexOutOfBoundsException if the index `n` is not in the valid range
 *            `0 <= n <= length`.
 */
def insert(n: Int, elems: A*) { insertAll(n, elems) }

/** Removes the element on a given index position. It takes time linear in
  *  the buffer size.
  *
  *  @param n       the index which refers to the first element to delete.
  *  @param count   the number of elements to delete
  *  @throws IndexOutOfBoundsException if `n` is out of bounds.
  */
 override def remove(n: Int, count: Int) {
   require(count >= 0, "removing negative number of elements")
   if (n < 0 || n > size0 - count) throw new IndexOutOfBoundsException(n.toString)
   copy(n + count, n, size0 - (n + count))
   reduceToSize(size0 - count)
 }

在这里插入图片描述

/** Removes the last ''n'' elements of this buffer.
 *
 *  @param n  the number of elements to remove from the end
 *            of this buffer.
 */
def trimEnd(n: Int) { remove(length - n max 0, n) }

在这里插入图片描述

（10）高阶函数

map：映射 一一映射

    val a: Array[Int] = Array(1,2,4,5,6,7,8)
    /**
      * map : 一一映射
      * f: A => B    ==>  类似  y = f(x)   里面传的就是 匿名函数 
      */
    a.map((x : Int) => x * 2)

在这里插入图片描述

filter：过滤掉不需要的东西 （true留下 false不留）

在这里插入图片描述

reduce：入参是两个
def reduce[A1 >: A](op: (A1, A1) => A1): A1 = reduceLeft(op)

eg：  可以测试这个东西是个什么鬼
    a.reduce(_+_)
    a.reduceLeft(_-_)
    a.reduceRight((a,b) =>{
      println(a,b)
      a - b
    })

在这里插入图片描述

zip ：  相同位置的放在一块  只有同等位置有的才有 没有就是没有

在这里插入图片描述

flatten：把所有元素抽出来 放到一个Array里面

 /** Flattens a two-dimensional array by concatenating all its rows
   *  into a single array.
   *
   *  @tparam U        Type of row elements.
   *  @param asTrav    A function that converts elements of this array to rows - arrays of type `U`.
   *  @return          An array obtained by concatenating rows of this array.
   */
  def flatten[U](implicit asTrav: T => scala.collection.Traversable[U], m: ClassTag[U]): Array[U] = {
    val b = Array.newBuilder[U]
    b.sizeHint(map{case is: scala.collection.IndexedSeq[_] => is.size case _ => 0}.sum)
    for (xs <- this)
      b ++= asTrav(xs)
    b.result()
  }

flatmap： 注意 flatten 和 flatmap的区别
  def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
    def builder = bf(repr) // extracted to keep method size under 35 bytes, so that it can be JIT-inlined
    val b = builder
    for (x <- this) b ++= f(x).seq
    b.result
  }

在这里插入图片描述
flatmap的入参是 Array[Int] 哟

在这里插入图片描述
map和flatmap的区别
map并没有做压扁操作

在这里插入图片描述

find ： 最多查找出满足条件的第一个元素
  override /*IterableLike*/
  def find(p: A => Boolean): Option[A] = {
    val i = prefixLength(!p(_))
    if (i < length) Some(this(i)) else None
  }

在这里插入图片描述

mapValues:  也是一一映射  map是作用在 value上面的  必须是 kv类型的

groupBy ： 自定义分组  
   def groupBy[K](f: A => K): immutable.Map[K, Repr] = {
    val m = mutable.Map.empty[K, Builder[A, Repr]]
    for (elem <- this) {
      val key = f(elem)
      val bldr = m.getOrElseUpdate(key, newBuilder)
      bldr += elem
    }
    val b = immutable.Map.newBuilder[K, Repr]
    for ((k, v) <- m)
      b += ((k, v.result))

    b.result
  }

在这里插入图片描述

sortBy : 自定义排序     最好利用 List使用
  /** Sorts this $Coll according to the Ordering which results from transforming
   *  an implicitly given Ordering with a transformation function.
   *  @see [[scala.math.Ordering]]
   *  $willNotTerminateInf
   *  @param   f the transformation function mapping elements
   *           to some other domain `B`.
   *  @param   ord the ordering assumed on domain `B`.
   *  @tparam  B the target type of the transformation `f`, and the type where
   *           the ordering `ord` is defined.
   *  @return  a $coll consisting of the elements of this $coll
   *           sorted according to the ordering where `x < y` if
   *           `ord.lt(f(x), f(y))`.
   *
   *  @example {{{
   *    val words = "The quick brown fox jumped over the lazy dog".split(' ')
   *    // this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
   *    words.sortBy(x => (x.length, x.head))
   *    res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)
   *  }}}
   */
  def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Repr = sorted(ord on f)

在这里插入图片描述

（11）scala编写wordcount 先压扁再做操作

代码：好好理解   这块最好结合  mapreduce的wc ： map输出之后 相同的key  把不同的value值放到一个集合里 这个思想是重点
    val wc = Array("spark,flink,hadoop","spark,hive,flink","kafka,flume,kafka")
    
    //1.拆分打平   打平用 flatMap
    val words: Array[String] = wc.flatMap(_.split(","))
    //2.转换kv
    val word2one: Array[(String, Int)] = words.map((_,1))
    //3.自定义分组
    val groupByData: Map[String, Array[(String, Int)]] = word2one.groupBy(_._1)
    //4.按key 求value的sum  
    val result: Map[String, Int] = groupByData.mapValues(x=> x.map(_._2).sum)
    //5.将结果按 value的降序排
    result.toList.sortBy(-_._2)

在这里插入图片描述

正常应该这样写：
    val wc = Array("spark,flink,hadoop","spark,hive,flink","kafka,flume,kafka")
    val resultWithSortDesc: List[(String, Int)] = wc.flatMap(_.split(",")).map((_,1)).groupBy(_._1).mapValues(_.map(_._2).sum).toList.sortBy(-_._2)
    resultWithSortDesc.foreach(println(_))

在这里插入图片描述