Scala函数式编程【从基础到高级】

这篇具有很好参考价值的文章主要介绍了Scala函数式编程【从基础到高级】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

函数基础

基本语法

函数参数

函数至简原则

至简原则细节

 函数高级

高阶函数

函数的3种高阶用法:

1、函数作为值传递

2、函数作为参数传递

匿名函数作参数传递

3、函数作为返回值传递

匿名函数的至简规则

高阶函数的应用 

案例-将数组中的元素全部+1后返回

 匿名函数

练习1-匿名函数作为值传递:

练习2-函数作为返回值

 函数柯里化&闭包

案例2的闭包实现:

案例2的柯里化实现:

闭包案例 - 常量a+变量b

案例 - 柯里化

递归

斐波那契数列

阶乘 

尾递归

Scala实现尾递归求阶乘 

Java实现尾递归求阶乘

控制抽象

传值调用

传名调用

应用案例 - 自定义函数实现while  

惰性加载


函数基础

        Scala 的函数式编程以及面向对象的特点,使它能够很好的应用到大数据场景下,比如 Spark、Kafka 的底层都是 Scala 编写的。

基本语法

        在Java中,方法只能够在类下面声明,不可以在main方法以及其它方法内部声明,但是Scala可以,因为Scala是一个函数式编程,函数是一等公民。

        所以,我们通常把main方法内部定义的方法叫做函数,main外部声明的方法才叫做对象的方法。

object Test{

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

    //定义函数
    def sayHello(name: String): Unit = {
      println("hello " + name)
    }

    //调用函数
    sayHello("GGBond")

    //调用对象的方法
    Test01_Function.sayHello("Tom")
  }

  //定义对象的方法
  def sayHello(name: String): Unit = {
    println("hello " + name)
  }
}

        可以看到,我们可以直接通过函数名调用函数,但是在伴生类中,一切类变量和方法都是静态的,所以我们需要通过类名才可以调用方法。

函数参数

  1. 可变参数
  2. 如果参数列表中存在多个参数,那么可变参数一般放置在最后
  3. 参数默认值,一般将有默认值的参数放置在参数列表的后面
  4. 带名参数
def main(args: Array[String]): Unit = {

    //1.可变参数
    def f1(names: String*): Unit = {
      println(names)
    }
    f1("alice","tom","GG bond")

    //2.如果参数列表中存在多个参数,那么可变参数一般放置在最后
    def f2(grade: String, names: String*): Unit = {
      println(grade)
      println(names)
    }
    f2("大二","alice","tom","GG bond")

    //3.参数默认值,一般将有默认值的参数放置在参数列表的后面
    def f3(name: String = "GG bond"): Unit = {
      println(name)
    }
    f3()
    f3("燕双鹰")

    //4.带名参数
    def f4(name: String, age: Int): Unit = {
      println(s"${name}的年龄=${age}")
    }
    f4("GG bond",14)
    f4(age = 13,name = "熊大")
  }

函数至简原则

代码能省则省

至简原则细节

  • return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
  • 如果函数体只有一行代码,可以省略花括号
  • 返回值类型如果能够推断出来,那么可以省略(:和返回值类型一起省略)
  • 如果有 return,则不能省略返回值类型,必须指定
  • 如果函数明确声明 unit,那么即使函数体中使用 return 关键字也不起作用
  • Scala 如果期望是无返回值类型,可以省略等
  • 如果函数无参,但是声明了参数列表,那么调用时,小括号,可加可不加
  • 如果函数没有参数列表,那么小括号可以省略,调用时小括号必须省略
  • 如果不关心名称,只关心逻辑处理,那么函数名(def)可以省略
object Test{

