scala01

scala01课件

课程进度

scala课程，语言课程

spark源码是用scala写的，scala=面向对象+函数式编程的语言python

scala底层java 函数式编程

scala再java上层进行封装所以写入的代码比较灵活，比较少（优雅）

运行速度比较慢 scala --- java ----运行

javac java

scala的课程安排

课程目标

初级目标：

scala编写程序，语法，方法，对象，函数，集合List Set Map....

中级目标

写一个框架，rpc框架tcp协议，和yarn hdfs中的组件通信机制是一样的

高级目标

高级目标不是开发语言，是用scala看spark的源码

scala基础语法，方法，函数

scala的集合===spark操作

scala中的面向对象

scala的并发编程（scala中的多线程）

scala的高级语法

scala简介

scala是一门编程语言，底层使用java来写的，运行的时候需要jdk，运行再jvm中。运行的时候编译成。class文件，java运行

语法非常简单，使用非常方便，但是编译速度比较慢

scala-lang.org官网

scala的特点就是编程速度极快

mr wordcount mapper reduce

Source.formFile(“aaa.txt”).flatMap(_.split(“ ”)).map((_,1)).groupBy(_._1).mapValues(_.length)

scala的安装

首先安装jdk

安装scala -- 环境变量 --- scala文件夹（scala_home/bin）

安装的时候如果需要下载就去官网下载 zip tar.gz rar

linux安装

下载tar.gz ---加压 --- /etc/profile,jdk一定是1.8以上的

idea安装

www.jetbrains.com

再idea中安装scala的插件

不要从网络安装，从磁盘进行安装

安装scala插件以后进行重启

创建scala项目

idea中的设置 ctrl+alt+s进行项目设置

在设置的搜索栏中设置font encoding system setting对于整个项目的设置

ctrl+d快速复制一行内容

ctrl+y 删除一行

ctrl+alt+i格式化

ctrl+alt+v生成变量

double shift全文搜索

alt+insert生成set get toString ....

scala的基础语法

java中的数据类型

byte short int long double float char boolean

scala中九种基础数据类型

Byte Short Int Long Double Float Char Boolean Unit

Nothing是any的子类型 Null是anyRef的子类型

与java相比多了一种数据类型unit=（）在scala中unit相当于void，unit只有一个值（）

scala> var a = 1

a: Int = 1

scala> var a:Int = 1

a: Int = 1

scala> val b = 23

b: Int = 23

scala> val b:Int = 23

b: Int = 23

scala> a = 2

a: Int = 2

scala> b=34

<console>:12: error: reassignment to val

b=34

var和val都可以声明变量，如果不加入泛型就可以自适配类型，val修饰的变量的final形式的，不能修改其中的值

表达式

if else判断语句

ctrl+shift+F10运行

if(age>18)
println("u r adult")
else
println("u r child")

判断语句下面只有一行内容不需要加上{}

val result: AnyVal = if(age>18) {
false
}else
age

println(result)

如果分支中的数据类型不一致，那么我们将数据类型适配为最小的父类型

if判断语句中带有返回值的，默认不需要加return关键字，只需要是分支的最后一行内容就是返回数据结果

val result: AnyVal = if(age>18) {
age
}else{
()
}

相当于

val result: AnyVal = if(age>18) {
age
}

只有一个分支的时候，其实还有一个默认分支else{()}

for循环

  def main(args:Array[String]):Unit={
    //在scala中只有增强for循环
//      for(String s:list)
      var arr:Array[Int] = Array(1,2,3,4,5,6,7,8,9)
      for(i:Int<-arr)
        println(i)

//     to until
      for(i:Int<- 0 until 100){
        println(i)
      }

      println(0 to 100)
      println(0 until 100)

      for(i:Int<- 0 to arr.length-1)
        println(arr(i))

      for(i<- 0 until arr.length){
        if(arr(i)%2==1)
          println(arr(i))
      }
     //控制守卫

      for(i<- 0 until arr.length if(arr(i)%2==1)){
          println(arr(i))
      }

      //并列for循环
      for(i<-1 to 9){
        for(e<-1 to 9){
          println(e,"*",i)
        }
      }

      for(i<- 1 to 9 ; e<- 1 to 9){
        println(e,"*",i)
      }

      //var arr:Array[Int] = Array(1,2,3,4,5,6,7,8,9)
      for(e<-arr)
        println(e*10)

      val res = for(e<-arr){
        e*10
      }
      println(res)

      //yield关键字专门做for循环返回值的
      val res1 = for(e<-arr)yield e*10
      for(e<-res1)
        println(e)

        //要求得出100内的所有偶数
      //yield关键字在使用的时候什么都不能加
      val res2 = for(e<- 0 to 100 if(e%2==0)) yield e*10

      val res3 = for(e<-1 to 9;i<- 1 to 9)yield e+"*"+i
      for(t<-res3){
        println(t)
      }

      var res4 = for(e<-1 to 10) e*10
      println(res4)
    }

