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

由于昨天下班后有点困,就没有来及写博客,今天会把它补上!把这个习惯坚持下去!

关于Scala高阶函数详解

  1.Scala高阶函数代码实现:高阶函数就是在我们函数中套用函数

  2.高阶函数代码详解:高阶函数能够让方法的调用更加便捷

  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet

  //(1 to 9)数组中的map方法向数组中放* 用foreach用于来循环 println _ 表示函数,把函数当做参数进行传递
  (1 to 9).map("*" * _).foreach(println _)        //> *
                                                  //| **
                                                  //| ***
                                                  //| ****
                                                  //| *****
                                                  //| ******
                                                  //| *******
                                                  //| ********
                                                  //| *********
  //过滤后被2整除的遍历  println也当做参数进行传递这就是高阶函数
  (1 to 9).filter(_ % 2 == 0) .foreach(println)   //> 2
                                                  //| 4
                                                  //| 6
                                                  //| 8
  //_*_代表数组中两个数据相乘 也属于高阶函数
  println((1 to 9).reduceLeft(_ * _))             //> 362880
  //把字符串用空格分割在按照长度排序
   "Spark is the most exciting thing happening in big data today".split(" ").
        sortWith(_.length < _.length).foreach(println)
                                                  //> is
                                                  //| in
                                                  //| the
                                                  //| big
                                                  //| most
                                                  //| data
                                                  //| Spark
                                                  //| thing
                                                  //| today
                                                  //| exciting
                                                  //| happening
   //ceil函数表示向上取值
   val fun = ceil _                               //> fun  : Double => Double = <function1>
   val num = 3.14                                 //> num  : Double = 3.14
   fun(num)                                       //> res0: Double = 4.0
   Array(3.14, 1.42, 2.0).map(fun)//fun函数当做函数传递   //> res1: Array[Double] = Array(4.0, 2.0, 2.0)
   //函数表示三的倍数
    val triple = (x: Double) => 3 * x             //> triple  : Double => Double = <function1>
    Array(3.14, 1.42, 2.0).map((x: Double) => 3 * x)
                                                  //> res2: Array[Double] = Array(9.42, 4.26, 6.0)
    Array(3.14, 1.42, 2.0).map{ (x: Double) => 3 * x }
                                                  //> res3: Array[Double] = Array(9.42, 4.26, 6.0)
    //定义高阶函数
    def high_order_functions(f: (Double) => Double) = f(0.25)
                                                  //> high_order_functions: (f: Double => Double)Double
    println(high_order_functions(ceil _))         //> 1.0
    println(high_order_functions(sqrt _))         //> 0.5
    //函数相乘
    def mulBy(factor: Double) = (x: Double) => factor * x
                                                  //> mulBy: (factor: Double)Double => Double
    val quintuple = mulBy(5)                      //> quintuple  : Double => Double = <function1>
    println(quintuple(20))                        //> 100.0
         //3的倍数解析
    println(high_order_functions((x: Double) => 3 * x))
                                                  //> 0.75
    high_order_functions((x) => 3 * x)            //> res4: Double = 0.75
    high_order_functions(x => 3 * x)              //> res5: Double = 0.75

    println(high_order_functions(3 * _))          //> 0.75

    val fun2 = 3 * (_: Double)                    //> fun2  : Double => Double = <function1>
    val fun3: (Double) => Double = 3 * _          //> fun3  : Double => Double = <function1>

Scala中SAM转换讲解

  1.SAM的意义:隐式的转换

  2.SAM转换详解

  var data = 0
  val frame = new JFrame("SAM Testing");
  val jButton = new JButton("Counter")
  jButton.addActionListener(new ActionListener {
    override def actionPerformed(event: ActionEvent) {
      data += 1
      println(data)
    }
  })
  //隐式函数就把一些函数定义,好比java中的函数定义模块-->这就可以隐式转换
  implicit def convertedAction(action: (ActionEvent) => Unit) =
    new ActionListener {
      override def actionPerformed(event: ActionEvent) { action(event) }
    }
  //这样是写代码的时候只关心业务逻辑,没有必要去编写没有关系的代码,直接写所需的结果
  jButton.addActionListener((event: ActionEvent) => {data += 1; println(data)})
    //这跟java中的gui编程一样
    frame.setContentPane(jButton);
    frame.pack();
    frame.setVisible(true);  

Scala中curring讲解

  1.curring的定义:curring颗粒度,就是把参数简化成一个参数进行操作,返回后把另外进行计算

  2.curring在项目中重要性:在公式的推到中和计算中相当重要

    //curring颗粒度,就是把参数简化成一个参数进行操作,返回后把另外进行计算
    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(_)))

