Scala零基础教学【21-40】

第24讲：Scala中SAM转换实战详解

SAM：single abstract method 单个抽象方法

我们想传入一个函数来指明另一个函数具体化的工作细节，但是重复的样板代码很多。

我们不关心它实现了什么接口的什么方法，只关心这个动作。比如下面的按钮点击一次，data就加1，而不关心ActionListener以及其回调方法。

那么就用隐式转换。这个后面会彻底地讲解。

第25讲：Scala中Curring实战详解

柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。

从数学的角度讲，这是一个对函数消元求解的过程：

def f(x:Int,y:Int)=x+y

def g(x:Int)=f(x,1)

def z=g(1)

z=2

那么z也可以写成这样：def z=(x:Int)=>(y:Int)=>x+y

例如：

def add(x:Int,y:Int)=x+y

柯里化后：

def add(x:Int)(y:Int)=x+y

实际实现是scala的语法糖，依次调用两个普通函数，第一次调用函数（x）,第二次调用时使用了(x)的返回值。

def add=(x:Int)=>(y:Int)=>x+y

那么具体怎么实现柯里化呢？

假设我原始的普通函数 def add(x:Int,y:Int)=x+y

目标函数是Int=>Int=>Int (或者Int=>(Int=>Int))

大概长这样def add=(x:Int)=>(y:Int)=>x+y

抽象出来是[参数1=>参数2=>function(参数1，参数2)]
柯里化函数：
def curry[A,B,C](f: (A, B) => C): A => (B => C) = a => b => f(a, b)

curry: [A, B, C](f: (A, B) => C)A => (B => C)

用柯里化函数调用非柯里化函数add后：

def add(x:Int,y:Int)=x+y

def addCurry=curry(add)

addCurry: Int => (Int => Int)

测试：

addCurry(1)(2)

res10: Int = 3

package com.wanji.scala.function

object Curring {

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

    def multiple(x:Int,y:Int)=x*y

    def multipleOne(x:Int)=(y:Int)=>x*y

    println(multipleOne(6)(7))

    def curring(x:Int)(y:Int)=x*y

    println(curring(10)(10))

    val a=Array("Hello","Spark")

    val b=Array("Hello","spark")

    println(a.corresponds(b)(_.equalsIgnoreCase(_)))

  }

}

第28讲：Scala提取器Extractor实战详解　

第29讲：Case class和Case object代码实战解析

第30讲：模式匹配高级实战：嵌套的Case class

第31讲：Option使用和实现内幕源码揭秘

第36讲：List的partition、find、takeWhile、dropWhile、span、forall、exsists操作代码实战

val r1 = s1.takeWhile( _ < 10)
r1: List[Int] = List(1, 2, 3, 4)
takeWhile是从第一个元素开始，取满足条件的元素，直到不满足为止
val r2 = s1.filter( _ < 10)
r2: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)
fiter取出所有满足条件的元素
差异：
fiter取所有的满足条件的元素；
takeWhile取出从第一个开始满足条件的元素，直到遇到不满足条件的元素

    println(List(, , , , ) partition (_ %  ==))

    //find:查找集合第一个符合条件的元素

    println(List(, , , , ) find (_ %  ==))

    println(List(, , , , ) find (_  <=))

    //takeWhile:着个匹配符合条件的元素 直到不符合条件 之后的元素不在判断

    println(List(, , , , ) takeWhile (_  < ))

    //dropWhile:着个匹配去除符合条件的元素 直到不符合条件 之后的元素不在判断

    println(List(, , , , ) dropWhile (_  < ))

    //span 着个匹配按照某种条件对数据进行分类 直到不符合条件 之后的元素不在判断

    println(List(, , , , ) span (_  < ))

    //forall  当所有的元素满足条件时 返回true 否则返回false

    //exists  当存在(至少有一个满足)元素满足条件时 返回true 否则返回false

    def hastotallyZeroRow(m: List[List[Int]]) = m exists (row => row forall (_ == ))

    val m= List(List(,,), List(,,), List(,,))

    println(List(,,) forall(_==))

    println(List(,,) forall(_==))

    println(List(,,) forall(_==))

    println(hastotallyZeroRow(m))

第37讲：List的foldLeft、foldRight、sort操作代码实战

foldLeft定义：

def foldLeft[B](z: B)(op: (B, A) => B): B = {

    var result = z

    this.seq foreach (x => result = op(result, x))

    result

}

方法接受2个参数，z和op，一个是B类型的参数，一个是返回B类型的函数。

在看到这个trait其实是TraversableOnce，可迭代的集合。

def seq: TraversableOnce[A]

比如一个val listA = List(1，2，3)

listA其实是实现了TraversableOnce这个trait的。

我们可以直接使用：

scala> listA.foldLeft(0)((sum,i)=>sum+i)
res26: Int = 6

