第一章.Scala入门

1.概述

为什么学习Scala

  • Spark-新一代内存级大数据计算框架,是大数据的重要内容
  • Spark就是使用Scala编写的
  • Spark的兴起,带动Scala语言的发展

一.Scala发展历史

  1. - 创始人:马丁.奥德斯基(Martin Odersky),将函数式编程语言的特点融入到java中,发明了Scala和Pizza两种语言
  2. - jdk5.0 的泛型，for循环增强，自动类型转换等，都是从Pizza 引入的新特性。
  3. - jdk8.0 的类型推断，Lambda表达式就是从Scala引入的特性。

二.Scala与Java关系

$01[scala变量类型_运算符_循环控制] - 图1

三.Scala语言特点

  • Scala是一门以Java虚拟机(JVM)为运行环境,并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言
  • Scala是一门多范式的编程语言,Scala支持面向对象和函数式编程
  • Scala的源代码(.scala)会被编译成Java字节码(.class).然后运行于JVM之上,并可以调用现有的Java类库,实现两种语言的无缝对接
  • Scala单作为一门语言来看,非常的简洁高效

四.Scala环境搭建

  1. 确保JDK安装成功
  2. 下载对应的Scala安装文件scala-2.11.8.zip,并解压
  3. 配置Scala的环境变量
  4. 在Idea中安装对应的scala插件

五.HelloWorld案例

  1. 打开idea,新建一个maven项目(scala-study)
  2. 默认情况下,maven不支持scala的开发,需要引入scala的相关类库

$01[scala变量类型_运算符_循环控制] - 图2

  1. 创建项目的源文件目录,并右键->make directory as-> source root

$01[scala变量类型_运算符_循环控制] - 图3

  1. 默认情况下,会使用maven进行编译,则会报错,需要取消相关设置

$01[scala变量类型_运算符_循环控制] - 图4

  1. 新建一个包com.atguigu.chapter01,创建一个helloword
  1. package com.atguigu.chapter01
  2. /*
  3. *java中的main方法的语法: public static void main(String[] args){...}
  4. * scala object中所有的属性和方法都是类似java static修饰的
  5. * scala class中所有的属性和方法都是类似java 非static
  6. * Unit相当于java的void
  7. * Array代表字符串数组
  8. * def 是defined的缩写,是方法的标识符
  9. * */
  10. object HelloWord {
  11.   def main(args: Array[String]): Unit = {
  12.     println("hello word")
  13.   }
  14. }

第二章.变量和数据类型

1.注释

  1. package com.atguigu.chapter02
  3. object $01_Command {
  5.   /**
  6.     * java的注释:
  7.     *     单行注释: //
  8.     *     多行注释: /*..*/
  9.     *     文档注释: /** ..*/
  10.     * scala注释:
  11.     *     单行注释:
  12.     *     多行注释: /*..*/
  13.     *     文档注释: /** ..*/
  14.     */
  15.   def main(args:Array[String]): Unit ={
  16.     //单行注释
  17.     val name = "zhangsan"
  19.     /*
  20.     * 多行注释
  21.     * */
  22.     val age = 20
  23.   }
  25. }

2.标识符的命名规范

  1. package com.atguigu.chapter02
  3. /**
  4.  * java标识符的命名规范,必须是字母,数字,下划线,$,首字母不能是数字
  5.  * scala标识符的命名规范,必须是字母,数字,下划线,$,特殊符号,首字母不能是数字
  6.  * scala标识符的特殊符号是scala内部使用的
  7.  * 工作中,定义变量的时候依然采用驼峰原则
  8.  */
  9. object $02_ParamDefinedOperator {
  10.   def main(args:Array[String]): Unit={
  11.     var $name = "xxx"
  12.     var + = 10
  13.     println(+)
  14.   }
  15. }