  def main(args: Array[String]): Unit = {
    //(1)return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
    def f0(name: String): String = {
      return name
    }
    println(f0("GG bond"))

    def f1(name: String): String = {
      name
    }
    println(f1("GG bond"))
    //(2)如果函数体只有一行代码,可以省略花括号
    def sum(a: Int,b: Int): Int = a+b

    //(3)返回值类型如果能够推断出来,那么可以省略(:和返回值类型一起省略)
    def add(a: Int,b: Int) = a+b  //因为参数都是Int类型,所以可以自己推断返回值类型

    //(4)如果有 return,则不能省略返回值类型,必须指定
    def f3(name: String): String = {
      return name
    }


    //(6)Scala 如果期望是无返回值类型,可以省略等号
    def f4(name: String){
      println("hello")
    }

    //(7)如果函数无参,但是声明了参数列表,那么调用时,小括号,可加可不加
    def f5() = "name"
    println(f5)

    //(8)如果函数没有参数列表,那么小括号可以省略,调用时小括号必须省略
    def f6 = "hi"

    //(9)如果不关心名称,只关心逻辑处理,那么函数名(def)可以省略
    def say_Hi(name: String): Unit = {
      println("hi" + name)
    }
    //匿名函数 匿名函数的返回值是一个函数
    val say_Hello = (name: String) => {"hello " + name}
    //调用匿名函数
    println(say_Hello("GG bond"))


  }

}

 函数高级

高阶函数

        高阶函数指的是接受一个或多个函数作为参数,并返回一个函数作为结果的函数。函数是Scala中的一等公民,地位很高,这体现在它可以在main方法中直接定义并通过函数名来直接使用,而不用向Java一样,需要再对象下面声明方法,来通过对象或者类名来调用。高阶函数可以减少代码的重复,并增加代码的灵活性和可重用性。

        通常我们的业务数据在高阶函数中写死,等待传进来的函数参数来作处理。

函数的3种高阶用法:

  1. 函数作为值传递
  2. 函数作为参数传递
  3. 函数作为返回值
1、函数作为值传递

        函数作为返回值赋值给一个变量,这个变量类型是一个函数对象。如果直接输出的话,如果这个函数没有参数,将直接输出这个函数的返回值,否则直接输出这个对象的地址(对象引用)。我们也可以通过返回值来直接使用,因为返回值本身就是一个函数对象,我们可以直接+(参数)来调用函数。

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

    //定义一个普通函数 输入num返回num+1
    def f(num: Int): Int = {
      num + 1
    }

    //1.函数作为值传递 -两种方式返回函数对象
    val f1: Int => Int = f
    val f2 = f _

    //我们可以直接输出函数对象,也可以直接利用函数对象进行使用传递参数
    println(f1)   //输出这个对象的地址(也叫对象引用)
    println(f1(9))
    println(f2)   //输出这个对象的地址(也叫对象引用)
    println(f2(10))

    //定义一个函数无参,直接返回1
    def fun(): Int = {
      1
    }

    val f3 = fun    //因为fun是无参的,所以这里返回的是返回值 1
    val f4 = fun _  //返回函数体
    val f5: () => Int = fun

    println(f3)   //输出 1
    println(f4)   //输出这个对象的地址(也叫对象引用)
    println(f5)   //输出这个对象的地址(也叫对象引用)

  }
2、函数作为参数传递

  我们可以定义两个函数,分别实现两个数的加和减,然后我们可以将这两个函数作为参数传递给另一个函数,来实现对两个数的处理(数据是写死的)。

    //定义一个函数 sum 求和
    def sum(a: Int,b: Int): Unit = {
      println(s"${a} + ${b} = ${a+b}")
    }

    //定义一个函数 sub 求差,函数体只有一行可以省去花括号{}
    def sub(a: Int,b: Int): Unit = println(s"${a} - ${b} = ${-b}")

    def fun(f: (Int,Int) => Unit):Unit = {
      f(1,2)
    }

    fun(sum)    //输出 1 + 2 = 3
    fun(sub)    //输出 1 - 2 = -1

        前面我们数据是写死的,也就是说,我们的高阶函数只能够对 1和2进行处理,显然很没用!这里我们直接将要计算的数据页当做参数传递进来。

def doEval(f: (Int,Int) => Int,a: Int ,b: Int): Int = {
      f(a,b)
    }

    def add(a: Int,b: Int): Int = {
      a + b
    }
    //使用普通函数作为参数
    doEval(add,1,2)
    //使用匿名函数做参数
    doEval((a,b) => a + b,1,2)
    //简化代码
    doEval(_ + _,1,2)
匿名函数作参数传递

我们可以直接将匿名函数作参数传入fun,更加简化代码。

//以函数作为参数
    def fun(f: (Int,Int) => Unit): Unit = f(1,2)

    //直接传入匿名函数
    fun((a: Int,b: Int) => println(s"${a} + ${b} = ${a+b}")))   //输出 1 + 2 = 3
    //高阶函数定义了函数参数的类型,匿名函数这里就不需要再指定函数类型了
    fun((a,b) => println(s"${a} - ${b} = ${a-b}")))   //输出 1 - 2 = -1
