备案控制台
探索云世界
开发者社区 大数据 文章 正文

Scala学习--day03--函数式编程

2024-02-19 63
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Scala学习--day03--函数式编程

函数式编程

image.png

不同范式对比：

  • 面向过程：按照步骤解决问题。
  • 面向对象：分解对象、行为、属性，通过对象关系以及行为调用解决问题。耦合低，复用性高，可维护性强。
  • 函数式编程：面向对象和面向过程都是命令式编程，但是函数式编程不关心具体运行过程，而是关心数据之间的映射。纯粹的函数式编程语言中没有变量，所有量都是常量，计算过程就是不停的表达式求值的过程，每一段程序都有返回值。不关心底层实现，对人来说更好理解，相对地编译器处理就比较复杂。
  • 函数式编程优点：编程效率高，函数式编程的不可变性，对于函数特定输入输出是特定的，与环境上下文等无关。函数式编程无副作用，利于并行处理，所以Scala特别利于应用于大数据处理，比如Spark，Kafka框架。
object Scala01Function {
  def main(args: Array[String]): Unit = {
    //TODO 函数式编程语言
    //1.scala中的函数并不是数学中函数
    //   这里的函数其实表示的就是功能的封装,java中功能的封装一般称之为方法
    //2.java中方法其实在scala中就是函数,但是声明在类中的函数称为方法
    //函数只在当前作用域有效，但是方法需要受到类的约束
    //3.因为函数其实就是功能的封装，也就是意味着，功能的名称不能重复，也不能重写,重载的概念
    //因为方法属于类,那么就可能存在方法的重载，重写
    val s="zhangsan"
    val newString=s.substring(0,1).toUpperCase()+s.substring(1)
    println(newString)
    val s1="list"
    //TODO 函数的声明和使用
    //def:scala语言声明方法的关键字
    //声明=> def 函数名(参数列表):返回值类型={  函数体  }
    //使用=> 函数名(参数)
    def test():Unit={
      println("test...")
    }
    test()
  }
}
package 函数式编程

object Scala02Function {
  def main(args: Array[String]): Unit = {
    //TODO 函数式编程语言
    //1.函数可以声明在任何的位子,方法只能声明在类中
    def test():Unit={
      println("test function...")
    }
    //如果函数名称和方法名称相同，那么默认情况下，会调用函数。如果没有函数，那么调用方法
    //方法和对象相关,而函数是独立使用的。
    this.test()
  }
  //方法
  def test():Unit={
    println("tst method...")
  }

}

函数&方法

object Scala03Function {
  def main(args: Array[String]): Unit = {
    //TODO 函数式编程语言
    //函数的本质就是java中的方法
    //scala源码中,方法就是函数,编译后的字节码中，函数就是方法
    //函数编译成方法中，增加了修饰符:private static final
    //函数编译成功时,函数名会自动发生变化,为了避免和方法名冲突
    def test(): Unit = {
      println("test....")
    }
    test()
  }
  def test():Unit={
    println("test method....")
  }

}

object Scala04Function {
  def main(args: Array[String]): Unit = {
    //TODO函数式编程语言
    //函数应用功能,说的简单点就是声明和使用
    //函数其实就是功能的封装,就意味着功能已经按照特定的规则封装好了，所以重点在如何调用
    def headerUpper(s:String):String={
      return s.substring(0,1).toUpperCase()+s.substring(1)
    }
    val newString:String=headerUpper("lisi")
    println(newString)
    //函数式编程侧重点:函数名,输入参数，返回结果
    //TODO函数声明
    
  }

}

 函数参数

package 函数式编程

