Scala--第一天

一、scala的语言类型

1. 编译型语言
2. 强数据类型编程语言（数据有类型，变量也有类型）

二、Scala的用处

1. 开发大数据（spark，Flink，Kafka）
2. 表达能力强，胜过Java，开发效率高
3. 兼容Java，可直接访问Java类库

三、基本语法

　　1.标识符：①大小写敏感；②不可使用关键字或保留字；③望文生义

　　2.变量的定义： var/val 变量名：变量类型 = 初始值

　　　　　　　　　e.g：var name:String="cmx"

　　　　　　　　　注意：var定义的变量是可以重新赋值的；val定义的不可以重新赋值

　　3.类型推断：var name="cmx"，在Scala中，如果没有写变量的类型，Scala会根据变量的初始值来推断出变量的类型

　　4.惰性赋值：lazy val name="cmx"，这种写法的意义在于：当一个变量过大时，无需马上加载到内存，可以惰性赋值，在用的时候，给其分配内存空间，减少内存的压力

　　　　　　　　注意：传统的赋值，会在赋值成功后，立刻开辟新的内存空间

　　　　　　　　　　　惰性赋值只能使用 val 关键字  var关键字用不了

　　5.Scala的字符串

　　　　①使用双引号：var name:String="cmx" ，var  n:String="c" ， var a:Char='v'

　　　　  ②使用三引号：var s:String="""

　　　　　　　　　　　　　　　　　　select *

　　　　　　　　　　　　　　　　　　from

　　　　　　　　　　　　　　　　　　user

　　　　　　　　　　　　　　　　 """

　　　　　　可以保持换行的格式

　　　　③插值表达式：用于字符串的拼接

　　　　　方式一：使用"+"  var ss ="cmx", print(name+name.length)

　　　　　方式二：插值表达式，var/val 变量名：变量类型 = s"${变量}字符串"

　　　　　　　　　e.g：var name ="cmx"

　　　　　　　　　　　print(s"名字为${name}")

　　6.常见的数据类型

        　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　7.类型层次结构

1. 根类 Any 的子类： AnyVal 、AnyRef 。
2. AnyVal子类：Char、Byte、Short、Int、Long、Float、Double、Boolean、Unit
3. AnyRef子类：ScalaObject、String、Seq、List、Array、Iterable、Other Scala Classes、Other Java Classes、Null
4. Null是继承自AnyRef的类，是每个引用类的子类
5. Nothing是任何其他类型的子类型

　　几个重点说明：

• Any scalla中所有类型的父类，有俩个子类AnyVal，AnyRef
• AnyVal 所有数值类型的父类
• AnyRef 所有引用对象的父类
• Unit特殊数值类型，只用于方法（函数）声明的时候，表达这个函数没有返回值
• Null是AnyRef的子类，可以赋值给所有的引用类型的对象 null
• Nothing scala内部使用，不可直接创建对象

　　8.运算符

     

　　注意：Scala中没有a++,a--，但是有a+=1,a-=1

　　　　　字符串值的对比用 == 或者 equals方法  ：var a="cc" var b="dd" print(a==b) 或者 print(a.equals(b))

　　　　　字符串引用的对比 用eq()方法 ：print(a.eq(b))

　　9.Scala表达式

1. 变量+运算符 构成的一个式子
2. 每个表达式都有其对应的结果，可以是字符串 布尔值 数值
3. 语句块，用{}括起来的部分，每个语句块 都有对应的返回值（语句块中最后一行的内容），且可以赋值给其他变量

var a={
　　print(1+1)
　　1+2
}
println(a)
6##结果位3

　　10.流程控制

　　流程控制同其他语言大致相同，分为三类：1.顺序流程；2.分支流程；循环流程

　　①顺序流程 自上而下 从左至右依次执行          注意：函数的定义与调用，不受定义顺序的限制

object test1 {
  def func():Unit={
    print("我是一个函数")
  }
  def main(args: Array[String]): Unit = {
    println(1+2)
    func()
  }
##输出结果
3
我是一个函数

　　②分支流程（条件选择流程）

　　格式：

if(布尔表达式){}
else if(布尔表达式){}
...
else{}

　　Scala中没有三元运算符，但是有类似Java中的运算代码如下

  def main(args: Array[String]): Unit = {
    var b = 1
    var a = if (b > 0) 2 else 4
    print(a)
  }
###结果
2

　　③for循环，while循环 知道循环的次数用for  不知道用while

　　示例代码：

    for(i<- 1 to 10){    ##闭区间用to
      print(i+",")
    }
    println()
    for(j<-1 until 10){   ##开区间用until
      print(s"${j},")
    }
###结果
//    1,2,3,4,5,6,7,8,9,10,
//    1,2,3,4,5,6,7,8,9,
#若循环中只有一个表达式 可以简化代码
for(n<- 1 to 10)println(n)
###结果
//    1
//    2
//    3
//    4
//    5
//    6
//    7
//    8
//    9
//    10

　　嵌套循环

    //嵌套循环
    for (i <- 1 to 10) {
      for (j <- 1 to 8) {
        println(i + "," + j)
      }
    }
    //若嵌套循环中只有一个表达式，可以简化
    for(i<-1 to 10 ;j<-1 to 10){
      println(i + "," + j)
    }
  }

　　守卫

    //可以解决步长的问题
    for (i <- 1 to 10 if i % 2 == 0) {
      println(i)
    }
    //使用Range函数解决步长问题
    for(j<- Range(1,10,2)){
      println(j)
    }
  }

　　for推导式：在Scala中用来生成一个新的集合

    var newCollection = for (i <- 1 to 10) yield i * 10
    print(newCollection)
    println()
    var newCollection1 = for (i <- Range(1,10)) yield i * 10
    print(newCollection1)
###结果
//    Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)  ##vector 向量，载体的意思
//    Vector(10, 20, 30, 40, 50, 60, 70, 80, 90)

　　while循环

    var i = 1
    while (i < 10) {
      print(i)
      i += 1
    }

　　break，continue关键字

###break关键字
import scala.util.control.Breaks._
breakable(
      for (i<-1 to 10){
        if(i>5)break()
        else println(i)
      }
    )
###结果
//    1
//    2
//    3
//    4
//    5
###continue关键字
    for (j<-1 to 10){
      breakable(
        if (j==5)break()
        else println(j)
      )
    }
###结果
//    1
//    2
//    3
//    4
//    6
//    7
//    8
//    9
//    10