3.变量

  1. package com.atguigu.chapter02
  2. /*
  3. * java定义变量: 类型 变量名 = 值
  4. * scala定义变量的语法: val/var 变量名:类型 =值
  5. *       val与var的区别:
  6. *           val修饰的变量类似java final修饰的,不能给变量重新赋值
  7. *           var修饰的变量类似java 非final修饰的,可以给变量重新赋值
  8. * scala定义变量的时候可以省略变量类型,省略之后scala会自动推断变量类型
  9. * scala中如果一行只写一个语句,分号可以省略,如果一行写多个语句,分号不能生=省略
  10. */
  11. object $03_ParamDefined {
  13.   def main(args:Array[String]): Unit ={
  14.     val name:String =  "zhangsan"
  15.     var age:Int = 20
  16.     println(name)
  17.     println(age)
  18.     //name = "lisi"
  19.     age = 100
  20.     println(age)
  21.     val address = "shenzhen"
  22.     print(address)
  23.   }
  25. }

4.字符串输出

  1. package com.atguigu.chapter02
  3. object $04_String {
  5.   /**
  6.    * java获取字符串的方式:
  7.    * 1.通过new的方式: new String("xxx")
  8.    * 2.直接"": "xxx"
  9.    * 3.通过+拼接: "aa" + "bb"
  10.    * 4.可以通过一些方法: substring,toString
  11.    *
  12.    * scala获取字符串的方式:
  13.    * 1.通过new的方式: new String("xxx")
  14.    * 2.直接 "": "xxx"
  15.    * 3.拼接
  16.    *   1.通过+拼接:"aa" + "bb"
  17.    *   2.通过插值表达式: s"${变量名/表达式/值}"
  18.    * 4.可以通过一些方法: substring,toString
  19.    * 5.通过三引号的方式: """..."""
  20.    */
  21.   def main(args:Array[String]):Unit={
  22.     //1.通过new的方式创建
  23.     val name = new String("hello")
  24.     println("===============================")
  25.     println(name)
  26.     //2.直接""
  27.     val sex = "man"
  28.     println("===============================")
  29.     println(sex)
  30.     //3.通过+拼接
  31.     val namesex = name + "_" +sex
  32.     println("===============================")
  33.     println(namesex)
  34.     //4.通过插值表达式
  35.     val namesex2 = s"${name}_${sex} ${2+1} ${3}"
  36.     println("===============================")
  37.     println(namesex2)
  38.     //5.可以通过一些方法:substring,toString
  39.     val hello = namesex.substring(4)
  40.     println("===============================")
  41.     println(hello)
  42.     println("===============================")
  43.     val host = "hadoop102"
  44.     val port = 8020
  45.     val url = "http://%s:%d/xx/xx/xx"
  46.     //%s: 字符串占位符
  47.     //%d: 整数占位符
  48.     //%f: 浮点型占位符
  49.     val url2 = url.format(host,port)
  50.     println("===============================")
  51.     println(url2)
  52.     //三引号
  53.     val sql = "select " +
  54.       "id,"+
  55.     "name,"+
  56.     "age,"+
  57.     "sex"+
  58.     " from person a"+
  59.     " left join student b"+
  60.     "on a.id = b.id"
  61.     println("===============================")
  62.     println(sql)
  64.     val table = "person"
  65.     val sql2 =
  66.       s"""
  67.         |select
  68.         | a.id
  69.         | b.name
  70.         | b.age
  71.         | a.sex
  72.         |  from ${table} a left join student b
  73.         |     on a.id = b.id
  74.         |""".stripMargin
  76.     println("===============================")
  77.     println(sql2)
  78.     val json = "{\"name\":\"lisi\",\"age\":20}"
  79.     println("===============================")
  80.     println(json)
  81.     val json2 = """{"name":"lisi","age":20}"""
  82.     println("===============================")
  83.     println(json2)
  84.   }
  87. }

$01[scala变量类型_运算符_循环控制] - 图5

