《Scala 程序设计》 学习心得

一、前言

Spark 的源码是用 Scala 写的，要更好地掌握 Spark 的原理，就应学好 Scala
身边一个公司的大数据开发方面，使用 Spark ，语言工具是 Scala，附加平台 zepplin
再次研究总结了一下 Scala

二、代码

【1.基础语法】

package all

import scala.math._
/**
 * 【1.基础语法】
 * 因为Scala是基于Java虚拟机，也就是JVM的一门编程语言
 * 所以Scala和Java是可以无缝互操作的。Scala可以任意调用Java的代码
 *
 */
object base {

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

    // 1.val常量
    val name = "linhongcun"

    // 2.var变量
    var age = 21

    // 3.指定类型
    var account: Double = 20.18

    // 4.声明多个变量
    var iphone, desk = "单词"

    // 5.基本数据类型：Byte、Char、Short、Int、Long、Float、Double、Boolean
    var tag: Boolean = true

    // 6.操作符:scala中没有提供++、--操作符，但有 +=，-=
    age += 1

    // 7.函数调用
    println(min(5, 4)) // 函数库

  }
}

【2.条件控制与循环】

package all

/**
 * 【2.条件控制与循环】
 * 默认情况下，scala不需要语句终结符;，默认将每一行作为一个语句
 */
object controller2 {

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

    // 1.if-else
    if (1 > 2) {
      println("1>2")
    } else {
      println("1<2")
    }

    println(
      if (1 > 2) {
        1 // 有返回值
      } else {
        2
      });

    // 2.块表达式:最后一个语句的值就是块表达式的返回值
    var a, b, c = 1
    var d = if (a < 10) { b = b + 1; c + 1 }
    println("块表达式:" + d)

    // 3.输出
    print("---")
    println("+++")
    printf("届：%d，专业：%s", 2016, "计算机科学与技术\n")

    // 4.输入
    var word = readLine()
    println(word)

    // 5.while 循环
    var n = 3
    while (n > 0) {
      println(n)
      n -= 1
    }

    // 6.for语句
    var m = 3
    for (i <- 1 to m) println(i)
    for (i <- 1 to m if i % 2 == 0) println(i)

  }

}

【3.函数】

package all

/**
 * 【3.函数】
 */
object fun3 {

  // 1.定义函数
  def sayName(word: String) {
    println(word)
  }

  // 2.返回值
  def sumInt(a: Int, b: Int): Int = {
    a + b
  }

  // 3.默认参数
  def sayHello(name: String, age: Int = 20) {
    println("Hello, " + name + ", your age is " + age)
  }

  // 5.变长参数
  def sum(nums: Int*) = {
    var res = 0
    for (num <- nums) res += num
    res
  }

  // 7.过程函数 Unit
  def doSomethings(name: String): Unit = "Hello, " + name

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

    sayName("linhongcun")

    println(sumInt(2, 3))

    sayHello("larger5")

    // 4.带名传参
    sayHello(age = 18, name = "Mick")

    println(sum(1, 2, 3))

    // 6.使用序列调用变长参数
    println(sum(1 to 5: _*))

    println(doSomethings("666")) // 没有返回值

    // 8.lazy值:只有在第一次使用该变量时，变量对应的表达式才会发生计算
    lazy val music="Fade"
    println(music)
  }
}

【4.异常】

package all

import java.io.IOException

/**
 * 【4.异常】
 */
object exception5 {

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

    // 1.异常处理流程
    try {
      throw new IllegalArgumentException("x should not be negative")
    } catch {
      case e1: IllegalArgumentException => println("illegal argument")
      case e2: IOException              => println("io exception")
      case _: IllegalArgumentException  => println("Illegal Argument!")
    } finally {
      print("release resources!")
    }
  }

}

【5.数组】

package all

import scala.collection.mutable.ArrayBuffer

/**
 * 【5.数组】
 */
object array6 {

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

    // 1.定义Array 数组（长度不可变）
    val a = new Array[Int](3)
    // 1.1 查
    println(a(0))
    // 1.2 改
    a(0) = 6
    println(a(0))
    // 1.3 增

