Scala进阶源码实战之三——文件IO、正则表达式、高阶函数

最新推荐文章于 2022-06-29 19:27:29 发布
最新推荐文章于 2022-06-29 19:27:29 发布
阅读量748 收藏
点赞数
分类专栏： scala Scala进阶源码实战 文章标签： 函数 scala 正则表达式 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Crystal_Zero/article/details/51193784
版权

文件

import scala.io.Source
import java.io.PrintWriter
import java.io.File

object FileOps {
    def main(args: Array[String]) {
        val file = Source.fromFile("test.txt") 
        for (line <- file.getLines){ println(line)}
        file.close

        val webFile = Source.fromURL("http://spark.apache.org/")
        webFile.foreach(print)
        webFile.close

        val writer = new PrintWriter(new File("scalaFile.txt" ))
        for (i <- 1 to 100) writer.println(i)
        writer.close()

        print("Please enter your input : " )
        val line = readLine
        println("Thanks, you just typed: " + line)
    }

正则表达式

object RegExpressOps {

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

    val regex="""([0-9]+) ([a-z]+)""".r
    val numPattern = "[0-9]+".r
    val numberPattern = """\s+[0-9]+\s+""".r

    // findAllIn方法返回遍历所有匹配项的迭代器
    for (matchString <- numPattern.findAllIn("99345 Scala, 22298 Spark")) println(matchString)
//99345
//22298
    println(numberPattern.findFirstIn("99ss java, 222 hadoop"))
//  Some( 222 )    有Some 是因为有可能为空 
    println(numberPattern.findFirstIn("99ss java, 22a hadoop"))
//  None    
    val numitemPattern="""([0-9]+) ([a-z]+)""".r

    val numitemPattern(num, item) = "99 hadoop"

    val line = "93459 spark"     //93459    spark
//    val line = "934s59 spark"     //Oops..
    line match{
      case numitemPattern(num, blog) => println(num + "\t" + blog)
      case _ => println("Oops...")

    }

  }

}

高阶函数

package functions
import scala.math._

object func {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet


      (1 to 9).map("*" * _).foreach(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



    val fun = ceil _                              //> fun  : Double => Double = <function1>
    val num = 3.14                                //> num  : Double = 3.14
    println(fun(num) )                            //> 4.0
   Array(3.14, 1.42, 2.0).map(fun).foreach(println)
                                                  //> 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)
                                                  //> res0: Array[Double] = Array(9.42, 4.26, 6.0)
    Array(3.14, 1.42, 2.0).map{ (x: Double) => 3 * x }
                                                  //> res1: 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

    println(high_order_functions((x: Double) => 3 * x))
                                                  //> 0.75
    high_order_functions((x) => 3 * x)            //> res2: Double = 0.75
    high_order_functions(x => 3 * x)              //> res3: 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>
}

闭包

    val data = List(1, 2, 3, 4, 5, 6)             //> data  : List[Int] = List(1, 2, 3, 4, 5, 6)
        var sum = 0                       //> sum  : Int = 0
        data.foreach(sum += _)

        def add(more: Int) = (x: Int) => x + more
                                                  //> add: (more: Int)Int => Int
        val a = add(1)                    //> a  : Int => Int = <function1>
        val b = add(9999)                 //> b  : Int => Int = <function1>
        println(a(10))                    //> 11
        println(b(10))                    //> 10009

偏函数

  val data = List(1, 2, 3, 4, 5, 6)               //> data  : List[Int] = List(1, 2, 3, 4, 5, 6)
    data.foreach(println _)                       //> 1
                                                  //| 2
                                                  //| 3
                                                  //| 4
                                                  //| 5
                                                  //| 6
    data.foreach(x => println(x))                 //> 1
                                                  //| 2
                                                  //| 3
                                                  //| 4
                                                  //| 5
                                                  //| 6

