精华内容
下载资源
问答
  • scala处理json数据

    千次阅读 2017-08-14 09:07:03
    1. Lift-json ...scala处理json可以调用JAVA常用json处理库来处理json 这里展示使用fastjson 和json-lib来处理 json-lib处理json 需要的包 import net.sf.json.JSONObject object

    1. Lift-json

    2. Gson

    3. Json4s

    4. spray-json


    scala处理json可以调用JAVA常用json处理库来处理json
    这里展示使用fastjson 和json-lib来处理


    json-lib处理json
    需要的包


    import net.sf.json.JSONObject
    object Json {
      def main(args: Array[String]): Unit = {
        val str2 = "{\"et\":\"kanqiu_client_join\",\"vtm\":1435898329434,\"body\":{\"client\":\"866963024862254\",\"client_type\":\"android\",\"room\":\"NBA_HOME\",\"gid\":\"\",\"type\":\"\",\"roomid\":\"\"},\"time\":1435898329}"
        val data=JSONObject.fromObject(str2);
        println(data)
        //获取json成员
        val et=data.get("et")
        println(et)
        //获取字符串类型json成员
        val et1=data.getString("et")
        println(et1)
        //获取整形类型,这样可以确定val vtm的数据类型,防止下面编译过程中报错.
        val vtm=data.getInt("vtm")
        //获取多级元素
        val client=data.getJSONObject("body").getString("client")
        print(client)
      }
    }

    fastjson处理json
    fastjson处理json只需要fastjson的包就可以了

    import com.alibaba.fastjson.JSON

    object Json {
      def main(args: Array[String]): Unit = {
        val str2 = "{\"et\":\"kanqiu_client_join\",\"vtm\":1435898329434,\"body\":{\"client\":\"866963024862254\",\"client_type\":\"android\",\"room\":\"NBA_HOME\",\"gid\":\"\",\"type\":\"\",\"roomid\":\"\"},\"time\":1435898329}"
           val json=JSON.parseObject(str2)
           //获取成员
           val fet=json.get("et")
           //返回字符串成员
           val etString=json.getString("et")
           //返回整形成员
           val vtm=json.getInteger("vtm")
           println(vtm)
           //返回多级成员
           val client=json.getJSONObject("body").get("client")
           println(client)

    在spark-steaming中,使用fast-json更加稳定,json-lib经常出现莫名问题,而且fastjson的解析速度更快.

    展开全文
  • Scala 异常处理Scala 异常处理

    千次阅读 2017-12-27 16:19:26
    Scala 的异常处理和其它语言比如 Java 类似。 Scala 的方法可以通过抛出异常的方法的方式来终止相关代码的运行,不必通过返回值。 捕捉异常的catch子句,语法与其他语言中不太一样。在Scala里,借用了模式匹配的...
    • 1、Scala抛出异常
    • 2、Scala捕获异常

    Scala 的异常处理和其它语言比如 Java 类似。
    Scala 的方法可以通过抛出异常的方法的方式来终止相关代码的运行,不必通过返回值。
    捕捉异常的catch子句,语法与其他语言中不太一样。在Scala里,借用了模式匹配的思想来做异常的匹配,因此,在catch的代码里,是一系列case字句,finally 语句用于执行不管是正常处理还是有异常发生时都需要执行的步骤
    如下例所示:

    例子:

    package DataStructureAndAlgorithm
    
    /**
      * Created by Administrator on 2017/12/27.
      */
    
    import java.io.FileReader
    import java.io.FileNotFoundException
    import java.io.IOException
    object Test7IllegalArgumentException {
    
      def main(args: Array[String]) {
        try {
          val f = new FileReader("input.txt")
        } catch {
          case ex: FileNotFoundException => {
            println("Missing file exception")
          }
          case ex: IOException => {
            println("IO Exception")
          }
        } finally {
          println("Exiting finally...")
        }
      }
    
    }
    
    展开全文
  • Scala数据结构

    2019-05-29 21:20:10
    Scala数据结构 主要的集合特质 Scala同时支持可变集合和不可变集合,优先采用不可变集合。集合主要分为三大类:序列(List),集(set),映射(map)。所有的集合都扩展自Iterable特质。对几乎所有的集合类,Scala...

    Scala数据结构

    主要的集合特质

    Scala同时支持可变集合和不可变集合,优先采用不可变集合。集合主要分为三大类:序列(List),集(set),映射(map)。所有的集合都扩展自Iterable特质。对几乎所有的集合类,Scala都同时提供了可变和不可变版本。

    • Seq是一个有先后次序的值的序列。IndexedSeq能够通过整形下表快速访问
    • Set是一个没有先后顺序的集合。
    • Map是一组键值对偶,SortedMap按照键的排序访问其中的实体。

    数组

    定长数组

    val nums  = new Array[Int](10)
    

    变长数组

    var b = ArrayBuffer[Int]()
    

    Array与ArrayBuffer的互转

    ArrayBuffer = Array.toBuffer
    Array = ArrayBuffer.toArray
    
    //遍历数组
    
    for (i <- nums) println(i)
    
    for (i <- 0 to nums.length - 1) println(nums(i))
    
    for (i <- 0 until nums.length) println(nums(i))
    

    数组转换

    转换动作不会修改原数组,而是产生一个新的数组

    多维数组

    和java一样,多维数组通过数组的数组来实现,可以使用ofDim方法实现

    val array = Array.ofDim[Int](2, 3)
    
    //赋值
    array(0)(0)=10
    array(0)(1)=11
    array(0)(2)=12
    array(1)(0)=20
    array(1)(1)=21
    array(1)(2)=22
    
    //遍历
    for (i <- array; j <- i) println(j)
    

    和java数组的互操作

    Scala数组是通过java进行实现的,所以可以进行互相转换操作,使用AsJavaConverters 或者 AsScalaConverters 进行转换

    import scala.collection.mutable.ArrayBuffer
    import scala.collection.JavaConverters._
    
    val a = ArrayBuffer("hello", "world")
    //转为Java对象 b.command()可以调用java的方法
    val b = new ProcessBuilder(a.asJava)
    
    
    //转为Scala
    val sb = b.command().asScala
    
    
    

    映射

    映射就是KV的集合,类似于Java中的Map

    映射操作

    import scala.collection.mutable
    
    //不可变的构造映射
    val map = Map("name" -> "upuptop", "age" -> 10)
    
    //可变映射
    val map2 = scala.collection.mutable.Map("name" -> "upuptop", "age" -> 10)
    //空映射
    val map3 = new mutable.HashMap[String, Int]()
    //对偶
    "name" -> "upuptop"
    //对偶元组
    var map4 = Map(("name" -> "upuptop"), ("age" -> 10))
    
    //获取值
    println(map("name"))
    
    //遍历值
    for (i <- map) println(i)
    
    //同时遍历键值对
    for ((k, v) <- map) println(s"key:${k},value:${v}")
    //遍历所有的键
    for (k <- map.keys) println(k)
    //遍历所有的值
    for (v <- map.values) println(v)
    
    //简便操作
    map.foreach(println(_))
    
    

    注意:

    • 根据键获取值,如没有键会抛异常,可以通过contains方法进行判断是否存在键
    • 不可变映射不能更新

    和Java的互操作

    与数组相同

    元组

    元组是不同类型值的聚集,元组使用_1、_2进行访问
    元组的下标识从1开始,不是从0开始

    //定义元组
    var aa = ("app", 123, false)
    //访问元组
    aa._1
    aa._2
    aa._3
    
    //打印结果
    aa: (String, Int, Boolean) = (app,123,false)
    res0: String = app
    res1: Int = 123
    res2: Boolean = false
    
    

    注意

    • 元组的下标识从1开始,不是从0开始
    • aa._1 可以写成aa _1(把点换成空格),不能省略空格
    • 元组可用于函数需要返回不止一个值的情况
    • 可以把多个值绑在一起以便他们以后能够被一起处理

    队列

    队列是一个先进先出的结构

    import scala.collection.mutable
    
    var q = new mutable.Queue[Int]()
    q += 1
    q +=2
    q ++= List(3,4,5)
    
    //出队 删除 1
    q.dequeue()
    
    //入队 新加6
    q.enqueue(6)
    
    q
    
    //获取第一个元素
    q.head
    //获取除了第一元素之外的其他元素
    q.tail
    
    打印结果:
    import scala.collection.mutable
    
    q: scala.collection.mutable.Queue[Int] = Queue()
    res0: scala.collection.mutable.Queue[Int] = Queue(1)
    res1: scala.collection.mutable.Queue[Int] = Queue(1, 2)
    res2: scala.collection.mutable.Queue[Int] = Queue(1, 2, 3, 4, 5)
    
    
    res3: Int = 1
    
    
    res4: Unit = ()
    
    res5: scala.collection.mutable.Queue[Int] = Queue(2, 3, 4, 5, 6)
    
    res6: Int = 2
    res7: scala.collection.mutable.Queue[Int] = Queue(3, 4, 5, 6)
    
    
    

    堆栈

    Stack 是一个先进后出的结构

    import scala.collection.mutable
    
    val s = new mutable.Stack[Int]();
    
    //入栈
    s.push(1,2,3,4)
    
    //出栈
    s.pop()
    
    s
    
    //取栈顶上的元素 但不出栈
    s.top
    
    //取除了栈顶的其他元素
    s.tail
    
    
    打印:
    import scala.collection.mutable
    
    s: scala.collection.mutable.Stack[Int] = Stack()
    
    
    res0: scala.collection.mutable.Stack[Int] = Stack(4, 3, 2, 1)
    
    
    res1: Int = 4
    
    res2: scala.collection.mutable.Stack[Int] = Stack(3, 2, 1)
    
    
    res3: Int = 3
    
    
    res4: scala.collection.mutable.Stack[Int] = Stack(2, 1)
    
    

    列表

    如果List为空,用Nil来表示

    val list1 = List(1, 2, 3)
    
    //第一个元素
    list1.head
    
    //除了第一个元素的之后元素
    list1.tail
    
    //将9 放到list1这个列表的最前面
    var list2 = 9 :: list1
    list2
    
    //组成9,4,2一个列表
    var list3 = 9 :: (4 :: (2 :: Nil))
    list3
    
    打印结果:
    list1: List[Int] = List(1, 2, 3)
    
    
    res0: Int = 1
    
    
    res1: List[Int] = List(2, 3)
    
    
    list2: List[Int] = List(9, 1, 2, 3)
    res2: List[Int] = List(9, 1, 2, 3)
    
    
    list3: List[Int] = List(9, 4, 2)
    res3: List[Int] = List(9, 4, 2)
    
    
    
    

    • 元素不重复
    • 无顺序,默认哈希
    • 有需集(SortedSet,红黑树实现)
    val set = Set(1, 2, 3, 3)
    val set2 = set + 5 
    set
    set.head
    set.tail
    
    打印结果:
    set: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
    res0: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 5)
    res1: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
    res2: Int = 1
    res3: scala.collection.immutable.Set[Int] = Set(2, 3)
    
    

    添加去除元素的操作符

    • 向后:+或向前+:追加元素到序列中
    • 添加+元素到无先后次序的集合中
    • -移除元素(map只能加不能减)
    • ++--来批量添加和移除元素
    • 对于列表,优先使用:::::
    • 改值操作有+=,++=,-=,--=
    • 集合可以使用&求交集,|并集
    • 优先使用++&|、尽量不用 ++:+=:++=:
    val set = Set(1, 2, 3, 3)
    val set1 = Set(2, 3, 4)
    //并集  1, 2, 3, 4
    set | set1 
    //交集 2, 3
    set & set1 
    
    

    常用方法

    在这里插入图片描述

    这些方法从不改变原有集合。他们返回一个与原集合类型相同的新集合

    将函数映射到集合

    将一元函数应用到集合中的每一个元素。
    map应用于集合中的每一个元素,并产生转换后的一个新元素。

    val names = List("peter", "Bob", "Mary")
    //List(peter, bob, mary)  通过map方法,传入函数应用到每个元素上
    names.map(_.toLowerCase)
    
    

    flatMap方法同样应用于集合的每一个元素,对于每一个元素产生的一个集合,并将集合中的元素串接在一起。

    val names = List("peter", "Bob", "Mary")
    
    def ulcase(s: String) = Vector(s.toLowerCase(), s.toUpperCase())
    
    //peter, PETER, bob, BOB, mary, MARY
    names.flatMap(ulcase(_))
    
    

    化简、折叠、扫描

    将二元函数应用到集合中的元素
    例如:
    化简操作:

    val list = List(1, 2, 3, 4, 5)
    //(((1-2)-3)-4)-5 = -13
    list.reduceLeft(_ - _)
    //1-(2-(3-(4-5))) = 3
    list.reduceRight(_ - _)
    
    

    折叠操作

    val list = List(1, 2, 3, 4, 5)
    //0-1-2-3-4-5
    list.foldLeft(0)(_ - _)
    //1-(2-(3-(4-(5-0))))
    list.foldRight(0)(_ - _)
    

    求字符出现的次数

    /*
      getOrElse
        第一个参数是key,如果该key存在,那么返回key对应的值
        第二个参数是默认值,如果key不存在,那么返回默认值
    
       freq += ('a' -> 0)
      //i: Int = 1
      val i = freq.getOrElse('u', 1)
      //a: Int = 0
      val a = freq.getOrElse('a', 1)
    */
    
    val line = "upuptop"
    
    var freq = scala.collection.mutable.Map[Char, Int]()
    
    //循环赋值 如果字符存在那么拿到存储的值进行加1操作  如果没有存储 k为字符 v为1
    for (i <- line) freq(i) = freq.getOrElse(i, 0) + 1
    
    println(freq)
    
    
    
    

    扫描操作:
    扫描就是化简和折叠的结合。可以得到包含所有中间结果的集合:

    var list = List(1, 2, 3, 4, 5)
    list.scanLeft(0)(_ - _)
    list.scanRight(0)(_ - _)
    
    打印结果
    list: List[Int] = List(1, 2, 3, 4, 5)
    res0: List[Int] = List(0, -1, -3, -6, -10, -15)
    res1: List[Int] = List(3, -2, 4, -1, 5, 0)
    

    拉链操作

    作用于两个集合,将对应的元素合并成一个元组。

    var list = List(1, 2, 3, 4, 5)
    var list2 = List(2, 3, 4, 5, 6)
    
    //List((1,2), (2,3), (3,4), (4,5), (5,6))
    list.zip(list2)
    //List((1,0), (2,1), (3,2), (4,3), (5,4))
    list.zipWithIndex
    

    迭代器

    使用迭代器进行集合遍历

    var list = List(1, 2, 3, 4, 5)
    val iterator = list.iterator
    while (iterator.hasNext) {
      println(iterator.next())
    }
    
    或者:
    
    for (i <- iterator) println(i)
    
    

    流(不可变列表)

    流Stream只有在需要的时候才会去计算下一个元素,是一个尾部被懒计算的不可变列表。
    #::操作符用于返回流。

    // #:: 返回一个流
    def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm( n + 1 )
    
    val tenOrMore = numsForm(10)
    
    tenOrMore.tail
    
    tenOrMore.head
    
    // 获取最后一个元素
    tenOrMore.tail.tail.tail
    
    var squares = numsForm(5).map(x => x * x)
    
    squares.take(5).force
    
    //squares.force   不要尝试对一个无穷流的成员进行求值,OutOfMemoryError
    

    懒视图

    可以对其他集合使用view方法是集合具有懒执行的行为,该方法产出一个器方法总是被懒执行的集合、但是view不会缓存数据,每次都要重新计算

    // 通过View的懒执行
    val palindromicSquares = (1 to 100).view.map(x => {
      println(x);
      x * x
    })
    
    // Evaluates the first eleven
    palindromicSquares.take(10).mkString(",")
    
    // Contrast with streams
    def squares(x: Int): Stream[Int] = {
      println(x);
      x * x
    } #:: squares(x + 1)
    
    val palindromicSquareStream = squares(0)
    
    
    palindromicSquareStream(10)
    
    // Caution
    
    // Evaluates only the first ten
    palindromicSquares.take(10).last
    
    // Evaluates all elements
    palindromicSquares(10)
    
    

    与java集合互操作的总结

    在这里插入图片描述

    线程安全的集合

    • SynchronizedBuffer
    • SynchronizedMap
    • SynchronizedPriorityQueue
    • SynchronizedQueue
    • SynchronizedSet
    • SynchronizedStack
    var scores = new mutable.HashMap[String,Int]() with mutable.SynchronizedMap[String,Int]
    
    

    并行集合

    Scala为了充分利用多核CPU,提供了并行集合(有别于前面的串行集合),用于多核环境的并行计算。
    主要用的算法有:
    divide and conquer:分治算法
    Scala通过splitters,combiners等抽象层来实现。主要原理是将计算工作分解很多任务,分发给一些处理器去完成,并将它们处理结果合并返回
    work stealing:Work Stealing算法
    主要用于任务调度负载均衡。

    并行集合位于scala.collection.parallel,跟不同集合一样
    主要的实现类:

    • ParArray
    • ParHashMap
    • ParHashSet
    • ParRange
    • ParHashMap
    • ParHashSet
    • ParVector

    通过par关键字将集合转为一个并行集合,并行集合的扩展自ParSeq、ParSet、ParMap特质的类型,所有的特质都是ParIterable的子类型,但并不是Iterable的子类型。所以不能将并行集合传递为预期的Iterable、Seq、Map的方法。可以通过 ser方法将并行集合转为串行集合

    注意:在并行任务中,不要同时更新一个共享变量

    操作符概述

    1.如果想在变量名、类名、等定义中使用保留字,可以使用反引号:

    val `val` = 42
    

    2.A 操作符 B 等同于 A.操作符(B) 这种形式叫中置操作符
    3.后置操作符:A 操作符等同于 A.操作符 ,如果操作符定义的时候不带() 则调用的时候不能加()
    4.前置操作符,=-!~操作符 A 等同于 A.unary_操作符
    5.赋值操作符, A操作符= B 等同于 A = A 操作符 B

    展开全文
  • Scala 数据类型

    2016-07-12 18:10:54
    Scala 与 Java有着相同的数据类型,下表列出了 Scala 支持的数据类型:上表中列出的数据类型都是对象,也就是说 scala 没有 jav a中的原生类型。在 scala 是可以对数字等基础类型调用方法的。Scala 基础字面量Scala ...

    Scala 与 Java有着相同的数据类型,下表列出了 Scala 支持的数据类型:

    这里写图片描述

    上表中列出的数据类型都是对象,也就是说 scala 没有 jav a中的原生类型。在 scala 是可以对数字等基础类型调用方法的。


    Scala 基础字面量

    Scala 非常简单且直观。接下来我们会详细介绍 Scala 字面量。

    整型字面量

    整型字面量用于 Int 类型,如果表示 Long,可以在数字后面添加 L 或者小写 l 作为后缀。:

    0
    035
    21 
    0xFFFFFFFF 
    0777L

    浮点型字面量

    如果浮点数后面有f或者F后缀时,表示这是一个Float类型,否则就是一个Double类型的。实例如下:

    0.0 
    1e30f 
    3.14159f 
    1.0e100
    .1

    布尔型字面量

    布尔型字面量有 true 和 false。

    符号字面量

    符号字面量被写成: ‘<标识符> ,这里 <标识符> 可以是任何字母或数字的标识(注意:不能以数字开头)。这种字面量被映射成预定义类 scala.Symbol 的实例。
    如: 符号字面量 ‘x 是表达式 scala.Symbol(“x”) 的简写,符号字面量定义如下:

    package scala
    final case class Symbol private (name: String) {
       override def toString: String = "'" + name
    }

    字符字面量

    在scala中字符类型表示为半角单引号(‘)中的字符,如下:

    'a' 
    '\u0041'
    '\n'
    '\t'

    其中 \ 表示转移字符,其后可以跟 u0041 数字或者 \r\n 等固定的转义字符。

    字符串字面量

    字符串表示方法是在双引号中(“) 包含一系列字符,如:

    "Hello,\nWorld!"
    "scala编程入门"

    多行字符串的表示方法

    多行字符串用三个双引号来表示分隔符,格式为:”“” … “”“。
    实例如下:

    scala从入门到精通
    scala从入门到放弃
    scala从入门到出门"""
    

    Null 值

    空值是 scala.Null 类型。

    Scala.Null 和 scala.Nothing 是用统一的方式处理 Scala 面向对象类型系统的某些”边界情况”的特殊类型。
    Null类是null引用对象的类型,它是每个引用类(继承自AnyRef的类)的子类。Null不兼容值类型。

    Scala 转义字符

    下表列出了常见的转义字符:
    这里写图片描述

    0 到 255 间的 Unicode 字符可以用一个八进制转义序列来表示,即反斜线‟\‟后跟 最多三个八进制。
    在字符或字符串中,反斜线和后面的字符序列不能构成一个合法的转义序列将会导致 编译错误。
    以下实例演示了一些转义字符的使用:

    object Test {
       def main(args: Array[String]) {
          println("学习\tscala\n\n编程" );
       }
    } 

    运行结果:
    这里写图片描述

    展开全文
  • Scala处理json数据

    2016-12-29 17:22:54
    json的操作类似scala.xml._ api的特性 val json: JsValue = Json.parse(jsonString) val json = Json.parse(jsonString)val maybeName = (json \ "user" \ name).asOpt[String]val emails = (json \ "user" \\ ...
  • Scala 异常处理package scala_learn.demo13_Exceptionimport java.io.{FileNotFoundException, FileReader, IOException}/** * Created by liguohua on 2017/3/31. */ /** * 1.在scala中的异常和java中的异常处理...
  • Scala XML处理

    千次阅读 2016-04-10 13:07:02
    Scala XML处理       简介 XML是一种半结构化数据的形式。它比单纯的字符串更为结构化,因为它把数据内容组织成了树结构。尽管如此,单纯的XML的结构化程度依然比不上编程语言的对象,因为它允许在标签之间存在...
  • 四.Scala 数据类型

    2017-04-24 11:40:54
    Scala 数据类型 1.Scala数据类型Scala 与 Java有着相同的数据类型,下表列出了 Scala 支持的数据类型: 数据类型 描述 Byte 8位有符号补码整数。数值区间为 -128 到 127 Short 16位有符号补码整数。数值区间为 ...
  • 数据处理基础之scala编程语言入门

    千次阅读 2019-07-05 19:45:52
    概要: 1.为什么要学习scala? 2.scala的介绍 3.与java语言的对比 ...大数据学习时数据处理的两种方式: 1)离线计算 : MapReduce 2)在线计算 : spark a.spark 底层是scala ,我们需要看源码 b.sca...
  • scala异常处理

    千次阅读 2018-08-06 19:20:17
    scala的异常机制和java的异常机制是一样的,抛出的异常必须是java.lang.Throwable的子类,但是scala中没有“受检”异常的机制。 //这是java的“受检”异常的方式,在可能抛出异常的方法上做出声明 //scala中没有...
  • 数据处理,MapReduce,Spark,Scala

    千次阅读 2019-05-31 13:12:03
    数据处理实验 实验目的 理解MapReduce、SPARK在Hadoop大数据平台中的作用; 掌握基本的MapReduce编程方法; 了解MapReduce解决一些常见的数据处理问题; 掌握基本的Spark shell编程; ...
  • Scala数据集合操作

    千次阅读 2016-08-22 17:49:36
    大数据技术是数据的集合以及对数据集合的操作技术的统称,具体来说: ...Spark的框架实现语言是Scala,首选的应用程序开发语言也是Scala,所以Scala对集合以及集合操作的支持就至关重要且必须异常强
  • 一、Scala数据类型

    2019-08-22 11:16:25
    1、scala数据类 型体系一览图 2、scala数据类型列表 二、数据类型 1、整数类型 2、浮点类型 3、字符类型(Char) 4、布尔类型:Boolean 5、Unit类型、Null类型和Nothing类型 三、值类型转换 1、值类型隐式...
  • appengine-rx - 在 Appengine 上的 Scala 中的React式数据处理。 React式编程思想的应用不是请求处理,而是数据处理管道。 非常早期的发展阶段。 入口点: 将 RxModule 安装到您的 Guice 配置模块中。 安装任意...
  • kafka->spark->streaming->mysql(scala)实时数据处理示例
  • 该库包含一堆用于使用Scala Spark进行数据处理的低级基本方法。 目标是从spark作业代码中删除最多的高度使用和高度重复的低级代码,并将其替换为经过充分测试的,名称易于说明和可读的方法。 这也提供了监视/记录...
  • PowerPoint 演示文稿;PowerPoint 演示文稿;...Scala的安装与体验;PowerPoint 演示文稿;PowerPoint 演示文稿;PowerPoint 演示文稿;PowerPoint 演示文稿;PowerPoint 演示文稿;PowerPoint 演示文稿;PowerPoint 演
  • 而大多数的Scala数据框架都能够把Scala数据集合API和抽象数据类型相统一,比如Scalding中的TypedPipe与Spark中的RDD都有相同的方法,包括map、flatMap、filter、reduce、fold和groupBy,这样使用Scala来处理就更为...
  • 它的主要特点有:支持二进制序列化方式,可以便捷,快速地处理大量数据;动态语言友好,Avro提供的机制使动态语言可以方便地处理 Avro数据。 示例代码: import com.gensler.scalavro.types.AvroType import ...
  • Scala:数据类型和变量

    千次阅读 2016-10-23 15:51:26
    http://blog.csdn.net/pipisorry/article/details/52902158Scala数据类型Scala 与 Java有着相同的数据类型,下表列出了 Scala 支持的数据类型:数据类型描述Byte8位有符号补码整数。数值区间为 -128 到 127Short16位...
  • scala处理文件常用算法 Scala文件处理 (Scala file handling) File handling is storing, excessing and modifying data from in a file. In Scala, we can fetch data from a file, store data in a file in ...
  • Scala处理JSON

    万次阅读 2016-09-12 16:15:02
    Scala处理json的时候,使用java的json-lib  def main(args: Array[String]): Unit = {  val str2 = "{\"et\":\"kanqiu_client_join\",\"vtm\":1435898329434,\"body\":{\"client\":\"866963024862254\",\...
  • Scala如何处理(多级)JSON字符串

    千次阅读 2017-07-26 18:56:43
    Scala如何处理(多级)JSON字符串1.JSON.parseFull 简单JSON格式import scala.util.parsing.json.JSONval jsonStr = """{"username":"Ricky", "age":"21"}""" val jsonValue = JSON.parseFull(jsonStr)val jsonObj = ...
  • Scala

    万次阅读 多人点赞 2017-11-27 21:05:26
    Scala安装与配置 1 安装 2 配置IDEA 二 Scala基础 1 Hello Scala 11 IDEA运行HelloScala程序 12 控制台运行HelloScala程序 2 声明值和变量 3 常用类型 31 常用类型介绍 32 常用类型结构图 4 算数操作符重载 5 ...
  • scala

    千次阅读 2019-12-29 00:06:39
    Scala https://www.scala-lang.org/ 一、概述 Scala是一门多范式的编程语言,一种类似java的编程语言 [1] ,设计初衷是实现可伸缩的语言 [2] 、并集成面向对象编程和函数式编程的各种特性。 为什么要学习scala编程...
  • scala处理json文件

    千次阅读 2017-08-11 14:48:34
    读取json数据处理并保存 输入文件数据为json格式,csid.txt {"bid": "1","品牌":"奥迪","厂商":"一汽-大众奥迪","csid":"5"} {"bid": "1","品牌":"奥迪","厂商":"奥迪(进口)","csid":"63"} {"bid": "1","品牌":...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,548
精华内容 25,019
关键字:

scala数据处理