3、函数作为返回值传递

函数作为返回值后返回函数对象,我们可以通过函数对象来使用该函数。

//3.函数作为返回值传递
    def f6(): Int => Unit = {
      def f7(a: Int): Unit = {
        println("f7被调用 " + a)
      }
      f7  //返回函数对象
    }

    //获取f7函数对象 并使用
    val res  = f6()
    //输出:
    //  f7被调用 10
    //  ()
    //  因为f7的返回值为 Unit类型
    println(res(10))

匿名函数的至简规则

  1. 参数的类型可以省略,会根据形参进行自动的推导
  2. 类型省略之后,发现只有一个参数,则圆括号可以省略;其他情况:没有参数和参 数超过 1 的永远不能省略圆括号。
  3. 匿名函数如果只有一行,则大括号也可以省略
  4. 如果参数只出现一次,则参数省略且后面参数可以用下划线 _ 代替
    //定义一个函数,以函数作参数
    def say_Name(f: String => Unit): Unit = f("GG Bond")
    
    //普通调用
    say_Name((name: String) => {println(name)})
    
    //1.参数的类型可以省略,会根据形参进行自动的推导
    say_Name( (name) => {println(name)})
    
    //2.如果参数只有一个 括号省略
    say_Name( name => {println(name)} )

    //3.匿名函数如果只有一行,则大括号可以省略
    say_Name( name => println(name) )

    //4.如果参数只出现一次,则参数省略且后面参数可以用_代替
    say_Name( println(_) )

    //5.如果可以推断出当前传入的println()是一个函数体,而不是调用语句,可以直接省略_
    say_Name( println )

高阶函数的应用 

高阶函数对集合的处理更加体现了Sala对于处理大数据的优势。

案例-将数组中的元素全部+1后返回
val arr: Array[Int] = Array(1,2,4,3,8)

    //对数组进行处理,把对数组的操作进行抽象

    /**
     *
     * @param array 待处理的数组
     * @param op 操作函数(Int => Int)将数组中的数处理后变为另一个数
     * @return 返回新数组
     */
    def arrayOperation(array: Array[Int], op: Int => Int): Array[Int] = {
      for (elem <- array) yield op(elem)
    }

    //定义操作函数
    def addOne(elem: Int): Int = elem + 1

    //调用函数
    val res_arr: Array[Int] = arrayOperation(arr,addOne)

    //用逗号间隔输出新数组的内容
    println(res_arr.mkString(","))

    //使用匿名函数实现
    val res2_arr = arrayOperation(arr,elem => elem + 1)
    //这里的后面的elem可以用下划线代替 _
    val res2_arr = arrayOperation(arr,elem => _ + 1)
    println(res2_arr.mkString(","))

 匿名函数

前面已经用过了,这里在详细解释一下。

说明:没有函数名的函数就是匿名函数。

表达式:(a: Int,b: Int)=>{函数体}

注意匿名函数的定义没有返回值类型,但是可以作为高阶函数的参数时指定

//以函数作为参数
    def fun(f: (Int,Int) => Int): Unit = f(1,2)

    //直接传入匿名函数
    fun((a: Int,b: Int) => a + b ))   //返回 3
    //高阶函数中指定了参数函数的参数类似,所以这里可以省去匿名函数的参数类型
    fun((a,b) => a - b ))   //返回-1

    //如果每个参数只出现一次,可以这样写
    fun( _ + _)    //对应 a + b
    fun( _ - _)    //对应 a - b
    //如果要实现 b-a 可以写作 -a+b
    fun((a,b) => -a + b)    
    fun( -_ + _)    //对应 -a + b
练习1-匿名函数作为值传递:

定义一个匿名函数,并将它作为值赋给变量 fun。函数有三个参数,类型分别为 IntStringChar,返回值类型为 Boolean

要求:调用函数 fun(0, “”, ‘0’)得到返回值为 false,其它情况均返回 true

//匿名函数在没被高阶函数指定返回值类型的时候,需要声明参数名和类型
    val fun = (a: Int,b: String,c: Char) => {
      if (a == 0 && b == "" && c == '0')
        false
      else
        true
    }

    println(fun(1,"",'0'))    //true
