scala_1

scala
        开发spark可以使用哪些语言：
            Python开发45%
            scala  35%
            java 20%

一、scala的概述
        java基础上代码的简化版、功能的加强版
        隐式转换
        高阶函数
            一个函数的参数是另一个函数 ，或者是返回值是一个函数
    1、scala继承了面向对象编程和面向函数式编程的各种特征，在2003年发布了基础java的第一个版本
        Object-Oriented Meets Functional

    scala 优雅 简洁  强大 

基于spark的开发使用scala语言实现wordcount

sc.textFile("/user/beifeng/input/wc.txt")  //RDD[String]
.flatMap(x=>x.split(" ")) // Array[(String)]
.map(x=>(x,1))  //Array[(String,Int)]
.reduceByKey((x,y)=>(x+y))     //Array[(String,Int)]
.saveAs("/user/beifeng/output1")    

hadoop hive hive spark
oozie flume
Array(hadoop hive hive spark oozie flume )
Array[(hadoop,1), (hive,1), hive spark oozie flume ]

    2、scala和java可以互操作
        java和scala共用jvm平台
        scala使用scalac编译器将源码编译成java的class文件
        可以在scala代码中直接调用所有的java类库
        也可以在java的代码中插入一段scala代码
    3、函数式链式编程一些以函数和对象两方面为主
        函数在scala中是一等公民
            函数可以被当做参数进行传递
            函数可以做为一个函数的返回值返回
            可以在函数中定义另一函数  

        重点：
            模式匹配
            高阶函数
                匿名函数
            隐式转换
                将一种数据类型偷偷转换成另一种数据类型
            trait类
                接口  

二、scala安装部署 

        下载路径：http://www.scala-lang.org/download/2.10.4.html
        window下：
            java需求提前配置好
            scala配置：
                scala-2.10.4.zip 解压到某个路径下
                配置环境变量：
                        JAVA_HOME  XXX
                        SCALA_HOME  XXX
                        PATH  %JAVA_HOME%/bin;%SCALA_HOME%/bin
        linux： 

三、scala基本使用 

        交互式命令行 -》  REPl   l->loop            

        scala是一种强类型语言
        但是scala可以自动推断数据类型
scala> val b = 3
       b: Int = 3    

scala> b+5
res0: Int = 8  //res0是系统提供的临时变量

scala> res0+1
res1: Int = 9

scala> println("hello world")
hello world    

    scala写第一个程序 

object HelloWorld {
    def main(args:Array[String]) {
    println("Hello,world!!!")
    }
}

$ scalac HelloWorld.scala
$ scala HelloWorld  

四、安装部署IDEA工具

    window/linux 版本
    window：
        安装前一定要配置好scala和java的环境变量
        启动-》选择主题-》都是下一步（不要选择任何插件）-》start
        集成scala插件：
            configure-》plugins-》install form disk -》选择scala插件-》重启
        Setting：
            appreance-》设置系统字体及主题
            keymap -》 设置快捷键风格-》eclipse
            editor->font->save as -> 设置代码字体风格 

        create new project
            scala -》设置项目名称及工程目录 -》选择本地安装的jdk的sdk

五、scala中变量的定义、数据类型、函数的定义及函数的参数类型  

    1、变量的定义
        使用val声明一个不可变变量
            scala> val a:Int=3
            a: Int = 3
            scala> a=4  //val声明的变量不能重新赋值
            <console>:8: error: reassignment to val
                   a=4
                    ^
        使用var声明一个可变变量
            scala> var c = 6
            c: Int = 6

            scala> c = 7
            c: Int = 7        

        在scala中声明变量的语法
            val/var a:Int=3
            语法：
                关键字（val/var）+ 变量名:数据类型（首写字母大写） = 值   

    2、scala中如何先定义一个为空值的变量
        scala> var name:String    //报错，需要给变量一个初始化值
        解决：
            scala> var name:String = ""
            scala> var name1:String = _   

    3、scala中的数据类型
        在scala中没有基本数据量和包装类之分，所有的数据类型都是类
        首写字母需要大写

    4、scala中的lazy 懒执行
        当val修饰的变量被lazy修饰时，它的初始化将被推迟，直到第一次去调用
        scala> lazy val price = 15.8
        price: Double = <lazy>   //此时没有将15.8赋值给price  

        scala> price  //当第一次去调用 price时系统才会进行赋值操作
        res3: Double = 15.8

        scala> lazy var price1 = 15.8
<console>:1: error: lazy not allowed here. Only vals can be lazy
       lazy var price1 = 15.8
            ^
    5、scala中函数的定义  

        def 函数名称（参数名称：参数类型）：返回类型 = {
            函数体内容
        }         

        因为scala可以自动推断数据类型，所以函数的返回值类型一般可以直接省略 

