Scala快速学习

最新推荐文章于 2024-06-27 09:26:01 发布
最新推荐文章于 2024-06-27 09:26:01 发布
阅读量1.1k 收藏 10
点赞数 3
文章标签： Scala Spark Hdfs 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33247435/article/details/83473879
版权

文章目录

1、Scala六大特性

  1. java和scala可以无缝混编（都是基于JVM）
  2. 类型推测（不必指定类型，自动推测类型）
  3. 支持并发和分布式（Actor）
  4. 特质：trait（集结了java中抽象类和接口的产物）
  5. 模式匹配（match case ：类似于java中的switch case）
  6. 高阶函数（参数时函数或者返回值是参数）

2、Scala的安装使用

    本教程介绍在Windows下安装Scala2.10版本。安装包可以去官网下载。Scala官网。也可以直接下载我传到网盘上的压缩包。安装包如下：
    链接：https://pan.baidu.com/s/1cDstlitWRXpUfDW48UzzmA 提取码：es15
    下载完成之后，解压在电脑合适位置（记住该位置）。然后配置环境变量（和java配置环境变量一样）
    新建一个系统变量SCALA_HOME,值是Scala安装包的位置。
    在这里插入图片描述
    编辑Path环境变量，添加;%SCALA_HOME%\bin;%SCALA_HOME%\jre\bin
    在这里插入图片描述
    此时scala安装完毕，使用win+r输入cmd打开命令行，然后输入scala -version可以看到安装的scala的版本号。测试成功。
    在这里插入图片描述
    下面分享一个Scala工具：Eclipse Scala版本。