练习2-函数作为返回值

        定义一个函数 func,它接收一个 Int 类型的参数,返回一个函数(记作 f1)。 它返回的函数 f1,接收一个 String 类型的参数,同样返回一个函数(记作 f2)。函数 f2 接 收一个 Char 类型的参数,返回一个 Boolean 的值。

        要求调用函数 func(0) (“”) (‘0’)得到返回值为 false,其它情况均返回 true

//表示返回一个输入类型为String输出类型为(Char => Boolean)的函数
def func(a: Int): String => (Char => Boolean) = {
      //表示返回一个输入类型为Char输出类型为Boolean的函数
      def f1 (b: String): Char => Boolean = {
        //表示返回一个返回值类型为Boolean的值
        def f2(c: Char): Boolean = {
          if (a == 0 && b == "" && c == '0') false else true
        }
        f2
      }
      f1
    }

    println(func(0)("")('0'))    //false

使用匿名函数简写

 函数柯里化&闭包

  • 闭包:如果一个函数 ,访问到了它外部变量的值,那么这个函数和它所处的环境,称为闭包
  • 函数柯里化:把一个参数列表的多个参数,变成多个参数列表。

        我们学习闭包和柯里化是为了更加简洁地实现调用上层函数的参数,因为在上面的案例2中,我们通过嵌套函数来实现读取上层函数的参数显然代码很复杂,所以我们可以使用柯里化来实现。

案例2的闭包实现:

//匿名函数简写
    def func1(a: Int): String => (Char => Boolean) = {
      //外层指定了返回值类型 内层的匿名函数就不需要指定参数类型
      b => c => if (a == 0 && b == "" && c == '0') false else true
    }

    
    println(func(1)("")('0'))    //tue

案例2的柯里化实现:

//柯里化
    def func2(a: Int)(b: String)(c: Char): Boolean = {
      if (a == 0 && b == "" && c == '0') false else true
    }

//调用
    println(func2(0)("")('0'))    //true

 我们可以看到,柯里化更加简单,其实柯里化的底层就是闭包来实现的。

闭包案例 - 常量a+变量b

        这并不是一个简单的两数相加,因为实际开发中,我们可能遇到大量的变量对常量不断运算,比如大量数字分别对4相加、对5相加,这就需要定义两个函数addByFour、addByFive;但是如果常量有几百种呢,这就需要定义几百个函数,显然过于复杂。所以这就需要使用双层嵌套函数,以返回值为函数:第一层函数输入常量,第二层函数输入变量。

//A是任意常量
    def addByA(a: Int): Int=>Int = {
      def addB(b: Int): Int = {
        a + b
      }
      addB
    }
    
    //不断简化代码
    
//既然直接返回函数 我们直接定义一个匿名函数即可 scala默认返回最后一行(一个方法可以看作一行)作为返回值
    def addByA1(a: Int): Int=>Int = {
      (b: Int) => a + b
    }
    //指定外层函数指定了返回值类型 内层就不需要写输入类型了
    def addByA2(a: Int): Int=>Int = b => a + b

    //内层的变量 b 只在函数体出现了一次 所以可以用 _ 替换
    def addByA3(a: Int): Int=>Int = a + _

     //调用
    val fun = addByA3(5)    //接收一个函数(任意数+5)作为返回值 
    println(fun(10))    //调用函数 输出15

案例 - 柯里化

        在纯粹的函数式编程中其实是不存在多参数这样的定义的,只是Scala为了兼容其它语言才不做限制的。所以引入柯里化来实现这样的一个效果,将一个含多个参数的参数列表转变为多个仅含一个参数的参数列表。

        柯里化的底层就是闭包。

    //柯里化 底层是闭包实现分层调用
    def addCurrying(a: Int)(b: Int): Int = a + b
    //调用
    println(addCurrying(4)(36))

递归

斐波那契数列

def fb(i: Int): Int = {
      if (i ==1 || i == 2)
        1
      else
        fb(i-1) + fb(i+2)
    }

阶乘 

def jieC(n: Int): Int = {
      if (n==1)
        1
      else
        jieC(n-1)*n

    }

尾递归

        我们知道,在做递归的时候,我们其实是方法不断调用,比如上面的阶乘案例,当我们希望得到5的阶乘时,函数的调用会不断压栈,到达阶乘的最小值1的时候原路返回。显然如果是10亿的阶乘,肯定会造成栈溢出的问题。