def min(x:Int,y:Int):Int = {

  if (x>y)
    y
  else
    x

}            

    6、文件编辑软件sublime介绍
        查看-》语法-》scala  

    7、当定义的函数为空参时，调用该函数时可以省略函数的括号
        def hello()={println("hello!!!")}
        def hello() = println("hello!!!")  //当函数体只有一句时可以省略大括号
        hello()
        hello 

        def hello():Unit = println("hello!!!")
            Unit在scala中表示无返回值类型，相当于java的void 

    8、函数中定义另一个函数
            函数的嵌套或闭包
            内函数可以调用外函数的变量  

def fun1(a: Int) = {
  def fun2(b: Int) = {
    println("a+b=" + (a + b))
  }
  fun2(200)
}

fun1(20)

    scala> :paste   //进入到粘贴模式  

     (ctrl-D to finish)  

     scala> fun1(100)
            a+b=300

    9、匿名函数 

        定义： (x:Int)=>{x+1}
        语法：（变量名：数据类型，...）=> { 函数体内容 }

        匿名函数的特点： 

        1、匿名函数可以赋值给一个函数
            def add=(x:Int,y:Int)=>{x+y}
            add(3,8)
        2、匿名函数可以赋值给一个变量
            val add=(x:Int,y:Int)=>{x+y}
            add(3,6) 

        考虑如何将一个非匿名函数赋值给一个变量 ？
            def add(x: Int, y: Int) = x + y
            val add1=add _  //函数名+空格+占位符
            add1(3,8)

    10、在scala的函数中可以指定参数的默认值（缺省值）        

def path(p: String="Desttop") = {
  println("the path is " + p)
}

path() //当传入参数时，会使用参数的默认值 

def loadConf(conf:String="spark-defalut.xml")={
  println("conf is "+conf )
}
    11、scala中可以使用*代表传入的参数为重复参数（变长参数）  

def printName(name:String*)={
  println("the name is "+name)
}
printName("zhangsan","lili","wangwu")

val arr=Array("lili","tom","mary")

printName(arr:_*)//通过声明arr为_*，表示告诉编译器我们传入的是一个个String类型的元素，而不是一个Array[String]         

六、scala中的流程控制语句及循环表达式
        while
        do while
        for
        breaks  

1、
val list=List("tom","mary","lio","lili")  //定义一个List集合不用使用new，使用的是List类的伴生对象里面的apply方法，通过apply方法帮我们new的List对象 

val list = List("tom", "mary", "lio", "lili")

var x = 0
while (x < list.length) {
  println(list(x))
  x += 1
}        

for (x <- list) {
  println(x)
}

“<-”是一个提取符，可以从集合中遍历提取出所有的元素 

break() 方法演示  

object LoopTest {
  def main(args: Array[String]) {
    val list = List("tom", "mary", "lio", "lili")
    val loop = new Breaks

    loop.breakable {

      for (x <- list) {
        println(x)
        if (x == "mary")
          loop.break()
      }
    }
    println("over........")

  }
}

-----------------------------------

2、scala中的循环表达式 

1 to 10  //包头包尾
1.to(10)  

1 until 10 //包头不包尾
1.until(10)    

Range(1,10)     //包头不包尾  

Range(1,-10,-3)   //可以给出step步长
Range(1,-10,0) //java.lang.IllegalArgumentException: step cannot be 0.

结合for循环使用循环表达式 

for (x<- 1.to(10)){
  println(x)
}

求1到10范围内的偶数 

for (x<- 1.to(10) if x%2==0 ){
  println(x)
}

七、元组 tuple  

    元组的定义 使用 括号 ()
        val tuple = (1, 3, "tom", 3.3, "lili") 

        tuple._1  //元组元素的获取
        tuple._3    

    总结 ：
        元组类型是scala和Python里特有
        在scala中，元组是n个不同数据类型对象的一个聚集
                n的最大的值是22
        Map的元素实际上是n=2的元组 ，即2元组 ，也是最简单的元组
        元组必须使用()来表示 

    元组元素的遍历 

val tuple = (1, 3, "tom", 3.3, "lili")
for (x<- 0 to tuple.productArity ) { //使用to为什么会报错
  println(tuple.productElement(x))
}

for (x<- 0 until  tuple.productArity ) { // until不报错
  println(tuple.productElement(x))
}