5.键盘输入

  1. package com.atguigu.chapter02
  3. import scala.io.{Source, StdIn}
  5. object $05_StdIn {
  6.   //从控制台读取数据: StdIn.readLine()/readInt/readChar/..
  7.   //读取本地文件: Source.fromFile(path).getLines()
  8.   def main(args:Array[String]):Unit ={
  9.     val line = StdIn.readLine("请输入一行语句:")
  10.     println(line)
  11.     println("==========================")
  12.     println(Source.fromFile("d:/test.csv").getLines().toList)
  13.   }
  14. }

6.数据类型

  1. package com.atguigu.chapter02
  3. object $06_DataType {
  4.   /**
  5.    * java的数据类型
  6.    *  1.基本数据类型
  7.    *  byte,short,int,long,float,double,char,boolean
  8.    *  2.引用类型
  9.    *  string,集合,数组,其他class
  10.    *scala是完全面向对象的语言
  11.    * Any: 所有类的父类
  12.    *    AnyVal:值类型
  13.    *        Byte,Short,Int,Long,Float,Double,Char,Boolean
  14.    *        Unit:相当于java的void,有一个实例()
  15.    *        Stringops:scala针对 java string的扩展
  16.    *    AnyRef:引用类型
  17.    *        String,java集合/数组/class,scala的集合/数组/class
  18.    *        Null:所有引用类型的子类,有一个实例null,一般用于给引用类型变量赋予初始值,在赋予初始值的时候必须指定变量类型
  19.    *   Nothing: 所有类型的子类
  20.    *
  21.    */
  23.   def main(args:Array[String]): Unit={
  24.     val u = ()
  25.     println(u)
  26.     println("=====================")
  27.     var name:String = null
  28.     println(name)
  29.     name = "lisi"
  30.     println("=====================")
  31.     println(name)
  32.     //val n = new Nothing
  33.     //println(n)
  34.   }
  36. }

7.类型转换

  1. package com.atguigu.chapter02
  3. object $07_TypeCover {
  4.   /**
  5.    * 数字与数字的转换
  6.    *      低精度转高精度[Int->Long]:自动转换
  7.    *      高精度转低精度[Long->Int]:toXXX方法
  8.    * 数字和字符串的转换
  9.    *      字符串转数字:toXXX方法
  10.    *      数字转字符串:拼接,toString
  11.    */
  12.   def main(args:Array[String]): Unit={
  13.     //低精度转高精度[Int->Long]:自动转换
  14.     val a:Int = 10
  15.     val b:Long = a
  16.     println(b)
  17.     //高精度转低精度[Long->Int]
  18.     val c:Long = 10L
  19.     val d:Int = c.toInt
  20.     println(d)
  21.     //字符串转数字
  22.     val s = "10"
  23.     val e:Int = s.toInt
  24.     println(e)
  25.     val f:Double = s.toDouble
  26.     println(f)
  27.   }
  29. }

第三章.运算符

  1. package com.atguigu.chapter03
  3. /**
  4.  * java的操作符:
  5.  *    算术运算符: + - * / ++  -- %
  6.  *    逻辑运算符: && || !
  7.  *    比较运算符: < > <= >= != ==
  8.  *    赋值运算符: += -= *= /=
  9.  *    位运算符: << >> >>> $ |
  10.  *    三元运算符: 布尔表达式?true:false
  11.  * scala没有三元运算符,++ --
  12.  *    算术运算符: + - * / %
  13.  *    逻辑运算符: && || !
  14.  *    比较运算符: < > <= >= != ==
  15.  *    赋值运算符: += -= *= /=
  16.  *    位运算符: << >> >>> $ |
  17.  * scala的操作符是一个个的方法
  18.  * scala的方法的调用有两种方式:
  19.  *    1.对象.方法名(参数值,...)
  20.  *    2.对象 方法名 (参数值,...)  [如果方法只有一个参数,参数的()可以忽略]
  21.  *
  22.  */
  24. object $01_Operator {
  25.   def m1(x:Int):Int = x + 10
  26.   def main(args:Array[String]):Unit ={
  27.     val d = 1.+(2)
  28.     println(d)
  29.     val f = 1+2
  30.     println(f)
  31.     val g = $01_Operator.m1(10)
  32.     println(g)
  33.     val h = $01_Operator m1 20
  34.     println(h)
  35.   }
  36. }