3、Scala基础

     1）、数据类型

         Byte 8bite的有符号数字，范围在-128 – 127
         Short 16bite的有符号数字，范围值在-32868 – 32767
         Int 32bite的有符号数字，范围在-21亿 – 21亿
         Long 64bite的有符号数字，范围在 负的2的16次方 – 2的16次方
         Float 32bite 单精度浮点数
         Double 64bite 双精度浮点数
         Char 16bite Unicode字符
         String 字符串
         Boolean 布尔类型
         Unit 表示无值，和其他语言的void相同
         Null 空值或者空引用
         Nothing 所有其他类型的子类型，表示没有值
         Any 所有类型的超类，任何实例都属于Any类型。类似于java的Object
         AnyRef所有引用类型的超类
         AnyVal所有值类型的超类
         Nil长度为0的List
         在这里插入图片描述

     2）、变量和常量的声明

        定义变量或者常量的时候，可以写上返回类型，也可以不写，如下：
        变量：var age:Int = 20或者var age2 = 18
        常量：val age:Int = 20或者val age2 = 18(常量不可以再次赋值）

     3）、类和对象

        创建类：

   class Person{
       val name = "zhangsan"
       val age = 18
       def sayName() = {
           "my name is "+ name
       }
   }

        创建对象：

  object Lesson_Class {
     def main(args: Array[String]): Unit = {
        val person = new Person()
        println(person.age);
        println(person.sayName())
     }
  }

        注意：建议类名首字母大写 ，方法首字母小写，类和方法命名建议符合驼峰命名法。
                scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类。object不可以传参数。另：Trait不可以传参数
                scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。
                重写构造函数的时候，必须要调用默认的构造函数。
                class 类属性自带getter ，setter方法。
                使用object时，不用new,使用class时要new ,并且new的时候，class中除了方法不执行，其他都执行。
                如果在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类。可以互相访问私有变量。

     4）、if else

        Scala中的if else与java中的用法基本一样。样例代码如下：

    val age =18 
    if (age < 18 ){
    	println("no allow")
    }else if (18<=age&&age<=20){
    	println("allow with other")
    }else{
    	println("allow self")
    }

     5）、for，while，do…while

        讲解Scala的循环之前，先讲解Scala的一个特性：until和to（主要区别是：until前闭后开，to前闭后闭）

   println(1 until 10 )       //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9
   println(1 until (10 ,3 ))  //步长为3，从1开始打印，打印1,4,7
   println(1 to 10 )          //打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
   println(1 to (10 ,2))      //步长为2，从1开始打印 ，1,3,5,7,9

        在逻辑上，Scala中的循环跟java中的循环一样，只是使用的方式有些区别，下面分别做介绍。
        for循环

    //例子： 打印九九乘法表；相当于java中的双层for循环
    for(i <- 1 until 10 ;j <- 1 until 10){
      if(i>=j){
    	  print(i +" * " + j + " = "+ i*j+"	") 
      }
      if(i==j ){
          println()
      }
    }

        与java中不一样的是，for里面可以加判断，如下：

   for(i<- 1 to 10 ;if (i%2) == 0 ;if (i == 4) ){
       println(i)
   }

        while与dowhile跟java中判断逻辑一样，下面贴个简单的while例子：

    var index = 0 
    while(index < 100 ){
    	println("第"+index+"次while 循环")
        index += 1 
    }

        注意点：scala中不能使用count++，count—只能使用count = count+1 ，count += 1
        for循环用yield 关键字返回一个集合val list = for(i <- 1 to 10 ; if(i > 5 )) yield i
        for循环中可以加条件判断，分号隔开

4、Scala函数

     1）、普通函数

        函数格式：

   def 函数名(变量名:变量类型，...)：返回值类型 = {
	   函数体
   }

        简单函数样例：

   def fun (a: Int , b: Int ) : Unit = {
      println(a+b)
   }

        下面是Scala函数的一些规则和注意点：

        1. 函数定义语法 用def来定义
        2. 可以定义传入的参数，要指定传入参数的类型
        3. 方法可以写返回值的类型也可以不写，会自动推断，有时候不能省略，必须写，比如在递归函数中或者函数的返回值是函数类型的时候。
        4. scala中函数有返回值时，可以写return，也可以不写return，会把函数中最后一行当做结果返回。当写return时，必须要写函数的返回值。
        5. 如果返回值可以一行搞定，可以将{}省略不写。（def fun1 (a : Int , b : Int)= a+b）
        6. 传递给方法的参数可以在方法中使用，并且scala规定方法的传过来的参数为val的，不是var的。
        7. 如果去掉方法体前面的等号，那么这个方法返回类型必定是Unit的。这种说法无论方法体里面什么逻辑都成立，scala可以把任意类型转换为Unit.假设，里面的逻辑最后返回了一个string，那么这个返回值会被转换成Unit，并且值会被丢弃。

     2）、递归函数

        递归函数就是循环调用自己，下面给出一个求阶乘的代码：

   def fun2(num :Int) :Int= {
      if(num ==1)
        num
      else 
        num * fun2(num-1)
   }

     3）、包含参数默认值的函数

        默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值。
        如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称。

   def fun3(a :Int = 10,b:Int) = {
        println(a+b)
   }
   fun3(b=2)

     4）、可变参数个数的函数

        多个参数用逗号分开。

   def fun4(elements :Int*)={
       var sum = 0;
       for(elem <- elements){
          sum += elem
       }
       sum
   }
   println(fun4(1,2,3,4))

     5）、匿名函数

        匿名函数分为有参匿名函数、无参匿名函数、有返回值的匿名函数。（可以将匿名参数的返回给一个val声明的值，匿名函数不能显式的声明返回值）

    //有参数匿名函数
    val value1 = (a : Int) => {
      println(a)
    }
    value1(1)
    
    //无参数匿名函数
    val value2 = ()=>{
      println("我爱Angelababy")
    }
    value2()
    
    //有返回值的匿名函数
    val value3 = (a:Int,b:Int) =>{
      a+b
    }
    println(value3(4,4))

     6）、嵌套函数

    def fun5(num:Int)={
       def fun6(a:Int,b:Int):Int={
          if(a == 1){
             b
          }else{
             fun6(a-1,a*b)
          }
       }
       fun6(num,1)
    }
    println(fun5(5))

     7）、偏应用函数

        偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。

    def log(date :Date, s :String)= {
       println("date is "+ date +",log is "+ s)
    }
    
    val date = new Date()
    //想要调用log，以上变化的是第二个参数，可以用偏应用函数处理
    val logWithDate = log(date,_:String)
    logWithDate("log11")
    logWithDate("log22")
    logWithDate("log33")

     8）、高阶函数

        函数的参数是函数，或者函数的返回类型是函数，或者函数的参数和函数的返回类型都是函数的函数。

    //函数的参数是函数
    def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
       f(a,100)
    }
    def f(v1 :Int,v2: Int):Int  = {
       v1+v2
    }
    
    println(hightFun(f, 1))
    
    //函数的返回是函数
    //1，2,3,4相加
    def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
       def f2 (v1: Int,v2:Int) :Int = {
          v1+v2+a+b
       }
       f2
    }
    println(hightFun2(1,2)(3,4))
    
    //函数的参数是函数，函数的返回是函数
    def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
       f
    } 
    println(hightFun3(f)(100,200))
    println(hightFun3((a,b) =>{a+b})(200,200))
    //以上这句话还可以写成这样
    //如果函数的参数在方法体中只使用了一次 那么可以写成_表示
    println(hightFun3(_+_)(200,200))

     9）、柯里化函数

        可以理解为高阶函数的简化

    def fun7(a :Int,b:Int)(c:Int,d:Int) = {
       a+b+c+d
    }
    println(fun7(1,2)(3,4))