object Scala04Function {
  def main(args: Array[String]): Unit = {
    //TODO函数式编程语言
    //函数应用功能,说的简单点就是声明和使用
    //函数其实就是功能的封装,就意味着功能已经按照特定的规则封装好了，所以重点在如何调用
    def headerUpper(s:String):String={
      return s.substring(0,1).toUpperCase()+s.substring(1)
    }
    val newString:String=headerUpper("lisi")
    println(newString)
    //函数式编程侧重点:函数名,输入参数，返回结果
    //TODO函数声明
    //1. 无参无返回值
    def fun1():Unit={
      println("fun1...")
    }
    fun1()

    //2. 无参有返回值
    def fun2():String={
      return "fun2..."
    }
    println(fun2())
    //3. 有参无返回值
    def fun3(name:String):Unit={
      println(s"fun3....$name")
    }
    fun3("zhangsan")
    //4. 有参有返回值
    def fun4(name:String):String={
      return name.toUpperCase
    }

    val str: String = fun4("sunyujie")
    println(str)
    //5. 多参数无返回值
    def fun5(name:String,age:Int):Unit={
      println( s"name=$name,age=$age")

    }
    fun5("zhagnsan",32)
    //6. 多参数有返回值
    def fun6(name:String,age:Int):String={
      return s"name=$name,age=$age"
    }
    println(fun6("sss",20))


  }

}
object ScalaFunction_Normal {
  def main(args: Array[String]): Unit = {
    //TODO函数参数是没有限制个数的，但是个数越多，传值越麻烦，所以并不推荐
    def fun1(
            name1:String,
            name2:String,
            name3:String
            ):Unit={

    }
    //TODO 参数个数简化
    //1. 可变参数,类似于java中的参数...
      // Java  :  String ... args
     // Scala :  args : String*

    //可变参数因为不确定,所以底层实现时,会采用不同的数组集合实现
    def fun2(names: String*): Unit = {
      println(names)
    }

    fun2()  //List()
    fun2("Zhangsan")//ArraySeq(Zhangsan)
    fun2("zhangsan","lisi")
    //TODO 可变参数位子
    // 可变参数只能有一个且要写到参数列表的最后面.:参数列表最后一项
    def  fun3(password:String,name:String*):Unit={

    }
    fun3("zhangsan","lisi","123123")

  }
}

参数默认值

package 函数式编程
//TODO 函数式编程语言 -普通版
//希望参数有默认值；如果不传递，那么参数自动取默认值
//Scala实现不了这个操作,函数的参数默认使用val声明
//下面的代码存在的问题:
//1.参数传值为null,并不是没有传值,只是传递一个特殊值
//2.在一个函数中,有相同含义的多个变量，容易出现歧义

object ScalaFunction_Normal_1 {
  def main(args: Array[String]): Unit = {
    def  test(name:String,password:String):Unit={
      var newpassword=password
      if(password==null){
        newpassword="0000000"
      }
      println(s"注册用户:${name},密码:${newpassword}")
    }
    //TODO 在参数声明时,进行初始化
    def test1(name: String, password: String="00000"): Unit = {
      var newpassword = password
      if (password == null) {
        newpassword = "0000000"
      }
      println(s"注册用户:${name},密码:${newpassword}")
    }
    test("lisi",null)
    test("lisi","1234563")
    test1("wangwu","123456")
  }

}

带名参数

object ScalaFunction_Normal_2 {
  def main(args: Array[String]): Unit = {
    def fun3(name: String, password: String = "000000", address: String): Unit = {
      println(s"name = $name , password = $password , address = $address")
    }

    fun3("wangwu", "123456", "beijing")
    //如果想要改变参数的传值顺序，那么可以采用带名参数

    fun3("wangxiaowu", address = "beijing")
  
  }

}

函数式编程 -  至简原则(能省则省)

package 函数式编程