八、scala中的数组
    1、scala中数组的特点
        数组是相同数据类型固定大小的元素的连续集合
        数组的元素的角标从0开始

        数组的定义
            val arr=Array(33,11,66,88)  

    2、数组分为定长数组和变长数组 

        定长数组
            val arr=Array(33,11,66,88)    //默认是定长数组 

            数组的取值
                arr(0)
                arr(2)
            定长数组不支持更改数组元素长度或值的方法 

        变长数组
            val arr1=scala.collection.mutable.ArrayBuffer(11,22,44) 

            import scala.collection.mutable.ArrayBuffer
            val arr2=ArrayBuffer(55,99) 

        添加元素
            val arr1 = scala.collection.mutable.ArrayBuffer(11, 22, 44)
            val arr = Array(111, 222)
            arr1 += 55
            arr1
            arr1 +=(66, 77)
            arr1 ++= arr
        减去元素
            -=/--=

        变长数组可以使用的更改元素内容的方法
            arr1.insert(0,77,88)
            arr1  

            arr1.remove(3)
            arr1 

            arr1.trimEnd(2)
            arr1 

            arr1.toArray //变长数组转定长数组 

    3、数组的遍历 

for (x <- 0 until arr1.length) {
  println(arr1(x))
}

for (x <-arr1){
  println(x)
}        

    4、其他常用方法 

        排序：
            val arr1 = scala.collection.mutable.ArrayBuffer(55,11, 22, 44)
            val arr2=arr1.toArray
            scala.util.Sorting.quickSort(arr2)        //原来的数组变了
            arr2 

            arr1.sorted  //默认是升序排序，返回一个新的排好序的数组 ，原来的不变

        转换为字符串
            arr1.mkString("，")
            arr1.mkString("【",",","】")  //res1: String = 【55,11,22,44】

九、scala中的集合 

    scala中所有的集合类都在 scala.collection 包下
        scala.collection.mutable  包下是可变集合
            可变集合可以进行修改、添加、删除等操作，且是在原集合基础上进行的更新操作
        scala.collection.immutable  包下是不变集合
            不可变集合也可以模拟修改、添加、删除等操作，但是每次操作不是在原来集合基础上的更新操作，每次都会生产一个新的集合

    1、定长List集合 

        定长list集合的定义：
            val list = List(33,55,77,11)

        list.head  //返回第一个元素的值
        list.tail  //返回除第一个元素外的其他元素的集合
        Nil   //代表一个空的List集合  

        总结List集合是由head头和tail尾组成的  

        向定长list集合添加元素
            val list1=88::list  //添加元素后生产了一个新的list集合，原list集合元素没有变化
            val list2 =99::111::222::list    

            val list3=555::Nil   //通过这种方法也能创建一个list集合 

        删除list集合的元素
            list.drop(3) //表示从左数删除3个元素
                            原list集合元素没有变化  

    2、变长list集合
        定义
            val list=scala.collection.mutable.ListBuffer(44,11,88)
        添加元素（都是在原集合基础上进行的更新操作）
            list += 111
            list+=(444,666)
            list++= list1
        删除元素
                -=/--= 

        变长list集合的转换
            list.toList   定长list集合
            list.toArray  定长数组

        list集合的遍历
            for (x<-list){
              println(x)
            }

        list集合其他常用方法
            list.exists((x:Int)=> {x>55})  //通过exists方法判断list集合里面有没有大于55的元素 

            简化：
                list.exists((x:Int)=> x>55 )
                list.exists((x)=> x>55)   //scala可以自动推断数据类型
                list.exists(x=> x>55 ) //只有一个参数时可以省略括号
                list.exists(_ > 55 )  //当匿名函数的参数在函数体中只调用一次时可以这样写 

                list.filter(_ > 20)  //过滤出大于20的元素 

        3、Set
            PPT 参考list array   

        4、不可变Map集合
            定义：
                val map=Map("lili"->18,"tom"->19,"mary"->17)
            获取value
                map("tom")
                map("mary")
                //map("wangwu")

                //方法一
                if (map.contains("wangwu"))
                  map("wangwu")
                else
                  -1
                //方法二
                map.getOrElse("lili",-1)

        5、可变map集合 

            定义
                val map1=scala.collection.mutable.Map("lili"->18,"tom"->19,"mary"->17)
            更新或添加元素
                map1("lili")=19
                map1("lio")=21
                map1 +=("zhaosi"->23)

            map集合的遍历 

for ((x, y) <- map1) {
  println("key is " + x + ",value is " + y)
}

for ((key, _) <- map1) {
  println("key is " + key)
}

for ((_, value) <- map1) {
  println("value is " + value)
}

for (values <- map1.values){
  println("value is " + values)
}

比较安全的遍历方法 

for((key,value)<-map1){
  println("key is " + key+ ",value is " + map1.getOrElse(key,-1))
}                

        map集合的排序
            map1.toList.sorted.toMap