5、Scala字符串

        Scala中字符串String仍是不可变量。StringBuild为可变字符串。具体操作与java类似。下面是我老师整理的String方法集：String方法合集

6、Scala集合

     1）、数组

        创建数组：

    //创建类型为Int 长度为3的数组
    val arr1 = new Array[Int](3)
    //创建String 类型的数组，直接赋值
    val arr2 = Array[String]("s100","s200","s300")
    //赋值
    arr1(0) = 100
    arr1(1) = 200
    arr1(2) = 300

        遍历数组：

    for(i <- arr1){
        println(i)
    }
    arr1.foreach(i => {
        println(i)
    })

        创建二维数组：

   val secArray = new Array[Array[String]](5)
   for(index <- 0 until secArray.length) secArray(index) = new Array[String](3)

        下面继续贴上我老师整理的数组方法

     2）、list

        list是不可变的，对list进行添加删除或者取值等操作均会返回一个新的list。

   val list = List(1,3,5,9)
   println(list.contains(9))
   val dropList = list.drop(2)
   dropList.foreach { println }
   val reList = list.reverse
   reList.foreach { x => print(x + "\t") }

        flatmap ：压扁扁平,先map再flat
        在这里插入图片描述

  val logList = List("hello bj","hello sh")
  val flatMapList = logList.flatMap { _.split(" ") }
  flatMapList.foreach(println)
  //上面是不可变的list，下面是可变的listBuffer
  var listBuffer = new ListBuffer[String]
  listBuffer.+=:("zhao")
  listBuffer.+=("liu")
  listBuffer.foreach { println }

        下面继续贴上我老师整理的list方法

     3）、set

        set是一个非重复的集合，若有重复数据，则会自动去重。

   val set = Set(1,3,5,8,1,6,5,8)
   set.foreach { x => print(x + "\t") }

        下面继续贴上我老师整理的set方法

     4）、map

        map是K-V键值对集合。

   //创建map
   val map = Map(
       "1" -> "bj" ,
       2 -> "sh",
       3 -> "gz"
    )
    
    //map遍历
    for(x <- map){
       println("====key:"+x._1+",value:"+x._2)
    }
    
    //遍历key
    var keys = map.keys
    //获取key的迭代器
    var keyIterator = keys.iterator
    while(keyIterator.hasNext){
       val key = keyIterator.next()
       println(key + "\t" + map.get(key).get)
    }

        下面继续贴上我老师整理的map方法

     5）、元组

        与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。创建过程可加new关键词，也可不加。

    //创建二元组，下面两句话效果相同
    val t2 = new Tuple2(1,"hello")
    val tt2 = (1,"hello")
    
    //创建三元组，下面两句话效果相同
    val t3 = Tuple3(2,"bj","come")
    val tt3 = (2,"bj","come")
    
    //创建tt3的迭代器
    val tupleIte = tt3.productIterator
    while(tupleIte.hasNext) print(tupleIte.next + "\t")
    
    //反转，只针对二元组
    val swap = tt2.swap
    
    //toString
    println(tt3.toString())