object ScalaFunction_NightMare {
  def main(args: Array[String]): Unit = {
    //如果编译器可以动态识别的语法,那么开发人员可以不需要编码，可以省略
//    TODO 1)省略return关键字
    def fun1(): String = {
      return "zhangsan"
    }
    println(fun1())

    def fun11(): String = {
      "zhangsan"
    }
    println(fun11())
//    TODO 2)省略花括号 如果逻辑代码只有一行，那么可以将大括号省略
    def fun2():String="zhangsan"
    println(fun2())
    //TODO 3)省略返回值类型:如果能够通过返回值推断返回值类型,那么返回值类型可以省略
    def fun3() = "zhangsan"
    println(fun3())
    //TODO 4)省略参数列表:如果函数的参数列表中没有声明参数，那么小括号可以省略
    //如果省略参数列表的小括号,那么调用时也不能添加
    //因为省略了很多语法内容，所以变量声明和函数声明很像，所以必须采用关键字区分
    def fun4="zhangsan"
    println(fun4)
    //TODO 5)省略等号:如果函数体中有明确的return语句，那么返回值类型不能省略
    def fun5():Unit={
      return "张三"

    }
//    如果函数体返回值类型明确为Unit, 那么函数体中即使有return关键字也不起作用
    def fun51(): Unit = {
      return "zhangsan"
    }
//    如果函数体返回值类型声明为Unit, 但是又想省略，那么此时就必须连同等号一起省略
    def fun52() {
      return "zhangsan"
    }

    println(fun52())

    println(fun5())
    println(fun51())
//   TODO 6)省略名称和关键字:如果函数名称不重要的时候,def和函数名也可以省略，称为匿名函数
    //1.def和函数名省略
    //2.返回值类型也需要省略，由逻辑代码自动推断
    //3.等号需要增加大于浩表示关联
    ()=>{
      return "zhagnsan"
    }
  }

}

函数就是对象

object ScalaFunction_Hell {
  def main(args: Array[String]): Unit = {
    //  TODO 函数式编程语言--地狱版
    /*
    * Scala语言是完全面向对象的语言,所以万物皆对象
    * Scala语言是完全面向函数式编程语言，所以万物皆函数
    * 函数也是对象，对象也是函数
    * java:
    * class User{
    *   private String name;
    * }
    * User user=new User()
    *
    * scala:声明一个函数,等同于声明一个函数对象
    * def test(){
    *
    * }
     */
    def test():Unit={

    }
//    如果一个函数声明时,参数列表中没有参数,那么调用时可以省略小括号
    println(test)  //打印test方法执行结果
    //如果不想让函数执行,只是想访问这个函数本身,可以采用特殊符号进行转化
    println(test _)  //对象
  }
}

函数类型&函数参数个数

package 函数式编程

object ScalaFunction_Hell01 {
  //函数其实就是对象
  //1.对象应该有类型
  //2.对象应该可以赋值给其他人使用
  def test():Unit={

  }
  //将函数对象test赋值给f
  //此时,f可以通过编译器自动推测类型,函数对象类型称之为函数类型
  //Funcation0[Unit]:
  //这里类型中的0表示函数参数列表中参数的个数
  //中括号中的Unit表示函数没有返回值
  val f:Function0[Unit]=test _
  def test1(age:Int):String={
    age.toString
  }
  //Funcation1[Int,String]
  /*
  * 这里类型的1表示函数参数列表中的参数的个数
  * 中括号中的Int表示函数参数的类型
  * 中括号中的String表示函数返回值类型
  * */
  val j:Function1[Int,String]=test1 _
  
  //TODO [函数对象]的参数最多只有22个
  //TODO 为了使用方便,函数类型可以使用另外一种声明方式
  //这里的函数类型为:Int(参数列表的参数类型)=>String(返回值类型)
  def test3(name:String,age:Int):Unit={
    
  }
  //(String,Int)=>Unit
  val  f3=test3 _
  f3

}

函数对象的使用

package 函数式编程

object ScalaFunction_Hell02 {
  def main(args: Array[String]): Unit = {
    //TODO 函数式编程语言
    def test():Unit={
      println("test...")
    }
    //将函数对象赋值给一个变量,那么这个变量就是函数
    //既然这个变量就是函数,所以这个变量可以传参后执行
    val f=test _ 
    println(f)  //对象
    f()

  }

}

将函数对象作为参数使用

package 函数式编程