第四章.流程控制

1.块表达式

  1. package com.atguigu.chapter04
  3. object $01_Block {
  4.   /**
  5.    * java的流程控制语句
  6.    *      1.分支判断
  7.    *      if-else
  8.    *      switch
  9.    *      2.循环
  10.    *      for,while,do-while
  11.    * scala的流程控制
  12.    *      1.分支判断:if-else
  13.    *      2.循环:for,while,do-while
  14.    * 块表达式:由{}包裹的一段代码称之为块表达式,块表达式有结果值,结果值是{}中最后一个表达式的结果值
  15.    *
  16.    */
  17.   def main(args:Array[String]):Unit={
  18.     val r = {
  19.       println("hello...")
  20.       val c = 10
  21.       val d = 20
  22.       val e =c+d
  23.       c+d
  24.     }
  25.     println(r)
  26.     10+20
  27.   }
  29. }

2.if-else

  1. package com.atguigu.chapter04
  3. object $02_if {
  4.   /**
  5.    * java关于分支判断的用法
  6.    *  单分支: if(布尔表达式){....}
  7.    *  双分支: if(布尔表达式){....} else {....}
  8.    *  多分支: if(布尔表达式){....} else if(布尔表达式){....}.. else{..}
  9.    *  scala if 语句的用法与java的完全一致
  10.    *  scala中if-else语句有返回值,返回值是符合条件的分支的{}中最后一个表达式的结果值
  11.    */
  12.   def main(args:Array[String]):Unit={
  13.     //单分支
  14.     val a = 10
  15.     if(a % 5 == 0){
  16.       println("a是5的倍数")
  17.     }
  18.     //双分支
  19.     val r = if(a%3==0){
  20.       println("a是3的倍数")
  21.       20
  22.     }else{
  23.       println("a不是3的倍数")
  24.       10
  25.     }
  26.     println(r)
  27.     //多分支
  28.     val result = if(a%4==0){
  29.       println("a是4的倍数")
  30.       100
  31.     }else if(a%3==0){
  32.       println("a是3的倍数")
  33.       200
  34.     }else{
  35.       if(a%2==0){
  36.         println("a是偶数")
  37.         300
  38.       }else{
  39.         println("a是奇数")
  40.         400
  41.       }
  42.     }
  43.     println(result)
  45.   }
  47. }

3.for循环

  1. package com.atguigu.chapter04
  3. object $03_For {
  4.   /**
  5.    * ===================================
  6.    * for循环两个重要方法
  7.    *    to方法:
  8.    *    语法:start.to(end) / start to end
  9.    *    to方法会生成一个左右闭合的集合
  10.    *    until方法
  11.    *    语法:start.until(end) / start until end
  12.    *    until方法会生成一个左闭右开的集合
  13.    * ===================================
  14.    * for循环基本语法:for(变量 <- 集合/数组/表达式){....}
  15.    * ===================================
  16.    * 守卫:for(变量<- 集合/数组/表达式 if(布尔表达式)){....}
  17.    * ===================================
  18.    * 步长:for(变量<-start to/until end by step){....}
  19.    * ===================================
  20.    * 嵌套for循环:for(变量<- 集合/数组/表达式; 变量名 = 值;变量<- 集合/数组/表达式;...){....}
  21.    * ===================================
  22.    * 引入变量:for(变量<- 集合/数组/表达式; 变量名=值; 变量<- 集合/数组/表达式;...){.....}
  23.    * ==================================
  24.    * yield表达式:
  25.    *        for循环默认没有返回值,如果想要for循环有返回值需要在{}之前加上yield关键字
  26.    *        语法:for(变量<- 集合/数组/表达式) yield{....}
  27.    * ==================================
  28.    */
  31.   def main(args:Array[String]):Unit ={
  32.     //for循环基本语法
  33.     for(i<- 1 to 10){
  34.       println(s"i=${i}")
  35.     }
  36.     println("*" * 100)
  37.     //for循环结合条件判断
  38.     for(i<- 0 to 10){
  39.       println(s"i+i=${i+i}")
  40.       if(i%2==0){
  41.         println(s"i=${i}")
  42.       }
  43.     }
  44.     println("+" * 100)
  45.     //守卫
  46.     for(i<- 0 to 10 if(i%2==0)){
  47.       println(s"i=${i}")
  48.     }
  49.     //步长
  50.     for(j<- 1 to 10 by 2){
  51.       println("j=" + j)
  52.     }
  53.     println("-" * 100)
  54.     //嵌套for循环
  55.     for(i<- 1 to 10){
  56.       val k = i * i
  57.       for(j<- 1 to k){
  58.         println(s"i+j=${i+j}")
  59.       }
  60.     }
  61.     println("%" * 100)
  62.     for(i<- 1 to 10; j<- 1 to i){
  63.       println(s"i+j=${i+j}")
  64.     }
  65.     println("&" * 100)
  66.     //引入变量
  67.     for(i<- 1 to 10 ; k = i * i ; j<- 1 to k){
  68.       println(s"i+j=${i+j}")
  69.     }
  70.     //yield表达式
  71.     val result = for(i<- 1 to 10) yield{
  72.       i * i
  73.     }
  74.     println(result.toList)
  75.   }
  77. }