    def sum(a: Int, b: Int, c: Int) = a + b + c   //> sum: (a: Int, b: Int, c: Int)Int
    println(sum(1, 2, 3))                         //> 6
    // 偏函数， 不需要提供所有参数
    // 有几个参数被实例化，其他参数没有实例化
     //PartialAppliedFuntion 命名的意义
    val fp_a = sum _                              //> fp_a  : (Int, Int, Int) => Int = <function3>
    println(fp_a(1, 2, 3))                        //> 6
    println(fp_a.apply(1, 2, 3))                  //> 6
    val fp_b = sum(1, _: Int, 3)    //主要是这里       //> fp_b  : Int => Int = <function1>
    println(fp_b(2))                              //> 6
    println(fp_b(10))                             //> 14

    data.foreach(println(_))                      //> 1
                                                  //| 2
                                                  //| 3
                                                  //| 4
                                                  //| 5
                                                  //| 6
    data.foreach(println)                         //> 1
                                                  //| 2
                                                  //| 3
                                                  //| 4
                                                  //| 5
                                                  //| 6
zekizz
关注
专栏目录
Scala语法从入门到高级运用
默主归沙的博客
03-25 1437
题外话： 为什么要学习Scala语言？ Scala语言是Spark语言的基础，不会scala就无法入门spark语言。spark语言是大数据开发必备的语言，通过RDD运算对离线数据或者微批次数据进行处理。学大数据就一定要学Spark！ 复制代码 1、scala语言特点： 1. 面向对象的语言 2. 面向函数式编程的语言 3. 静态的语言 4. 扩展性良好 5. 支持Actor并发模型(多线程) 复制代码 2、函数式编程 1. 函数式编程，也是一种编程思想 2. 纯粹的函数式编程语言编写的..
java中Double类型的运算精度丢失的问题 (小数点多出99999999999999)
weixin_34220834的博客
08-25 3388
在使用Java，double 进行运算时，经常出现精度丢失的问题，总是在一个正确的结果左右偏0.0000**1。 特别在实际项目中，通过一个公式校验该值是否大于0，如果大于0我们会做一件事情，小于0我们又处理其他事情。 这样的情况通过double计算出来的结果去和0比较大小，尤其是有小数点的时候，经常会因为精度丢失而导致程序处理流程出错。 首先...
scala学习 之 及 基本和高级用法（二）
heihei
07-10 1392
1. Scala的数据类型 比Java多出的数据类型有: Unit： 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。 Nothing Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。 Nothing ：Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。 Any ：Any是所有...
Scala进阶
04-04 426
scala进阶： 开发环境：idea或者scalaIDE for eclipse 元组（tuple）：val triple = (100,”scala”,”spark) 数组（array)：val arr = Array(1,2,3,4,5) Map：val = ages = Map(“oddo” -> 12 , “jucy” ->18) File：val file = Source.f
scala语言
浅谈
05-28 4285
Scala的特点、Scala数据类型、Scala类型转换、Scala运算符、Scala循环控制、Scala的函数式编程、Scala集合的相关操作、Scala面向对象的编程、Scala模式匹配、Scala隐式转换、Scala泛型、Scala正则匹配等等相关内容。基本涵盖了Scala的基本操作。
Scala
WFSLIFE的博客
06-21 634
概述 Scala (Scalable Language, 可伸缩语言) , 从计算机的角度来讲, Scala是一门完整的可伸缩的完全面向对象的软件编程语言。之所以说它可伸缩, 是因为这门语言体现了面向对象, 函数式编程等多种不同的语言范式, 且融合了不同语言新的特性, 同时它也是一门强类型和静态类型的语言。在大数据领域中, 其开发效率更高, 更直观, 更容易理解。 Scala编程语言是由联邦理工学院洛桑(EPFL)的Martin Odersky于2003年设计研发的. 官网 : https://www.sc
Scala学习记录
杰之行的博客
02-04 713
Scala（发音为/ˈskɑːlə, ˈskeɪlə/）是一门多范式的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。洛桑联邦理工学院的Martin Odersky于2001年基于Funnel的工作开始设计Scala。Java平台的Scala于2003年底/2004年初发布。
Scala学习笔记
m0_55212193的博客
05-16 1475
Scala学习笔记字符串输出注释变量和常量数据类型值类型转换隐式转换强制类型转换演示取余%操作演示按位与&操作键盘输入 字符串输出 object InputDemo { def main(args: Array[String]): Unit = { val name:String ="张三" var age:Int =20 var money:Double =1820.5626 //字符串,通过+来连接 println(name+"今年"+age+"岁了"
Scala超全详解
热门推荐
lukabruce的博客
08-16 1万+
转自：【https://blog.csdn.net/c391183914/article/details/78647533?locationNum=2&amp;fps=1】 一 Scala安装与配置 1 安装 2 配置IDEA 二 Scala基础 1 Hello Scala 11 IDEA运行HelloScala程序 12 控制台运行HelloScala程序 ...
Scala语言学习
TT15751097576的博客
09-30 914
Scala语言 引言：其实代码没有你想象那么难，但是如果你想不到哪里去，就会很难. 学习一个技术或知识点的流程： 大数据技术生态体系 学习Scala的原因： ​ 1）Spara新一代内存级大数据框架，是大数据的重要内容。 ​ 2）Spark就是使用Scala编写的，因此为了更好的学习Spark，需要掌握Scala这门语言。 ​ 3）Scala是Scalable Language的简写，是一门多...
Scala-Scala学习笔记
Guardian_Bud
02-19 870
概述 scala是一门以java虚拟机（JVM）为目标运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。 scala是纯粹的面向对象的语言。java虽然是面向对象的语言，但是它不是纯粹的，因为java的基本数据类型不是类，并且在java中还有静态成员变量和静态方法。相反，scala是纯粹面向对象的，每个值都是对象，每个操作都是方法调用。 scala也是一个成熟的函数式语言。函...
Scala入门小纸条(2)
Nichkhun的博客
06-29 181
101. 只有主构造器可以调用超类的主构造器。主构造器调用超类构造器，辅助构造器调用主构造器，不能跨越。scala也用super来调用超类的方法102. scala重写非抽象方法必须用override；除了方法，scala也能重写字段103. 特质是将java接口变为更加通用的scala概念104. 判断是某个类的对象，而不是子类，可用如p.getClass==classOf[Employee]，其中classOf方法在scala.Predef被定义，会被自动引入 105. 与类型检查和转换相比，模式匹配是
Scala进阶源码实战之二——面向对象
Crystal_Zero的博客
04-19 1257
类的属性与私有字段 package OOP class Person { private var age = 0 def increment(){age += 1} def current = age def act(person: Person){ person.age } } class Student{ private var private
Scala进阶源码实战之七——链式调用、结构类型
Crystal_Zero的博客
04-21 1069
链式调用风格 //核心就在 this.type class Animal { def breathe: this.type = this } class Cat extends Animal { def eat : this.type = this } object Singleton_Types { def main(args: Array[String]): Unit = { val
Scala进阶源码实战之四——模式匹配
Crystal_Zero的博客
04-19 1063
basicpackage PatternMatchobject patternmatch { println("Welcome to the Scala worksheet") //> Welcome to the Scala worksheet val data =2 //> data : Int = 2
Scala进阶源码实战之一——数组、函数基础、流程控制、文件、异常
Crystal_Zero的博客
04-18 1061
Scala进阶源码实战系列，省去一些冗余的文字基础介绍，直接上代码，结合注释，实战进阶。为Spark打下语言基础。最好集中时间短时间突击完，计划一周。最开始的一些简单的借助ScalaIDE source sheet，帮助理解类型之类的数组package basicobject basics { println("Welcome to the Scala worksheet") //>
Scala进阶源码实战之五——List、Queue、Stack、Set、Map
Crystal_Zero的博客
04-19 946
Listpackage databaseobject list { println("Welcome to the Scala worksheet") //> Welcome to the Scala worksheet val bigData = List("Hadoop" , "Spark") //> bigData : List[String] = Lis
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值