object ScalaFunction_Hell03 {
  def main(args: Array[String]): Unit = {
    /*
    * TODO java:
    *  public void test(User u){
    *   u.xxx();
    * }
    * User user=new User();
    * test(user)
    * */
    //TODO 将函数对象作为参数使用
    def fun():Unit={
      println("test...")
    }
    def test(f:()=>Unit):Unit={
      f()
    }
    //将函数对象赋值给函数
    val f=fun _
    test(f)
  }

}
package 函数式编程
object ScalaFunction_Hell04 {
  def main(args: Array[String]): Unit = {
    def sum(x:Int,y:Int)={
      x+y
    }

    def diff(x: Int, y: Int) = {
      x -y
    }

    def test(f:(Int,Int)=>Int):Unit={
      val result: Int = f(10, 20)
      println(result)
    }
    //将函数对象作为参数使用,类似于将逻辑进行传递，意味着逻辑可以不用写死
    //TODO 下划线的省略
    //将函数名称直接作为参数传递给另一个函数，此时，不需要使用下划线的
    //使用下划线的目的是不让函数执行，而是将它作为对象使用
    //TODO 函数名的名称真的重要吗?那么参数名称很重要
    test(sum)
    test(diff)
  }
}

将函数对象作为参数使用--匿名函数

package 函数式编程

object ScalaFunction_Hell05 {
  def main(args: Array[String]): Unit = {
    //如果函数名称不重要,那么在传参时,就可以省略函数名称
    def test(f: (Int, Int) => Int): Unit = {
      val result: Int = f(10, 20)
      println(result)
    }
    def sum(x:Int,y:Int):Int={
      x+y
    }
    //test(sum)
    //TODO 如果函数没有名称和def,那么是匿名函数，一般就是作为参数使用
    test(
      (x:Int,y:Int)=>{
        x+y
      }
    )
    //TODO 匿名函数作为参数使用时，可以采用[至简原则]
    //1.匿名函数的逻辑代码只有一行,那么大括号可以省略
    test(
      (x:Int,y:Int)=>x+y
    )
    //2.匿名函数的参数类型如果可以推断出来，那么参数类型可以省略
    test(
      (x,y)=>x+y
    )
    //3.匿名函数中如果参数列表个数只有一个,那么小括号可以省略
    //4.匿名函数如果参数按照顺序只执行一次的场合，那么可以使用下划线代替参数,省略参数列表
    test(_+_)
    //这里的第一个下划线就可以表示第一个参数,依次类推，数值表示任意
    def test1(f:(String)=>Unit):Unit={
      f("张三")
    }
    def fun(name:String):Unit={
      println(name)
    }
    //把名称和关键字省略
    test1(

   (name: String)=> {
      println(name)
    }
     
  
    )
    //简单原则
    test1(
//      name => println(_)
      println(_)
    )
    test1(println)

  }

}

匿名函数小练习

package 函数式编程

object ScalaFunction_Hell05_Test {
  def main(args: Array[String]): Unit = {
    def calc(x:Int,f:(Int,Int)=>Int,y:Int)={
      f(x,y)
    }
    def +(x:Int,y:Int):Int={
      x+y
    }

    def -(x: Int, y: Int): Int = {
      x - y
    }
//    val result=calc(5,+,3)
//    println(result)
    val result=calc(5, _+_,9)
    println(result)
  }
}

函数作为返回值

package 函数式编程

object ScalaFunction_Hell06 {
  def main(args: Array[String]): Unit = {
    //1.将函数对象作为变量赋值使用
    //2.将函数对象作为参数使用
    /*TODO java:
    public User test(){
      User user=new User();
      return user;
    }
    User u=test()
    u.xxx
    u.yyy
    * */
    //TODO 3.scala也可以将函数对象作为返回结果返回
    //函数的返回值类型一般情况下不声明,使用自动推断
    def outer()={  //函数类型
      def inner():Unit={
        println("inner...")

      }  //构建对象
      inner _
    }
    //此时,f就是一个函数对象,有函数类型:()=>Unit
    val f=outer()
    f()  //对象加个（）就能执行
  }

}