7、Scala trait特性

        Scala Trait(特征)相当于java中抽象类和接口的集合体，不只是具备接口的特征，还可以定义属性和方法的实现。一般情况下Scala的类可以继承多个Trait，从结果来看就是实现了多重继承。Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。
        继承的多个trait中如果有同名的方法和属性，必须要在类中使用“override”重新定义。并且trait中不可以传参数。

//定义一个trait
trait Read {
  val readType = "Read"
  val gender = "m"
  def read(name:String){
	println(name+" is reading")
  }
}

//定义第二个trait
trait Listen {
  val listenType = "Listen"
  val gender = "m"
  def listen(name:String){
	println(name + " is listenning")
  }
}

//定义了一个类继承上面两个trait
class Person() extends Read with Listen{
  override val gender = "f"
}

object test {
  def main(args: Array[String]): Unit = {
    val person = new Person()
    person.read("zhangsan")
    person.listen("lisi")
    println(person.listenType)
    println(person.readType)
    println(person.gender)
    
  }
}

8、Scala 模式匹配

        模式匹配类似于java的switch case。Scala的模式匹配不仅可以匹配值还可以匹配类型、从上到下顺序匹配，如果匹配到则不再往下匹配、都匹配不上时，会匹配到case _ ,相当于default、match 的最外面的”{ }”可以去掉看成一个语句。

   def match_test(m:Any) = {
       m match {
         case 1 => println("nihao")
         case m:Int => println("Int")
         case _ => println("default")
       }
    }

9、Scala 样例类

        使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类。实现了类构造参数的getter方法（构造参数默认被声明为val），当构造参数是声明为var类型的，它将帮你实现setter和getter方法。
        样例类默认帮你实现了toString,equals，copy和hashCode等方法。
        样例类可以new, 也可以不用new。

case class Person1(name:String,age:Int)

object Lesson_CaseClass {
   def main(args: Array[String]): Unit = {
      val p = new Person1("zhangsan",10)
  }
}

10、Scala Actor

        Actor Model是用来编写并行计算或分布式系统的高层次抽象（类似java中的Thread）让程序员不必为多线程模式下共享锁而烦恼,每个Actors有自己的世界观，当需要和其他Actors交互时，通过发送事件和消息，发送是异步的，非堵塞的(fire-andforget)，发送消息后不必等另外Actors回复，也不必暂停，每个Actors有自己的消息队列，进来的消息按先来后到排列，这就有很好的并发策略和可伸缩性，可以建立性能很好的事件驱动系统。
        Actor的特征：
                ActorModel是消息传递模型,基本特征就是消息传递
                消息发送是异步的，非阻塞的
                消息一旦发送成功，不能修改
                Actor之间传递时，自己去检查消息，而不是一直等待，是异步非阻塞的

object Scala07 {
  def main(args: Array[String]): Unit = {
    val actor = new MyActor
    actor.start()
    actor ! "hello bj"
  }
}

class MyActor extends Actor{
  def act() = {
    while(true){
      receive{
        case s: String => println(s)
        case _ =>println("default")
      }
    }
  }
}

11、Scala 隐式转换

        隐式转换，在编写程序的时候可以尽量少的去编写代码，让编译器去尝试在编译期间自动推导出这些信息来，这种特性可以极大的减少代码量，提高代码质量。

        特征：
                隐式转换必须满足无歧义规则
                在同一个作用域禁止声明两个类型一致的变量，防止在搜索的时候会犹豫不决
                声明隐式参数的类型最好是自定义的数据类型，不要使用Int,String这些常用类型，防止碰巧冲突

   def sayName(implicit name:String) = {
       println("say love to " + name)
   }
    
   implicit val name = "fanbingbing"
   sayName