这个里面的0其实就是z返回值是Int类型即B类型

那么可以看出op这个函数返回值也需要是Int类型

可以看出

val result = z，这里其实就是0，x=>result=op(result, x) ， sum其实也是z

其实z就是返回值，this.seq在这里就是list，对list遍历，这里执行op函数。

这里我们执行的是sum+i，就是累加了1+2+3=6

    println(List(1 to 5))

    //传递的参数在左参数

    //(10-1)-2-3-4-5=-5

    println((1 to 5).foldLeft(10)(_-_))

    //传递的参数在右参数，结果在右

    //(1-10)=-9

    //2-(-9)=11

    //3-11=-8

    //4-(-8)=12

    //5-12=-7

    println((1 to 5).foldRight(10)(_-_))

第38讲：List伴生对象操作方法代码实战

   //apply:根据元素构建对象

    println(List.apply(1, 2, 3))

    //make:重复构建，第一个参数个数，第二个参数是数值

    println(List.make(3, 5))

    //range:构建元素集合(1,2,3,4)

    println(List.range(1, 5))

    //rang:最后的元素是步长，(9,6,3)

    println(List.range(9, 1, -3))

    val zipped = "abcde".toList zip List(1, 2, 3, 4, 5)

    //List((a,1),(b,2),(c,3),(d,4),(e,5))

    println(zipped)

    //(List(a,b,c,d,e),List(1,2,3,4,5))

    println(zipped.unzip)

    //flatten:多个集合中的元素放到一个集合中

    println(List(List('a', 'b'), List('c'), List('d', 'e')).flatten)

    //多个集合拼接，类似flatten

    println(List.concat(List(), List('b'), List('c')))

    //map2:索引相同的元素操作之后放入新的集合中

    println(List.map2(List(10, 20), List(10, 10)) (_ * _))

　　结果：

List(1, 2, 3)

List(5, 5, 5)

List(1, 2, 3, 4)

List(9, 6, 3)

List((a,1), (b,2), (c,3), (d,4), (e,5))

(List(a, b, c, d, e),List(1, 2, 3, 4, 5))

List(a, b, c, d, e)

List(b, c)

List(100, 200)

第39讲：ListBuffer、ArrayBuffer、Queue、Stack操作代码实战

    import scala.collection.mutable.ListBuffer

    //可变的ListBuffer,默认不可变

    val listBuffer = new ListBuffer[Int]

    listBuffer += 1

    listBuffer += 2

    println(listBuffer)

    import scala.collection.mutable.ArrayBuffer

    val arrayBuffer = new ArrayBuffer[Int]()

    arrayBuffer += 1

    arrayBuffer += 2

    println(arrayBuffer)

    val empty = Queue[Int]()

    //入队列操作 enqueue

    val queue1 = empty.enqueue(1)

    val queue2 = queue1.enqueue(List(2,3,4,5))

    println(queue2)

    //出队列操作 dequeue  def dequeue: (A, Queue[A])

    val (element, left) = queue2.dequeue

    println(element + " : " + left)

    println("immutable:"+queue2)

    println(queue2.dequeue)

    println("immutable为不可变队列:"+queue2)

    import scala.collection.mutable.Queue

    val queue3=Queue[Int]()

    queue3++=List(1,2,3,4,5)

    println(queue3.dequeue())

    println("mutable:"+queue3)

    val queue = Queue[String]()

    queue += "a"

    queue ++= List("b", "c")

    println(queue)

    println(queue.dequeue)

    println(queue)

    import scala.collection.mutable.Stack

    val stack = new Stack[Int]

    stack.push(1)

    stack.push(2)

    stack.push(3)

    //top仅仅是get操作，pop是获取加出栈

    println(stack.top)

    println(stack)

    println(stack.pop)

    println(stack)

第40讲：Set、Map、TreeSet、TreeMap操作代码实战

   //Set 无序集合

    val data = mutable.Set.empty[Int]

    data ++= List(1, 2, 3)

    data += 4;

    data --= List(2, 3);

    println(data)

    data += 1;

    println(data)

    data.clear

    println(data)

    val map = mutable.Map.empty[String, String]

    map("Java") = "Hadoop"

    map("Scala") = "Spark"

    println(map)

    println(map("Scala"))

    //TreeSet 有序的集合

    val treeSet = TreeSet(9, 3, 1, 8, 0, 2, 7, 4, 6, 5)

    println("有序集合TreeSet:"+treeSet)

    val treeSetForChar = TreeSet("Spark", "Scala", "Hadoop")

    println(treeSetForChar)

    val treeSet2=TreeSet(0,1,2,3,4,5,6,7,8,9)

    println(treeSet2)

    var treeMap = TreeMap("Scala" -> "Spark", "Java" -> "Hadoop")

    println(treeMap)