函数作为返回值练习

package 函数式编程

object ScalaFunction_Hell07 {
  def main(args: Array[String]): Unit = {
    //1.将函数对象作为变量赋值使用
    //2.将函数对象作为参数使用
    /*TODO java:
    public User test(){
      User user=new User();
      return user;
    }
    User u=test()
    u.xxx
    u.yyy
    * */
    //TODO 3.scala也可以将函数对象作为返回结果返回
    //函数的返回值类型一般情况下不声明,使用自动推断
//    def outer() = { //函数类型
//      def inner(): Unit = {
//        println("inner...")
//
//      } //构建对象
//
//      inner _
//    }

    //此时,f就是一个函数对象,有函数类型:()=>Unit
//    val f = outer()
//    f() //对象加个（）就能执行
    //javascript:函数式
//    outer()()
def outer(x:Int) = { //函数类型
  def mid(f:(Int,Int)=>Int)={
    def inner(y:Int)= {
     f(x,y)

    } //构建对象
    inner _

  }
  mid _


}
//    val mid=outer(10)
//    val inner = mid(_ + _)
//    val result = inner(20)
//    println(result)
    println(outer(10)(_+_)(20))

  }

}

闭包

image.png 

package 函数式编程

object ScalaFunction_Hell08 {
  //TODO 如果一个函数使用了外部的变量，但是改变这个变量的生命周期
  //将这个变量包含到当前函数的作用域内，形成闭包的效果（环境),这个环境称为闭包环境
  //简称闭包
  def outer(x:Int)={
    def inner(y:Int)={
      x+y
    }
    inner _ 返回
  }
  val inner=outer(10)
  val result=inner(20)
  println(result)

}

思考一个问题: 没有使用外部变量还能称之为闭包吗？ 

package 函数式编程

object ScalaFunction_Closure {
  //TODO 闭包
  //scala在2.12版本前,闭包使用匿名函数类实现
  //scala在2.12版本后,闭包使用的是改变函数声明完成的
  def main(args: Array[String]): Unit = {
    def outer(a:Int)={
      def inner(b:Int)={
        a+b
      }
      inner _
    }
    var inner=outer(10)
    inner(20)
    val name="张三"
    def test():Unit={
      println(name)
    }
    val f =test _  //对象
    f()  //生命周期改变了，所以是闭包
    //总结闭包场景:
    //1.内部函数使用了外部的数据，改变了生命周期
    //2.将函数作为对象调用,改变函数本身的生命周期
    //3.所有匿名函数都有闭包
    //4.内部函数返回外部使用也会有闭包

  }

}

控制抽象

package 函数式编程

import scala.util.control.Breaks

object ScalaFunction_Abstract {
//  抽象：不完整
  //抽象类：不完整的类
  //抽象方法：不完整的方法
  def main(args: Array[String]): Unit = {
    def test(f:()=>Unit):Unit={
      f()
    }
    //函数类型只有返回，没有输入场合，称为抽象，因为不完整
    //调用的时候,不能使用括号
    //在传值的时候，就需要进行控制
    def test1(f: =>Unit):Unit={
      f
    }
    test(
      ()=>{
        println("test....")
      }
    )
    //TODO 完整的参数传递,是将函数对象作为参数进行传递
    //TODO 所谓的控制抽象,其实就是将对象作为参数进行传递
    //自定义语法时,可以采用控制抽象，因为代码是可以传递，也就意味着逻辑是变化的
    test1(
      println("test1...")
    )
    //TODO 循环中断的代码就体现了控制抽象
    Breaks.breakable{  //breakable底层是把下面的代码作为参数
      for(i<-1 to 5){
        if(i==3){
          Breaks.break()
        }
        println("i= "+i)
      }
    }
  }

}

函数柯里化

package 函数式编程

