scala

scala总结
1.scala简介和SDK的安装
1.1(1)（初级）熟练使用scala编写Spark程序
(2)（中级）动手编写一个简易Spark通信框架
(3)（高级）为阅读Spark内核源码做准备
(4)Scala是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台（Java虚拟机）(JS平台)，并兼容现有的Java程序。
1.2为什么要学Scala
(1)优雅：这是框架设计师第一个要考虑的问题，框架的用户是应用开发程序员，API是否优雅直接影响用户体验。
(2)速度快：Scala语言表达能力强，一行代码抵得上Java多行，开发速度快；Scala是静态编译的，所以和JRuby,Groovy比起来速度会快很多。
(3)能融合到Hadoop生态圈：Hadoop现在是大数据事实标准，Spark并不是要取代Hadoop，而是要完善Hadoop生态。JVM语言大部分可能会想到Java，但Java做出来的API太丑，或者想实现一个优雅的API太费劲。
1.3Scala编译器安装
(1)安装JDK
因为Scala是运行在JVM平台上的，所以安装Scala之前要安装JDK
(2)安装Scala
(2.1)Windows安装Scala编译器
访问Scala官网http://www.scala-lang.org/下载Scala编译器安装包，目前最新版本是2.12.x，但是目前大多数的框架都是用2.11.x编写开发的，Spark2.x使用的就是2.11.x，所以这里推荐2.11.x版本，下载scala-2.11.8.msi后点击下一步就可以了
(2.2)Linux安装Scala编译器
下载Scala地址http://downloads.typesafe.com/scala/2.11.8/scala-2.11.8.tgz然后解压Scala到指定目录
tar -zxvf scala-2.11.8.tgz -C /usr/java
配置环境变量，将scala加入到PATH中
vi /etc/profile
export JAVA_HOME=/usr/java/jdk1.8.0_111
export PATH=$PATH:$JAVA_HOME/bin:/usr/java/scala-2.11.8/bin
(2.3)Scala开发工具安装
目前Scala的开发工具主要有两种：Eclipse和IDEA，这两个开发工具都有相应的Scala插件，如果使用Eclipse，直接到Scala官网下载即可http://scala-ide.org/download/sdk.html。

由于IDEA的Scala插件更优秀，大多数Scala程序员都选择IDEA，可以到http://www.jetbrains.com/idea/download/下载社区免费版，点击下一步安装即可，安装时如果有网络可以选择在线安装Scala插件。这里我们使用离线安装Scala插件：

1.4安装IDEA，点击下一步即可。由于我们离线安装插件，所以点击Skip All and Set Defaul
1.5安装Scala插件：Configure -> Plugins -> Install plugin from disk -> 选择Scala插件 -> OK -> 重启IDEA
2.下载IEDA的scala插件，地址http://plugins.jetbrains.com/?idea_ce
1.6创建scala项目new project -> scala -> idea -> scala-SDK-2.11.12(scala SDK) -> SRC -> new -> scala class -> class,object(main),case…
2.2.变量的定义和使用

package cn._51doit.day01
object VariableTest {
  def main(args: Array[String]): Unit = {
    var abc = 125
    var edf: Int = 125
    var fgh = "helloworld"
    var ijk: String = "helloworld"
    var lmn = 10.0
    var opq: Double = 10.0
    println(edf)
    //定义可变的量
    var i = 11
    var j: Int = 12
    var a = 25
    var b: Int = 25
    //定义不可变得量
    val c = "bababamamamadididiyeyeye"
    val d: String = "bababamamamadididiyeyeye"
    val m = "hello"
    val n: Double = 10.0
    println(n)
  }
}

3.3.for循环的使用