while循环

  def main(args:Array[String]):Unit={
       val count = 10
       var index = 0
      var flag:Boolean = true
      while(index<count&&flag){
//        index++
        index+=1
        if(index==9)
          flag= false
//          break
//          continue 没有continue关键字
          //break continue ++都不存在
        println("继续抄写项目流程。。。。。")
      }

      do{
        println("你来抓我呀？？？？？")
      }
      while(false)

    }

只有+= 在判断是否跳出while的时候，自己声明开关值

方法和函数

scala> def getName(name:String):String={

| "hello "+name

| }

getName: (name: String)String

scala> getName("lmc")

res0: String = hello lmc

scala> def printHello={

| println("hello jack")

| }

printHello: Unit

scala> def add(x:Int,y:Int)={

| x+y

| }

add: (x: Int, y: Int)Int

scala> def getNum={

| 3

| }

getNum: Int

scala> def getName=3

getName: Int

scala> getNum

res1: Int = 3

scala> getNum()

<console>:13: error: Int does not take parameters

getNum()

scala> def getNum()=3

getNum: ()Int

scala> getNum

res3: Int = 3

scala> getNum()

res4: Int = 3

定义方法的时候def methodName(args:Type.....):returnType={}

定义方法的时候参数列表如果没有那么调用的时候必须没有（）

如果定义的时候存在参数列表，但是参数列表是空的，可以在调用的时候加（）或者不加（）

方法中存在方法体如果是一行那么可以不加{}

如果不加方法的返回值类型，这个方法可以自适配

可变参数

scala> def sum(x:Int*){

| var sum:Int = 0

| for(i<-x)

| sum+=i

| sum

| }

sum: (x: Int*)Unit

scala> sum(1,2)

scala> sum(1,2,3)

scala> sum(1,2,3,4)

scala> def sum(x:Int*)={

| var sum = 0

| for(i<-x)

| sum+=i

| sum

| }

sum: (x: Int*)Int

java中的可变参数

public class Test1 {
    public static void main(String[] args) {
      System.out.println(sum(1,2,34));
    }
    public static int sum(int ...x){
        int sum = 0;
        for(int i:x){
            sum+=i;
        }
        return sum;
    }
}

return关键字和返回值类型

scala> def add(x:Int,y:Int):Int={

| return x+y

| }

add: (x: Int, y: Int)Int

scala> def add(x:Int,y:Int)={

| return x+y

| }

<console>:12: error: method add has return statement; needs result type

return x+y

如果加上return关键字，那么必须加上返回值类型

阶乘？

scala> def calculate(x:Int)={

| if(x==1)

| return 1

| else

| return x*calculate(x-1)

| }

<console>:13: error: method calculate has return statement; needs result type

return 1

<console>:15: error: method calculate has return statement; needs result type

return x*calculate(x-1)

scala> def calculate(x:Int):Int={

| if(x==1)

| x

| else

| return x*calculate(x-1)

| }

calculate: (x: Int)Int

scala> calculate(5)

res8: Int = 120

一旦出现了递归调用，必须加上返回值类型

函数

函数就是方法的另一种体现形式，也是讲一段代码进行封装，起到复用的作用

scala是函数式编程，所以函数是scala语言中的头等公民

声明方式：

scala> calculate(5)

res8: Int = 120

scala> val add=(x:Int,y:Int)=>x+y

add: (Int, Int) => Int = <function2>

scala> add(1,2)

res9: Int = 3

scala> val getMax=(x:Int,y:Int)=>{

| if(x>y)

| x

| else

| y}

getMax: (Int, Int) => Int = <function2>

scala> getMax(1,2)

res10: Int = 2

函数简单的声明方式

scala> val add=(x:Int,y:Int)=>x+y

add: (Int, Int) => Int = <function2>

scala> (x:Int,y:Int)=>x+y

res11: (Int, Int) => Int = <function2>

scala> res11(1,2)

res12: Int = 3

scala> val a = 2

a: Int = 2