Scala函数式编程【从基础到高级】

 

        所以这就需要引入尾递归的概念,上面的普通递归需要不断压栈最后出栈,比如5的阶乘,它的返回值是 1 -> 2*1 -> 3*2*1 -> 4*3*2*1 -> 5*4*3*2*1

        而我们的尾递归刚好相反,它的返回值是 5 -> 5*4 -> 5*4*3 -> 5*4*3*2 -> 5*4*3*2*1,这样,在调用函数时,不会创建新的栈帧,而是直接复用当前栈帧,因此占用的栈资源是固定的。

Scala实现尾递归求阶乘 
def tailJieC(n: Int): Int = {
      def loop(n: Int,tmp: Int): Int = {
        if (n==0)
          return tmp
        loop(n - 1,tmp * n)
      }
      loop(n,1)
    }
Java实现尾递归求阶乘
public static int JC(int n){
        return loop(n,1);
    }
    public static int loop(int n,int tmp){
        if (n==0){
            return tmp;
        }else {
            return loop(n-1,tmp*n);
        }
    }

控制抽象

传值调用

参数类型:普通参数

println("=====传值调用======")
    //1.传值参数
    def f0(a: Int): Unit = {
      println("a = " + a)
    }

    //数值做参数
    f0(1)

    def f1(): Int = {
      println("f1被调用")
      2
    }

    //函数返回值做参数
    f0(f1())

输出结果

1
2

 

传名调用

参数类型:传递的不再是具体的值,而是代码块


    println("=====传名调用======")
    def f1(): Int = {
      println("f1被调用")
      2
    }

    //2.传名参数
    //f2的参数是代码块 要求代码块的返回值是Int
    def f2(a: => Int): Unit = {
      println("a = " + a)
      println("a = " + a) //a被调用几次 代码块就被执行几次
    }

    f2(23)    //输出两个23

    f2(f1())  //执行两次f1() 相当于把f2的函数体中的 a 都替换做 f1() 这也说明传名调用传递的是代码块而不是返回值

   
    f2({
      println("这是一个代码块")
      20
    })

输出结果

=====传名调用======
a = 23
a = 23
f1被调用
a = 2
f1被调用
a = 2
这是一个代码块
a = 20
这是一个代码块
a = 20

应用案例 - 自定义函数实现while  

//1.常规的while循环
    var n = 10
    while (n > 0){
      println(n)
      n -= 1
    }

    //2.自定义函数实现while
    // 用闭包实现一个函数,将代码块作为参数传入,递归调用
    def myWhile(condition: =>Boolean): (=>Unit)=>Unit = {
      //内层实现递归 参数就是循环体-代码块
      def doLoop(op: => Unit): Unit= {
        if (condition){
          op
          myWhile(condition)(op)
        }
      }
      doLoop _
    }
    //给n重新赋值
    n = 10
    myWhile(n >= 1)({
      println(n)
      n -=1
    })

简化代码

    //3.用匿名函数简化代码
    def myWhile2(condition: =>Boolean): (=>Unit)=>Unit = {
      //内层实现递归 参数就是循环体-代码块
      op => {
        if (condition){
          op
          myWhile2(condition)(op)
        }
      }
    }

    //4.用柯里化简化代码
    def myWhile3(condition: => Boolean)(op: =>Unit): Unit = {
      if (condition){
        op
        myWhile2(condition)(op)
      }
    }

惰性加载

        懒加载(Lazy Loading)是一种常见的优化策略,它可以延迟对象的初始化时间,减少应用程序的启动时间和内存消耗。在懒加载的策略下,只有在需要访问具体的对象时才会进行初始化。在Scala中,我们使用关键字 'lazy' 来实现懒加载。文章来源地址https://www.toymoban.com/news/detail-510970.html

lazy val res: Int = compute()

def compute(): Int = {
  // 进行复杂的计算
  Thread.sleep(1000)
  //返回计算结果
  100
}