object ScalaFunction_Curry {
  def main(args: Array[String]): Unit = {
    //TODO 函数式编程语言-函数柯西化
    def test(a:Int,b:Int):Unit={
      for (i<-1 to a){
        println(i)
      }
      for (i<-1 to b){
        println(i)
      }
    }
    //函数的参数之间可能没有关系,那么如果在传值的时候,同时传递,其实就有耦合性，而且增加了传参的难度
    val a=10//10min
    val b=20 //60min
    test(a, b)
    //柯西化,就是为了函数简单化，将无关的参数进行分离，可以设定多个参数列表
    def test1(a: Int)( b: Int): Unit = {
      for (i <- 1 to a) {
        println(i)
      }
      for (i <- 1 to b) {
        println(i)
      }
    }
    val intToUnit:Int=>Unit=test1(10)
    test1(10)(20)
    //等同于
    def outer()={
      def inner():Unit={
        println("inner...")
      }
      inner _
    }

    val inner: () => Unit = outer()
    inner()
    println("==================")
    outer()()
  }

}

递归函数

package 函数式编程

object Scala05Functiondigui {
  def main(args: Array[String]): Unit = {
    //TODO 递归:自己调用自己，应该跳出递归逻辑
    //StackOverflowError:栈溢出
    //Java在执行方法调用时,会将方法进行压栈处理，方法执行完毕后,会有弹栈处理
    //如果方法没有执行完,又调用了其他方法，那么方法栈空间会下压
    //如果越压越多，那么栈空间不够了，所以会发生溢出操作
    //TODO 阶乘
    //Scala中的返回类型不能省略
    def test(num: Int): Int = {
      if (num <= 1) {
        1
      } else {
        num * test(num - 1)
      }
    }
    println(test(5))
    //TODO Java的栈内存有大小限制的
    // 方法执行时,压栈的内存也是有大小的，那么栈内存不可能无限压栈
    //如果压栈的次数超过阀值，就会出现错误，即使有跳出的逻辑也会出错
    //scala采用了一种特殊的语法优化递归操作，尾（伪）递归
    //scala采用while循环实现伪递归
    //java中的尾递归没有优化
    def test1():Unit={
      println("test1..")
      //弹栈
      test1()
    }

  }

}

栈内存溢出&栈溢出

//5M =10*1024K
    //2G=2*1024M=200线程
    //TODO 栈内存溢出:没有足够的内存分配栈空间(内存)
    //java中的内存，堆内存，方法区内存只有一个，但是栈内存可以是多个
    //一个线程就是一个独立栈内存

惰性函数

当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。

package 函数式编程

object Scala06Functionlaze {
  def main(args: Array[String]): Unit = {
    //TODO 惰性函数:函数是否在调用时马上执行
    def test(): String = {
      println("function...")
      "zhangsan"
    }

    val a = test()
    println("----------")
    println(a)
  }

}

image.png 

package 函数式编程

object Scala06Functionlaze {
  def main(args: Array[String]): Unit = {
    //TODO 惰性函数:函数是否在调用时马上执行
    def test(): String = {
      println("function...")
      "zhangsan"
    }

     lazy val a = test()
    println("----------")
    println(a)
  }

}

image.png

函数式编程-小练习

将简化版本的函数式编程代码恢复完整代码

//test(10,20,_+_) //30

package 函数式编程

object Scala07Function_test {
  def main(args: Array[String]): Unit = {
    //TODO 将简化版本的函数式编程代码恢复完整代码
    //test(10,20,_+_) //30
    def fun(x:Int,y:Int):Int={
      x+y
    }
   def test(x:Int,y:Int,f:(Int,Int)=>Int)= {
     f(x,y)
     
   }
    println(test(10,20,fun))
  }

}

//test1(_.substring(0,1))