12、Scala Demo --Word Count

package com.hpe.spark.demo

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
/**
 * 单词统计并排序
 */
object WCSpark {
  def main(args: Array[String]): Unit = {
    //创建配置对象
    val conf = new SparkConf
    //设置App的名称   有啥用？ 方便在监控页面找到  MR-》Yarn 8088
    conf.setAppName("WordCountSpark")
    //设置Spark的运行模式  local本地运行  用于测试环境
    conf.setMaster("local")
    
    //创建Spark上下文 他是通往集群的唯一通道
    val sc = new SparkContext(conf)
    
    /**
     * 处理数据   在SparkCore中一切得计算都是基于RDD
     * R（Resilient）D（Distributed ）D（Dataset）
     * RDD 弹性分布式数据集
     */
    val lineRDD = sc.textFile("d:/wc.txt")
    //基于lineRDD中的数据 进行分词
    val wordRDD = lineRDD.flatMap { _.split(" ") }
    //每一个单词计数为1  pairRDD  K:word V:1
    val pairRDD = wordRDD.map { (_,1) }
    //相同的单词进行分组，对组内的数据进行累加
    val resultRDD = pairRDD.reduceByKey((v1,v2) => v1 + v2)
    //用户可以使用sortBy这个方法，来指定根据哪一个字段来排序
    resultRDD
      .sortBy(x => x._2,false)
      .foreach(println)
    //释放资源
    sc.stop()
    
  }
}

        注：使用Spark函数需要导包：Spark包

程序员小赵同学
关注
专栏目录
Scala快速学习教程（一）
wonner_的博客
08-20 3583
    在学习spark时使用到了scala语言进行编程，特编写此博客，已尽量精简的方式对scala语言进行总结学习（在至少会一门编程语言的基础上看此篇博客会比较容易）。Scala运行于Java平台（JVM，Java 虚拟机）上，并兼容现有的Java程序，Scala代码可以调用Java方法，访问Java字段，继承Java类和实现Java接口。scala与java有许多相似之处，建议进行对比学习。本...
Scala快速学习教程（二）
wonner_的博客
08-21 539
    上一篇文章写到了Scala基础知识及控制结构，这篇文章来介绍一下Scala中的数据结构。 定长数组（Array）与变长数组（ArrayBuffer） 定长数组声明有两种形式： 声明指定长度的数组 val 数组名= new Array[类型](数组长度) val intValueArr = new Array[Int](3) //声明一个长度为3的整型数组，每个数组元素初始化为0 ...