4.while循环和do..while循环

  1. package com.atguigu.chapter04
  3. object $04_WhileAndDoWhile {
  4.   /**
  5.    * scala while与do-while用法与java完全一样
  6.    * while循环是先判断后执行
  7.    * do-while是先执行后判断
  8.    */
  9.   def main(args:Array[String]): Unit ={
  11.     //while
  12.     var a = 11
  13.     while(a<=10){
  14.       println(s"a=${a}")
  15.       a=a+1
  16.     }
  17.     //do-while
  18.     var b = 11
  19.     do{
  20.       println(s"b=${b}")
  21.       b=b+1
  22.     }while(b<=10)
  23.   }
  25. }

5.break and continue

  1. package com.atguigu.chapter04
  3. import scala.util.control.Breaks.{break, breakable}
  5. object $05_BreakAndContinue {
  7.   /**
  8.    * break:结束整个循环
  9.    * continue:结束本次循环开始下一次循环
  10.    *
  11.    * scala没有break和continue
  12.    * scala实现break/continue
  13.    *      1.导包:import scala.util.control.Breaks._
  14.    *      2.使用breakable与break方法实现
  15.    */
  16.   def main(args: Array[String]): Unit = {
  17.     var a =0
  18.     //break
  19.     /*try {
  20.       while (a <= 10) {
  21.         if (a == 5) {
  22.           throw new Exception("...")
  23.         } else {
  24.           println(s"a=${a}")
  25.           a = a + 1
  26.         }
  27.       }
  28.     } catch {
  29.       case e:Exception=>
  30.     }*/
  32.     //continue
  33.     /*while (a<=10){
  34.       try {
  35.         if (a == 5) {
  36.           a = a + 1
  37.           throw new Exception
  38.         } else {
  39.           println(s"a=${a}")
  40.           a = a + 1
  41.         }
  42.       } catch {
  43.         case e:Exception =>
  44.       }
  45.     }*/
  46.     //scala实现break
  47.     breakable({
  48.       while(a<=10){
  49.          if(a==5){
  50.            break()
  51.          }else{
  52.            println(s"a=${a}")
  53.            a=a+1
  54.          }
  55.       }
  56.     })
  57.     //scala实现continue
  58.     var b = 0
  59.     while (b<=10){
  60.       breakable({
  61.         if(b==5){
  62.           b=b+1
  63.           break()
  64.         }else{
  65.           println(s"b=${b}")
  66.           b=b+1
  67.         }
  68.       })
  69.     }
  71.   }
  73. }