package cn._51doit.day01
  object ForDemo {
    def main(args: Array[String]): Unit = {
      val string = "abcdefabcdef"
      for(b <- string){
        println(b)
      }
      val arr125 = Array(1,2,3,4,5,6)
      for(a <- arr125){
        println(a)
      }
      for(c <- arr125) println(c)
      for(d <- 0 to arr125.length - 1){
        println(d)
        println(arr125(d))
      }
      for(e <- 0 until arr125.length){
        println(e)
        println(arr125(e))
      }
      for(f <- arr125.indices){
        println(f)
        println(arr125(f))
      }
      val h = for(g <- arr125) yield g * 10
      for(i <- h){
        println(i)
      }
      val k = for(j <- arr125 if j % 2 == 0) yield j * 10
      for(l <- k){
        println(l)
      }
      for(i <- 1 to 3;j <- 1 to 3 if i != j) println((10 * i + j) + " ")
      val str = "abcdef"
      //局部变量<-循环的数组或集合
      for(b <- str){
        //println(b)
      }
      val arr = Array(1,2,3,4,5,6)
      for(e <- arr)println(e)
      for(f <- 0 to arr.length - 1){
        //println(f)
        println(arr(f))
      }
      for(f <- 0 until arr.length){
        println(arr(f))
      }
      for(f <- arr.indices) {
        println(arr(f))
      }
      val g = for(e <- arr) yield e * 10
      for(h <- g){
        println(h)
      }
      for(i <- 1 to 3; j <- 1 to 3 if i != j) print((10 * i + j) + " ")
      val i = Array(1,2,3,4,5,6,7,8,9,10)
      val j = for(k <- i if k % 2 == 0) yield k * 10
      for(l <- j) println(l)
    }
  }

4.4.运算符重载成方法

package cn._51doit.day01
object MethodDemo {
  def main(args: Array[String]): Unit = {
    println(1 + 2)
    println(1.+(2))
    println(1 to 10)
    println(1.to(10))
    println(1 - 2)
    println(1.-(2))
  }

5.方法的定义

package cn._51doit.day01
object MethodDemo {
  def main(args: Array[String]): Unit = {
    println(1 + 2)
    println(1.+(2))
    println(1 to 10)
    println(1.to(10))
    println(1 - 2)
    println(1.-(2))
    val j = m1(5,6)
    println(j)
    val k = m2(5,6)
    println(k)
    val l = ss(1,2)
    println(l)
    m3()
    m3
    m4
    mw()
  }
  def m5(x: Int,y: Int): Int = {
    println("++++++++++")
    x + y
  }
  def m6(x: Int,y:Int) = {
    x + y
  }
  def m7(): Unit = {
    println("helloworld")
  }
  def m8: Unit = {
    println("helloworld")
  }
  def m9{
    println("heloworld")
  }
  def m10(a: Int,b: Int): Int ={
    m9
    a + b
  }
  def m1(x: Int,y:Int): Int = {
    println("++++++")
    x + y
  }
  def m2(x: Int,y:Int) = {
    x + y
  }
  def m3(): Unit ={
    println("helloworld")
  }
  def m4: Unit ={
    println("helloworld")
  }
  def mw(){
    println("hahaha")
  }
  def ss(a: Int,b: Int): Int = {
    m4
    a * b
  }
}
package cn._51doit.day01
object MethodDemo {
  def main(args: Array[String]): Unit = {
    println(1 + 2)
    println(1.+(2))
    println(1 to 10)
    println(1.to(10))
    println(1 - 2)
    println(1.-(2))
    val j = m1(5,6)
    println(j)
    val k = m2(5,6)
    println(k)
    val l = ss(1,2)
    println(l)
    m3()
    m3
    m4
    mw()
  }
  def m5(x: Int,y: Int): Int = {
    println("++++++++++")
    x + y
  }
  def m6(x: Int,y:Int) = {
    x + y
  }
  def m7(): Unit = {
    println("helloworld")
  }
  def m8: Unit = {
    println("helloworld")
  }
  def m9{
    println("heloworld")
  }
  def m10(a: Int,b: Int): Int ={
    m9
    a + b
  }
  def m1(x: Int,y:Int): Int = {
    println("++++++")
    x + y
  }
  def m2(x: Int,y:Int) = {
    x + y
  }
  def m3(): Unit ={
    println("helloworld")
  }
  def m4: Unit ={
    println("helloworld")
  }
  def mw(){
    println("hahaha")
  }
  def ss(a: Int,b: Int): Int = {
    m4
    a * b
  }
}

6.函数的定义及其完整地定义

package cn._51doit.day01
object FunctionDemo {
  def main(args: Array[String]): Unit = {
    val a = func(5)
    //println(a)
    val b = f2(1,2)
    //println(b)
    //f0()
    //val c = (5)
    //println(c)
  }
  val f4 = (a: Int,b: Int) => (a + b)
  val f5: (Int,Int) => (Int) = (a,b) => (a * b)
  val f6: Int => Int = (x: Int) => (x * x)
  val f7: Int => Int = (x) => (x * x)
  val f8: Int => Int = x => (x * x)
  val f9: (Int,Double) => Double = (a: Int,b: Double) => (a + b)
  (x: Int) => x * x
  val func1 = (x : Int) => x * x
  val func2 : Int => Int = (x : Int) => x * x
  val func3 : Int => Int = (x) => x * x
  val func4 : Int => Int = x => x * x
  val func = (x: Int) => {
  x * x
  }
  val f1 : (Int,Int) => Int = (c,d) =>  c + d
  val f2 = (x:Int,y:Int) => x + y
  val f3 : (Int,Int) => Int = (a,b) => a + b
  val f0 = () => println("helloworld")
  (x: Int) => x * x
}

7.函数作为参数传到方法中

package cn._51doit.day01
object MethodAndFunction {
  def main(args: Array[String]): Unit = {
    val abc = m(5)
    //println(abc)
    //定义一个函数
    val f3 = (x: Int) => x * x
    val f1 = (x: Int) => x * x
    val f2 = (x: Int) => x + x
    val f4 = (x: Int) => x + x
    val f5 = (x: Int,y: Double) => x * y
    val b = mf2(f5)
    println(b)
    val c = m21(f2)
    println(c)
    m5(f5)
    //将函数作为参数传入到方法中
    //mf(f1)
    //val r = mf1(6, f2)
    //调研匿名函数
    val z = mf1(9,(x: Int) => x * 9)
    val r = mf1(8,(x: Int) => x * 10)
    //println(r)
  }
  def m(x: Int) : Int = x * x
  def m12(a: Int) : Int = a * a
  def m21(f: Int => Int): Int = {
    f(2)
  }
  def m3(v: Int,f: Int => Int): Int = {
    f(v)
  }
  def m4(f: Int => Int){
    println(f(5))
  }
  def m5(f: (Int,Double) => Double): Unit ={
    println(f(5,6.0))
  }
  def mf1(f:Int => Int){
    println(f(5))
  }
  //定义一个方法，方法的参数是一个函数
  def mf(f: Int => Int){
    println(f(5))
  }