    // 2.定义 ArrayBuffer 数组（长度可变）
    val b = ArrayBuffer[Int]()
    println(b)
    // 2.1.1 增一个元素
    b += 1
    println(b)
    // 2.1.2 增加一个数组
    b ++= Array(7, 8)
    println(b)
    // 2.2 增 insert (位置，值)
    b.insert(0, 3)
    println(b)
    // 2.3 删(起始，终点)
    b.remove(0, 2)
    println(b)

    // 3.数组转换
    val c = a.toBuffer
    println(c)
    val d = b.toArray
    println(d)

    // 4.遍历 Array
    for (i <- 0 until d.length)
      println(d(i))

    // 5.Array 方法 max、min、sum、mkString、toString
    println(d.sum)
    println(d.mkString("~"))

    // 6.1.数组操作
    val d2 = for (ele <- d) yield ele * ele
    println(d2.mkString("-"))
    // 6.2.if 守卫
    val d3 = for (ele <- d if ele % 2 == 0) yield ele * ele // 只获取变动的数值
    println(d3.mkString("-"))
    // 6.3.函数式
    val d4 = d2.filter(_ % 2 == 0).map(2 * _) // 只获取变动的数值
    println(d3.mkString("-"))

  }

}

【7.类】

package opp

/**
 * 【7.类】
 * JavaBean 风格
 */
object oppclass {

  class Student() {

    // field
    private var name = "linhongcun" // 本可以直接访问

    // constructor
    def this(name: String = "默认名") {
      this()
      this.name = name
    }

    // getter
    def getName() = {
      this.name
    }

    // setter
    def setName(name: String) {
      this.name = name
    }
  }

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

    val s = new Student("绿茶")
    println(s.getName())
    s.setName("红茶")
    println(s.getName())

  }

}

【8.继承】

package opp

/**
 * 【8.继承】
 */
object oppextends {

  // 父
  class Person {
    private var name = "cun"
    protected var age = 18 // 子类可以直接访问
    def getName = name
  }

  // 子
  class Student extends Person {
    private var score = "A"
    def getScore = score

    // 覆盖非抽象方法
    override def getName = "linhongcun"
  }

  def main(args: Array[String]): Unit = {
    val student = new Student()
    println(student.getName)
    println(student.getScore)

    // isInstanceOf和asInstanceOf
    val p: Person = new Student
    var s: Student = null
    if (p.isInstanceOf[Student]) s = p.asInstanceOf[Student]
    // getClass
    println(s.getClass)
    println(p.getClass)
  }
}

【9.opptrat 接口】

package oppTrait

/**
 * 【10.opptrat 接口】
 * 类似 java 的接口
 */
object opptrat10 {

  trait Trait1 {
    def sayHello(name: String)
  }

  trait Trait2 {
    def sayGooBy(name: String)
  }

  // 继承后必须实现所有接口，格式：先 extends 再 with
  class Person(val name: String) extends Trait1 with Trait2 with Cloneable with Serializable {
    def sayHello(name: String) = println("Hello, " + name)
    def sayGooBy(name: String) = println(name + ",GoodBy")
  }

  def main(args: Array[String]): Unit = {
    val p: Person = new Person("绿茶")
    p.sayGooBy("abc")
    p.sayHello("abc")
  }

}

【10.函数式编程】

package oppTrait

/**
 * 【10.函数式编程】
 */
object funs10 {

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

    // 1.函数赋予变量（必须在函数后面加上空格和下划线）
    def sayHello(name: String) {
      println(name + ",hello")
    }
    val sayHello2 = sayHello _
    sayHello2("linhongcun")

    // 2.匿名函数（(参数名: 参数类型) => 函数体，语法和 ES6 有点像）
    val sayHelloFunc = (name: String) => println("Hello, " + name)
    sayHelloFunc("larger5")