快学scala完整本
07-18
Scala是一种简单易学的编程语言，语言与python有些相似，在spark做数据分析等其他场景都会用到，是一门值得学习的语言。
Scala学习-快速入门
yqtao的博客
03-10 9465
Scala 是一门多范式的编程语言，设计初衷是实现可伸缩的语言、并集成面向对象编程和函数式编程的各种特性。1. 安装Scala非常的简单，在ubuntu中只需要sudo apt-get install scala即可，在其他的linux中，找到下载源文件安装即可。安装成功后使用scala进入shell环境：yqtao@yqtao:~$ scala Welcome to Scala version 2
Scala
qq_43043777的博客
06-27 621
Scala语言由Martin Odersky（马丁·奥德斯基）设计，其兼具面向对象和函数式编程的特性，和Java一样运行在Java虚拟机（JVM）中。Scala语言简洁，表达性强，其函数式编程的特性使其在大数据场景中得到广泛使用。【Scala语言特性】Scala程序运行在JVM上，和Java程序一样需经过编译、解释、运行的流程，对应的指令是scalac、scalaScala可以直接使用Java类库，并提供特有的类库相比Java，Scala更为面向对象，同时兼具函数式编程的特性。
[大数据] Scala 速学手册1
eye2cro
10-24 208
Scala 基础介绍 1 Scala 1.1 什么是Scala Scala是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台（Java虚拟机），并兼容现有的Java程序。 1.2为什么要学Scala 优雅 速度快：开发速度快；静态编译，运行速度快 学习大数据组件 2 Scala基础 2.1 声明变量 object VariableDem...
快速学习Scala
热情、奔放、快乐编程！
02-22 787
Scala是一门现代的多范式编程语言，集成了面向对象和函数式语言的特性。Scala运行于Java平台上，并兼容现有的Java程序，Scala代码可以调用Java方法，访问Java字段，继承Java类和实现Java接口。Scala是一门非常纯粹的面向对象编程语言，在Scala中，每个值都是对象，每个操作都是方法调用。
读书笔记：scala 快速学习.zip
最新发布
07-22
读书笔记：scala 快速学习
快速学习-Scala异常
01-21
Scala提供try和catch块来处理异常。try块用于包含可能出错的代码。catch块用于处理try块中发生的异常。可以根据需要在程序中有任意数量的try…catch块。 语法处理上和Java类似，但是又不尽相同 Java异常处理回顾 try...
快速学习-Scala整数类型
01-07
Scala整数类型 基本介绍 Scala的整数类型就是用于存放整数值的，比如 12 , 30, 3456等等 整型的类型 整型的使用细节 Scala各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证Scala程序的可移植性。 ...
快速学习-Scala变量
01-07
一个程序就是一个世界，在scala中一切都是对象 变量是程序的基本组成单位 不论是使用哪种高级程序语言编写程序,变量都是其程序的基本组成单位，比如: object ScalaFunDemo01 { def main(args: Array[String]): ...
快学Scala（含详细目录）
05-06
scala经典图书，Core Java作者最新力作, 中文版。Scala for the Impatient 中文版 快学Scala pdf（含目录） scala 快速入门书箱 scala经典图书 Core Java作者最新力作 中文版 快学Scala Scala for the Impatient 中文版 [美]C S 霍斯曼 2012 电子工业出版社
快学Scala（完整中文版）
01-29
深入学习大数据的必备书籍，学好scala对掌握大数据有很大的帮助！！！
快学Scala（中文完整版）
01-19
Scala是一门以Java虚拟机（JVM）为目标运行环境并将面向对象和函数式编程语言的最佳特性结合在一起的编程语言。你可以使用Scala编写出更加精简的程序，同时充分利用并发的威力。由于Scala运行于JVM之上，因此它可以访问任何Java类库并且与Java框架进行互操作。本书从实用角度出发，给出了一份快速的、基于代码的入门指南。Horstmann以“博客文章大小”的篇幅介绍了Scala的概念，让你可以快速地掌握和应用。实际上手的操作，清晰定义的能力层次，从初级到专家级，全程指导。
快学scala 完整
01-24
快学scala 完整清晰版 大数据spark 主要的编程语言 快学scala 完整清晰版 大数据spark 主要的编程语言
快学scala
flyDeDog的博客
01-21 386
第一章 基础操作符 1.+(2) 和 1 + 2 的效果一样, +是int类型的一个方法, 你可以重载它, 然后用着两种语法调用导入 import scala.math._ 是导入math包中的所有方法方法调用 "hello".distinct 通常来说, 不带参数切不改变原来对应的方法不带括号apply "hello"(4) 是 "hello".apply(4)的简写, 可以理解为实现了app
快学Scala
imba_xuetu的博客
09-04 411
快学Scala
快速学习-Scala过程
逍遥云恋
02-25 352
过程 基本介绍 将函数的返回类型为Unit的函数称之为过程(procedure)，如果明确函数没有返回值，那么等号可以省略 案例说明 注意事项和细节说明 注意区分: 如果函数声明时没有返回值类型，但是有 = 号，可以进行类型推断最后一行代码。这时这个函数实际是有返回值的，该函数并不是过程。(这点在讲解函数细节的时候讲过的.) 开发工具的自动代码补全功能，虽然会自动加上Unit，但是考虑到Scal...
Scala快速入门：大数据开发利器
"Scala快速入门，适用于希望快速学习Scala语言并进行Spark/Flink大数据开发的初学者。" 在大数据处理领域，Scala语言以其强大的功能和与Apache Spark、Flink等框架的紧密集成而受到广泛关注。《Scala for the ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值