package 函数式编程
object Scala07Function_test {
  def main(args: Array[String]): Unit = {
    //TODO 将简化版本的函数式编程代码恢复完整代码
    //test(10,20,_+_) //30
    def fun(x:Int,y:Int):Int={
      x+y
    }
   def test(x:Int,y:Int,f:(Int,Int)=>Int)= {
     f(x,y)
   }
    println(test(10,20,fun))
    //test1(_.substring(0,1))
//    test1(()=>{_.substring(0,1)})
    def fun1(name:String):String={
  name.substring(0,1)
}
    def test1(f:(String)=>String):String={
  f("张三")
}
//    test1((x:String)=>{x.substring(0,1)})
    println(test1(fun1))
  }

}

//test2(_*2)

    def fun2(x: Int): Int = {
      x*2
    }
    def test2(f:(Int)=>Int):Int={
      f(10)
    }

//    test2((x:Int)=>{
//      x*2
//    })
    println(test2(fun2))

控制抽象可以实现自定义语法

package 函数式编程

object Scala08Function_test {
  def main(args: Array[String]): Unit = {
    //TODO 控制抽象可以实现自定义语法
    /*
    * 自定义while循环
    * while(条件表达式){
    *    循环体
    * }
    * */
    def mywhile(cond : => Boolean)(op : =>Unit):Unit={
      if(cond){
        op
        mywhile(cond)(op)
      }
    }
    val age=30
    mywhile(age==30){
      println("age=30")
    }
  }

}
文章标签：
云原生大数据计算服务 MaxCompute
Scala
消息中间件
分布式计算
大数据
编译器
关键词：
Scala学习
Scala学习函数式编程
Scala函数式编程
相关实践学习
简单用户画像分析
本场景主要介绍基于海量日志数据进行简单用户画像分析为背景，如何通过使用DataWorks完成数据采集 、加工数据、配置数据质量监控和数据可视化展现等任务。
SaaS 模式云数据仓库必修课
本课程由阿里云开发者社区和阿里云大数据团队共同出品，是SaaS模式云原生数据仓库领导者MaxCompute核心课程。本课程由阿里云资深产品和技术专家们从概念到方法，从场景到实践，体系化的将阿里巴巴飞天大数据平台10多年的经过验证的方法与实践深入浅出的讲给开发者们。帮助大数据开发者快速了解并掌握SaaS模式的云原生的数据仓库，助力开发者学习了解先进的技术栈，并能在实际业务中敏捷的进行大数据分析，赋能企业业务。 通过本课程可以了解SaaS模式云原生数据仓库领导者MaxCompute核心功能及典型适用场景，可应用MaxCompute实现数仓搭建，快速进行大数据分析。适合大数据工程师、大数据分析师 大量数据需要处理、存储和管理，需要搭建数据仓库？学它！ 没有足够人员和经验来运维大数据平台，不想自建IDC买机器，需要免运维的大数据平台？会SQL就等于会大数据？学它！ 想知道大数据用得对不对，想用更少的钱得到持续演进的数仓能力？获得极致弹性的计算资源和更好的性能，以及持续保护数据安全的生产环境？学它！ 想要获得灵活的分析能力，快速洞察数据规律特征？想要兼得数据湖的灵活性与数据仓库的成长性？学它！ 出品人：阿里云大数据产品及研发团队专家 产品 MaxCompute 官网 https://www.aliyun.com/product/odps&nbsp;
建模sister
目录
相关文章
让线程再跑一会
|
4月前
|
消息中间件 分布式计算 Java
Scala函数式编程【从基础到高级】
Scala函数式编程【从基础到高级】
让线程再跑一会
47 0
建模sister
|
2月前
|
Scala 容器
Scala学习--day04--集合、常用方法、案例实操 - WordCount TopN、不同省份的商品点击排行
Scala学习--day04--集合、常用方法、案例实操 - WordCount TopN、不同省份的商品点击排行
建模sister
70 2
建模sister
|
2月前
|
Java Scala
Scala学习--day02---控制流、“九层妖塔—杨辉三角”
Scala学习--day02---控制流、“九层妖塔—杨辉三角”
建模sister
54 1
建模sister
|
2月前
|
Java 编译器 API
Scala学习--day01变量与数据类型、运算符
Scala学习--day01变量与数据类型、运算符
建模sister
41 1
陌陌谣
|
4月前
|
数据采集 监控 安全
通过Scala实现局域网监控上网记录分析：函数式编程的优雅之路
在当今数字时代，网络监控成为保障信息安全的必要手段之一。本文将介绍如何使用Scala编程语言实现局域网监控上网记录分析的功能，重点探讨函数式编程的优雅之路。通过一系列代码示例，我们将展示如何利用Scala的函数式特性和强大的语法来实现高效的监控和分析系统。
陌陌谣
218 1
赵广陆
|
7月前
|
分布式计算 API Scala
Scala函数式编程
Scala函数式编程
赵广陆
46 0
笑看风云路
|
10月前
|
存储 分布式计算 Java
掌握Scala基础知识，让你在Spark的学习道路上更近一步！
Scala基础知识
笑看风云路
109 0
不懂开发的程序猿
|
11月前
|
分布式计算 Ubuntu Java
Scala函数式编程
Scala函数式编程
不懂开发的程序猿
93 0
安然AR
|
12月前
|
大数据 编译器 Scala
大数据开发基础的编程语言的Scala的函数式编程范式
Scala是一种支持函数式编程范式的编程语言，它允许开发者使用函数和不可变数据结构来实现程序逻辑。本文将介绍Scala中函数式编程范式的概念和用法，帮助开发者更好地理解和应用这门语言。
安然AR
88 0
橙子园
|
分布式计算 Shell API
scala函数式编程与高阶函数
谈到编程方式有指令式编程、过程化编程、函数式编程，函数式编程在使用时主要的思想就是把运算过程写成一些列嵌套的函数调用。把一组数据通过函数实现运算转化成另一组数据。函数式编程这种方式在我们将来开发Spark、Flink的业务代码时会大量使用。下面列出了一些我们经常使用的进行函数式编程的Iterable trait（可迭代特质）方法。
橙子园
64 0