  //输入两个参数的函数，第一参数时一个Int的值，第二个参数时一个函数，就是一个计算逻辑
  def mf2(v: Int, f: Int => Int): Int = {
    f(v)
  }
  def mf1(v: Int, f: Int => Int): Int = {
    f(v)
  }
  def mf2(f: (Int,Double) => Double): Unit = {
    println(f(5,6.0))
  }
  //方法要传入一个输入两个参数的函数
  def mf3(f: (Int,Double) => Double): Unit = {
    println(f(5, 6.0))
  }
}

8.数组的定义

package cn._51doit.day01
object ArrayDemo {
  def main(args: Array[String]): Unit = {
    val arra = Array(1,2,3,4,5,6)
    val arrb = new Array[String](10)
    arrb(0) = "a"
    arrb(1) = "b"
    arrb(2) = "c"
    val sum1 = arra.sum
    val max1 = arra.max
    val min1 = arra.min
    val length = arra.length
    val sorted1 = arra.sorted
    println(sorted1.toBuffer)
    val reverse1 = arra.reverse
    println(reverse1.toBuffer)
    val f4 = (a: Int) => a % 2 == 0
    val arrc = arra.filter(f4)
    val arrd = arra.filter((a: Int) => a % 2 == 0)
    val arre = arra.filter((a) => a > 0)
    val arrf = arra.filter(a => a > 0)
    val f5 = (a: Int) => (a * 100)
    arra.map(f5)
    arra.map(a => a * 2)
    arra.filter(a => a > 0).map(a => a * 2)
    arrb.map(a => a.toUpperCase)
    val arr1 = Array(1,2,3,4,5,6)
    val arr2 = new Array[Int](10)
    arr2(0) = 1
    arr2(1) = 2
    arr2(2) = 3
    val sum = arr1.sum
    println(sum)
    val min = arr2.min
    println(min)
    val max = arr2.max
    println(max)
    val arr3 = Array(1,2,5,3,4,6,7,8,9,10)
    val sorted = arr3.sorted
    println(sorted)
    val reverse = arr3.reverse
    println(reverse.toBuffer)
    val arr4 = for(i <- arr3 if i > 2)yield i
    println(arr4.toBuffer)
    val f1 = (x: Int) => x % 2 == 0
    val f2 = (y: Int) => y < 4
    val arr5 = arr3.filter(f1)
    val arr6 = arr3.filter(f2)
    val arr7 = arr3.filter((x:Int) => x % 2 != 0)
    val arr8 = arr3.filter((x) => x % 2 != 0)
    val arr9 = arr3.filter(x => x % 2 != 0)
    val arr10 = arr3.map(x => x * x)
    val abcabc = arr3.reduce((a, b) => a + b)
    println(abcabc)
    val defdef = arra.reduce((a, b) => a * b)
    println(defdef)
    println(arr10.toBuffer)
    val f3 = (x: Int) => (x * 100)
    val arr11 = arr3.map(f3)
    val arr12 = arr3.map(x => x * 2)
    val arr13 = Array("abc","def","lmn")
    val arr14 = arr13.map(x => x.toUpperCase)
    val arr15 = arr3.filter(x => x % 2 == 0).map(x => x * 125)
    val abc = arr3.reduce((x, y) => x + y)
    println(abc)
  }
}

package cn._51doit.day01
object IfDemo {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = if(a > 1) 25 else 10
    val c: Int = if(a > 1){
      25
    }else{
      10
    }
    val d = if(a > 1) 25 else "helloworld"
    val e: Any = if(a > 1){
      25
    }else if(a < 25){
      10
    }else{
      "HELLOWORLD"
    }
    println(e)
    val f = if(a > 1)125 else()
    val g = if(a > 125) 10//没有else返回Unit(无返回值类型)的一个实例即()
    val i = 10
    val j: Int = if(i > 25) 25 else 10
    val k = if(i > 0){
      10
      25
    }else{
      0
    }
    //println(k)
    val l = if(i > 1) 1
    val m: Any = if(i > 25) 1 else()
    val n = if(i > 0) 1 else "abc"
    val o = {
      if(i > 10){
        12
      }else if(i > 5){
        "125哦"
      }else{
        true
      }
    }
    println(o)
  }
}