到了这里,关于Scala函数式编程【从基础到高级】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • scala函数式编程

    参考 https://juejin.cn/post/7006243598714798094 https://www.cnblogs.com/listenfwind/p/11209383.html https://docs.scala-lang.org/zh-cn/scala3/book/introduction.html https://bbs.huaweicloud.com/blogs/126988 https://bbs.huaweicloud.com/blogs/126988 https://mp.weixin.qq.com/s?__biz=MzAxOTc0NzExNg==mid=2665513393idx=1sn=c1d6caca8ef9972f1105df982f15bb58chksm=80d

    2024年01月20日
    浏览(43)
  • Scala学习(三)---函数式编程

    Scala语言是一个完全面向对象的编程语言。万物皆是对象 对象的本质:对数据和行为的一个封装 在解决问题的时候,将问题分解成一个个的步骤,将每一个步骤进行封装(函数),通过调用这些封装好的步骤来解决问题。 Scala语言是一个完全函数式编程的语言。万物皆是函数。

    2024年02月04日
    浏览(35)
  • Scala 05 —— 函数式编程底层逻辑

    该文章来自2023/1/14的清华大学交叉信息学院助理教授——袁洋演讲。 函数式编程 什么是函数式编程? y=f(x) 无副作用: y只是依赖x,不会依赖其他变量 确定性关系:重新跑100次代码,得到的结果是一样的 不会给世界带来副作用。算完f(x)然后就得到了y,其他什么都没变。 什

    2024年04月29日
    浏览(38)
  • 你知道Scala编程语言吗?Scala基础教程【建议收藏】

    作者:i阿极 作者简介:Python领域新星作者、多项比赛获奖者:博主个人首页 😊😊😊如果觉得文章不错或能帮助到你学习,可以点赞👍收藏📁评论📒+关注哦!👍👍👍 📜📜📜如果有小伙伴需要数据集和学习交流,文章下方有交流学习区!一起学习进步!💪 Scala是一种

    2023年04月08日
    浏览(80)
  • 2023_Spark_实验九:Scala函数式编程部分演示

    需求: 1、做某个文件的词频统计//某个单词在这个文件出现次数 步骤: 1、文件单词规律(空格分开) 2、单词切分 3、单词的统计 (k,v)-(k:单词,V:数量) 4、打印 框架: 1、单例对象,main() 2、创建CONF 3、创建SC--读取文件的方式--》RDD 4、RDD进行处理 5、关闭资源 一、新

    2024年02月08日
    浏览(44)
  • 2023_Spark_实验七:Scala函数式编程部分演示

    1、Scala中的函数 在Scala中,函数是“头等公民”,就和数字一样。可以在变量中存放函数,即:将函数作为变量的值(值函数)。 2、匿名函数 3、带函数参数的函数,即:高阶函数 示例1: (*)首先,定义一个最普通的函数 (*)再定义一个高阶函数 (*)分析这个高阶函数

    2024年02月08日
    浏览(58)
  • Scala的函数式编程与高阶函数,匿名函数,偏函数,函数的闭包、柯里化,抽象控制,懒加载等

    函数式编程 解决问题时,将问题分解成一个一个的步骤,将每个步骤进行封装(函数),通过调用这些封装好的步骤,解决问题。 例如:请求-用户名、密码-连接 JDBC-读取数据库 Scala 语言是一个完全函数式编程语言。万物皆函数。 函数的本质:函数可以当做一个值进行传递

    2024年02月09日
    浏览(52)
  • 《Spark编程基础Scala版》第一章习题答案

    1、请阐述大数据处理的基本流程。 2、请阐述大数据的计算模式及其代表产品 3、请列举Hadoop生态系统的各个组件及其功能。 4、分布式文件系统HDFS的名称节点和数据节点的功能分别是什么? 名称节点: 数据节点: 5、试阐述MapReduce的基本设计思想 6、YARN的主要功能是什么?

    2024年02月06日
    浏览(71)
  • 大数据课程J2——Scala的基础语法和函数

    文章作者邮箱:yugongshiye@sina.cn              地址:广东惠州 ⚪ 掌握Scala的基础语法; ⚪ 掌握Scala的函数库; 语句 说明 示例 var 用来声明一个变量, 变量声明后,在程序执行过程中可以被修改。  def main(args: Array[String]): Unit = {     var var1=100     var var2:Int=100    //变量

    2024年02月12日
    浏览(39)
  • scala基础编程案例--定义一个类Rational支持有理数的运算

    1)定义一个类Rational,分子与分母作为类参数; 2)重写toString方法; 3)前提条件检查(分母是否为0检查); 4)定义add方法实现两个有理数相加; 5)为 Rational 定义一个辅助构造函数,当分母为1时调用该辅助构造函数; 6)定义一个求分子分母最大公约数的方法,用于有理

    2024年02月04日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包