热门文章

最新文章

  • 1
    挖掘网络宝藏：利用Scala和Fetch库下载Facebook网页内容
  • 2
    利用Scala与Apache HttpClient实现网络音频流的抓取
  • 3
    Scala入门到精通—— 第二节Scala基本类型及操作、程序控制结构
  • 4
    java集合和scala集合互转
  • 5
    Scala语法笔记
  • 6
    [Scala]Scala学习笔记二 数组
  • 7
    每天学一点Scala之Try
  • 8
    Scala开发入门指南
  • 9
    《Scala机器学习》一一3.7　总结
  • 10
    Scala 语言学习之泛型（7）
  • 1
    使用Maven对Scala独立应用程序进行编
    19
  • 2
    使用Scala编写控制局域网上网软件的机器学习算法
    102
  • 3
    scala的两种变量类型 var 和 val
    46
  • 4
    spark 与 scala 的对应版本查看、在idea中maven版本不要选择17，弄了好久，换成11就可以啦
    110
  • 5
    Scala学习--day04--集合、常用方法、案例实操 - WordCount TopN、不同省份的商品点击排行
    70
  • 6
    利用Scala编写公司内部监控软件的实时日志监控模块
    159
  • 7
    Scala学习--day02---控制流、“九层妖塔—杨辉三角”
    54
  • 8
    Scala学习--day01变量与数据类型、运算符
    41
  • 9
    Spark 集群和 Scala 编程语言的关系
    29
  • 10
    Spark编程语言选择：Scala、Java和Python
    289

    • 相关课程

    更多
  • Scala核心编程 - 进阶
  • Python语言基础 - 语法入门
  • 【Python入门】Python数据处理编程基础
  • Go语言核心编程 - 基础语法、数组、切片、Map

    • 相关电子书

    更多
  • JDK8新特性与生产-for“华东地区scala爱好者聚会”
  • Just Enough Scala for Spark
  • From Python Scikit learn to Scala Spark
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）