9.匿名函数简写方式

package cn._51doit.day02
object ArrayDemo {
  def main(args: Array[String]): Unit = {
    val arr = Array(1,2,3,4,5,6,7,8,9,10)
    val arr1: Array[Int] = arr.filter(a => a % 2 == 0)
    val arr2: Array[Int] = arr.filter(_ % 2 == 0)
    val arr3: Array[Int] = arr.map(b => b * 10)
    val arr4: Array[Int] = arr.map(_ * 10)
    val arr5: Array[Int] = arr.filter(a => a % 2 == 0).map(a => a * 10)
    val arr6: Array[Int] = arr.filter(_ % 2 == 0).map(_ * 10)
    val a: Int = arr.reduce((x, y) => (x + y))
    val b: Int = arr.reduce(_ + _)
  }
}

10.将方法转成一个新的函数以及方法中传入函数的多种方式

package cn._51doit.day02
object MethodToFunction {
  def main(args: Array[String]): Unit = {
    val f = m _
    val a = f(5)
    println(a)
    val ff = (a: Int) => {
      m(a)
    }
    val b = ff(6)
    println(b)
    println("helloworld")
  }
  def m(x: Int): Int = {
    println("this method invoked")
    x + x
  }
}

package cn._51doit.day02
object CallByName {
  def main(args: Array[String]): Unit = {
    //语法糖
    val arr = Array(1,2,3,4,5,6,7,8,9,10)
    val r1: Array[Int] = arr.map(m)
    println(r1.toBuffer)
    //v