    // 3.高阶函数（函数做为参数、返回值）
    // 闭包：函数在变量不处于其有效作用域时，还能够对变量进行访问
    val sayGoodBy = (name: String) => println("GoodBy, " + name)
    def greeting(func: (String) => Unit, name: String) { func(name) }
    greeting(sayGoodBy, "leo")

    // 4.1.常用高阶函数 map: 对传入的每个元素都进行映射，返回一个处理后的元素
    println(Array(1, 2, 3, 4, 5).map(2 * _).mkString("~"))
    // 4.2.常用高阶函数 foreach: 对传入的每个元素都进行处理，但是没有返回值
    (1 to 3).map("*" * _).foreach(println _)
    // 4.3.常用高阶函数 filter: 对传入的每个元素都进行条件判断，如果对元素返回true，则保留该元素，否则过滤掉该元素
    println((1 to 10).filter(_ % 2 == 0))
    // 4.4.常用高阶函数 reduceLeft: 从左侧元素开始，进行reduce操作，即先对元素1和元素2进行处理，然后将结果与元素3处理，再将结果与元素4处理，依次类推，即为reduce（1 * 2 * 3 * 4 = 24）
    println((1 to 4).reduceLeft(_ * _))
    // 4.5.常用高阶函数 sortWith: 对元素进行两两相比，进行排序
    println(Array(3, 2, 5, 4, 10, 1).sortWith(_ < _).mkString("~"))

    // 5.Currying函数：将原来接收两个参数的一个函数，转换为两个函数
    def sum(a: Int, b: Int) = a + b
    println(sum(1, 1))


  }
}

【11.集合函数编程】

package oppTrait

/**
 * 【11.集合函数编程】
 */
object ListSet11 {

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

    // 1.1 创建 List（不可变）
    val fruit1 = List("apples", "oranges", "pears")
    val fruit2 = List("mangoes", "banana")
    // 1.2 head代表List的第一个元素，tail代表第一个元素之后的所有元素
    println(fruit1.head)
    println(fruit1.tail)
    // 1.3 :::、:: 操作符
    val fruit = fruit1 ::: fruit2
    println(fruit)
    val fruit3 = fruit1.head :: fruit2.tail
    println(fruit3)

    // 2.1 创建 LinkedList （可变）
    val l = scala.collection.mutable.LinkedList(1, 2, 3, 4, 5); l.elem; l.next
    println(l)
    // 2.2 用elem可以引用其头部，使用next可以引用其尾部
    println(l.elem)
    println(l.next)
    // 2.3 案例：使用while循环将LinkedList中的每个元素都乘以2
    val list = scala.collection.mutable.LinkedList(1, 2, 3, 4, 5)
    var currentList = list
    while (currentList != Nil) {
      currentList.elem = currentList.elem * 2
      currentList = currentList.next
    }
    println(list)

    // 3.1 创建 Set
    val s = Set(1, 2, 3)
    println(s)
    // 3.2 增（不重复）
    s + 1
    println(s)

    // 4.1 函数式编程：添加一个前缀
    println(List("Leo", "Jen", "Peter", "Jack").map("name is " + _))
    // 4.2 函数式编程：拆分
    println(List("Hello World", "You Me").flatMap(_.split(" ")))
    // 4.3 输出所有
    println(List("I", "have", "a", "beautiful", "house").foreach(println(_)))
    // 4.4 关联
    println(List("Leo", "Jen", "Peter", "Jack").zip(List(100, 90, 75, 83)))


  }

}

【12.模式匹配】

package oppTrait

/**
 * 【12.模式匹配】
 * java switch case 加强版
 */
object oppOption12 {

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

    // 1  定义一个简单的 match
    def judgeGrade(name: String, grade: String) {
      grade match {
        case "A"                => println(name + ", you are excellent")
        case "B"                => println(name + ", you are good")
        case "C"                => println(name + ", you are just so so")
        case _ if name == "leo" => println(name + ", you are a good boy, come on")
        case _                  => println("you need to work harder")
      }
    }
    judgeGrade("linhongcun","A")

  }

}

三、其他

其他高级特性，有空再更新