Scala中模式匹配入门讲解

  1.模式匹配分析:Scala中匹配模式比较灵活,可以传入参数和函数等

  2.在模式匹配中使用守卫:接下的blog中会深入讲解

  3.模式匹配中的变量使用

  //模式匹配在java中用switch来表示,这里面限制不是很多,int,byte,char,short
   val data =2
    data match {
      case 1 => println("First")
      case 2 => println("Second")
      case _ => println("Not Known Number")
    }
    //Scala中case中可以用条件函数也可以是函数,也可以传参数
    val result = data match {
    case i if i == 1 => "The First"
    case number if number ==2 => "The Second" + number
    case _ => "Not Known Number"
    }
    println(result)
    "Spark !" foreach { c => println (
      c match {
        case ‘ ‘ => "space"
        case ch => "Char: " + ch
      }
      )}

这就是拖欠任务,今天会再写一篇关于Scala的学习!希望大家关注王家林老师的微信(18610086859),他会每天都更新大数据的视频!

最新大数据视频74讲:http://pan.baidu.com/s/1hqJByvU

本文百度云地址23-26讲:http://pan.baidu.com/s/1bOsSQ

时间: 2024-10-10 04:58:54

大数据系列修炼-Scala课程07的相关文章

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

前言 今天上班看了很多关于前端js,jQuery.bootstrap.js以及springMVC看得迷迷糊糊的,毕竟以前很少去学习前端的技术,所有看得有点困,还好看得比较多,回家后也开始学习关于Scala相关的课程,实验一下每天坚持做大数据相关的事情,一年后会成为什么样子......期待中....,今天也接着昨天的课程继续. Scala内部类实战详解 Scala内部类详解:scala中内部类要访问外部类直接把外部类的对象给内部类了,让其自己访问,内部类也需要实例化,这和java中有很多的区别,内

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

Scala中继承实现:超类的构造.字段重写.方法重写 关于超类的构建:超类可以在子类没有位置的限制,可以在子类中调用父类的方法 类中字段重写:在重写字段前面加一个override就可以重新赋值 类中方法重写:与字段重写差不多,参数,方法名也要相同 class Person1(val name : String, var age : Int){ println("The primary constructor of Person") val school = "BJU"

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

关于Scala中的正则表达式与模式匹配结合的正则表达式Reg 正则表达式的实现:正则表达式的定义与其它语言差不多,只需在表达式后加一个.r,并且可以遍历相应的表达式进行匹配 //定义的正则表达式 val regex="""([0-9]+) ([a-z]+)""".r //由数字与字母组成的常量 val numPattern = "[0-9]+".r //由数字组成的常量 val numberPattern = "&q

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

接下来会讲解关于各种模式匹配,从中就会知道模式匹配的重要性 关于Type.Array.List.Tuple模式解析 1.Type模式匹配代码解析 //关于Type类型的模式匹配 //匹配 Int类型.string类型.Map类型[_,_]代表任意类型的k,v def match_type(t : Any) = t match { case p : Int => println("It is Integer") case p : String => println("

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

Scala数组操作实战详解 接着昨天的课程,下面我们继续学习关于Scala数组操作详解.Scala数组的定义 //数组定义 //定长数组格式 /** * val arrayName = new Array[datatype](length) * val arrayName = Array(constant1,constant2,....) */ //不定长数组定义格式 /* * var arrayBufferName =ArrayBuffer[datatype]() */ 数组的基本操作:包括截

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

Scala多重继承.构造器的执行顺序.AOP实现 多重继承的trait实现:Scala中接口可以继承具体的类,trait接口可以实现多重继承,并且某个类也可以继承特定的类,在继承后面可以混入,接口的实现 多重继承构造器执行顺序:多重继承构造器执行顺序是从左到右按次序执行,如果前面类以及被继承实现了,后面的类就没有必要去实现,父类只需执行一次 object triatScala { def main(args: Array[String]): Unit = { val t1 = new Piano

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

接着昨天的list,也是学习集合的相关知识 ListBuffer.ArrayBuffer.Queue.stack相关操作 1.ListBuffer.ArrayBuffer代码实现:ListBuffer与ArrayBuffer都是mutable可变的与java中的定义也差不多,可以追加的. 2.Queue.Stack相关操作:队列是一端进去一端出来,而stack也是后进先出的原则,他们都是mutable可变的 import scala.collection.mutable.ListBuffer v

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

今天主要是关于Scala中对List的相关操作,list在Scala中应该是至关重要,接下来会讲解关于List的一系列操作 List的map.flatMap.foreach.filter操作讲解 1.关于List的Map.flatMap操作.区别 2.对List的foreach.filter操作 //list中的Map中用一个函数表达式-->实则是对list进行操作,_可以表示一个函数或者表达式 List(1, 2, 3, 4, 6) map (_ + 1) //> res0: List[In

好程序员大数据教程分享Scala系列之Option_偏函数_String

好程序员大数据教程分享Scala系列之Option_偏函数_StringOption类型在Scala中Option类型样例类用来表示可能存在或也可能不存在的值(Option的子类有Some和None).Some包装了某个值,None表示没有值. object OptionDemo {def main(args: Array[String]) {val map = Map("a" -> 1, "b" -> 2)val v = map.get("b