scala基础语法

scala基础语法

基础语法:变量及常量

变量的定义语法及测试*

  • 功能:定义一个值可变的变量

  • 语法

    var 变量名称:数据类型 =
    • Java中的写法:String name = “djn”
  • 测试

scala> var a:String = "djn"
a: String = djn

scala> println(a)
djn

scala> a = "sky"
a: String = sky

scala> println(a)
sky

scala> var b:Int = 20
b: Int = 20

scala> b = 10
b: Int = 10

scala> println(a+"\t"+b)
sky10


scala> var a = "spark"
a: String = spark

scala> var a = 1
a: Int = 1

scala> var a = 1.9
a: Double = 1.9

scala> var a = false
a: Boolean = false
    • Scala中大多数场景下可以自动推断类型
  • 常量的定义语法及测试

    • 功能:定义一个值不可变的常量

    • 语法

      val 常量名称:数据类型 = 值
      
    • 测试

    scala> val aa:String = "sky"
    

aa: String = sky

scala> println(aa)
sky

scala> aa = “djn”
:12: error: reassignment to val
aa = “djn”
^
```
初始值

  • 功能:用于构建一个变量时,指定初始值

  • 语法

    var 变量名称:数据类型 = _
    
  • 测试

scala> var a:Int = 0
a: Int = 0

scala> var a:String = null
a: String = null

scala> var a:Boolean = false
a: Boolean = false

scala> var a:Boolean = _
a: Boolean = false

scala> var a:String = _
a: String = null

scala> var a:Int = _
a: Int = 0

注意

  • 只能用于变量

  • 必须指定类型,不能自动推断类型

惰性赋值

  • 功能:构建一个常量时不直接赋值,只构建常量对象,当用到数据内容时,再真正赋值

  • 设计:避免值初始化以后,如果不被调用,占用内存,通过lazy使用时再进行初始化分配

  • 语法

lazy val 常量名称:数据类型 = 值

测试

scala> val aa:String = "sky"
aa: String = sky

scala> lazy val bb:String = "djn"
bb: String = 

scala> println(aa)
skt

scala> println(bb)
djn

scala> lazy var cc:String = "sky"
:1: error: lazy not allowed here. Only vals can be lazy
lazy var cc:String = "sky"
     ^
     ```
     **特点及注意事项**

- Scala代码不以分号结尾

- Scala中大多数场景可以自动推断类型

- Scala中推荐使用常量,不推荐使用变量:val

  - 如果需要变量的场景怎么办?可以用多个常量来代替变量的

  - var i = 1/2/3

    ```
    - val i1 = 1
    - val i2 =  2
    - val i3 = 3
    ```

- scala中名称在前、类型在后 中间以:分割

  - scala中类型首字母大写,大小写敏感

- 大多数场合写可以省去类型不写,编译器可以自动推导

- 初始值不能用于常量,只能用于变量,并且必须指定数据类型

- 惰性赋值只能用于常量,不能用于变量

  - 在scala中推荐使用val常量,可以使用函数式编程解决变量的问题
## 基础语法:数据类型
- **Scala中的数据类型**

  - 基本类型:Int、Double……

    - 变量存储的是值

  - 引用类型:String、集合、对象……

    - 变量存储的是内存地址

      

- **Scala中的数据类型运算**

  - 运算符:+、-、*、/ 、% ……

  - 本质:所有数据类型都是对象,所有数据类型的运算符都是这个对象的方法

  - 栗子

    ```scala
    scala> val a = 1
    a: Int = 1
    
    scala> val b = 2
    b: Int = 2
    
    scala> a + b				//中缀调用
    res6: Int = 3       
    
    scala> a.+(b)				//后缀调用
    res7: Int = 3
    ```

    

- **Scala中数据类型的层次结构**

 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210408092300839.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODE0Mzk5Ng==,size_16,color_FFFFFF,t_70)


  - 基本类型大体与Java中是一致的

  - Unit类似于Java中的void,没有任何实质性的意义,一般用于作为标识函数无返回值

    - Java

      ```
      public void name(args){
      	方法体
      	return
      }
      ```

    - Scala:没有return

      ```
      def name(args):unit= {
      	方法体
      	1+2
      	4
      }
      ```

      

  - Null类型是所有引用类型的子类

  - Nothing是所有类型的子类,一般用于作为函数返回值,用于明确的标识没有返回值

    ```
    def name(args):Nothing= {
    	方法体
    	Nothing
    }
    ```
## 基础语法:字符串使用及插值表达式
- **字符串定义**

  - 双引号定义

    ```scala
    scala> val s1 = "sky"
    s1: String = sky
    
    scala> println(s1)
    sky
    ```

  - 三引号定义:用于比较长的字符串定义,可读性比较强

    ```scala
    scala> val s2 = """
         | select xxxxx
         | from xxxx
         | where xxxx
         | group by xxx
         | having xxxx
         | order by xxxx
         | limit xxx
         | """
    s2: String =
    "
    select xxxxx
    from xxxx
    where xxxx
    group by xxx
    having xxxx
    order by xxxx
    limit xxx
    "
    ```

  

- **字符串截取substring**

  ```scala
  scala> s1.substring(2)
  res9: String = y
  
  scala> s1.substring(2,2)
  res10: String = ""
  
  scala> s1.substring(2)
  res11: String = y
  
  scala> s1.substring(2,3)
  res12: String = y
  
  scala> s1.substring(1,2)
  res13: String = k
  • 字符串替换replaceAll

    scala> val s3 = "I like"
    s3: String = I like
    
    scala> s3.replaceAll(" ","-")
    res14: String = I-like
    
  • 字符串拼接

    scala> println(s3+" "+s1)
    I like sky
    
    scala> s3 + " " + s1
    res17: String = I like sky
    
    scala> s3.+(s1)
    res18: String = I likesky
    
  • 插值表达式的使用

    • 功能:用于字符串拼接,可以在字符串中插入变量或者表达式

    • 语法

      s"${变量 | 表达式}"
      
    • 测试

      scala> s3 + " " + s1
      res19: String = I like sky
      
      scala> s"${s3} ${s1}"
      res20: String = I like sky
      
      scala> println(s"${s3.replaceAll(" ","-")}")
      I-like
      
      scala> println(s"${s3.replaceAll(" ","-")}-${s1}")
      I-like-sky
      

基础语法:块表达式与if判断

- **块表达式**
  • 功能:用{}包裹多行代码的表达式,scala中使用最后一行作为表达式的返回值,如果表达式只有一行代码,{}可以省略

  • 语法

    {
    	第一行代码
        第二行代码
    	……
    	表达式返回值
    }
    
  • 栗子

    scala> val a = 1
    a: Int = 1
    
    scala> val b = 2
    b: Int = 2
    
    scala> val c = {
         |    val d = a + b
         |    4
         | }
    c: Int = 4
    
    
    scala> val c = { a+b }
    c: Int = 3
    
    scala> val c = a+b
    c: Int = 3
    
  • if判断

    • 功能:用于实现代码中的判断分支逻辑

    • 语法

      if (表达式){
      	true的处理逻辑
      }else{
      	false的处理逻辑
      }
      
      if(表达式1){
          表达式1true
      }else if(表达式2){
          表达式2true
      }else if(表达式N){
          表达式N为true
      }else{
          都不满足
      }
      
      • 与Java基本一致
    • 栗子

      scala> if (c > 10){ false } else {true}
      res27: Boolean = true
      
      scala> if (c > 10) false else true
      res28: Boolean = true
      
      if(c > 10){
          println("c > 10")
      }else if(c > 5){
          println("c > 5")
      }else{
          println("c > 0")
      }
      

基础语法:for循环

    • Scala中for循环的语法

      • Java语法

        for(int i = 0;i < 10 ; i++){
        	循环逻辑
        }
        
      • Scala语法

        for(i <- 集合/数值范围){
        	循环逻辑
        }
        
    • Scala中构建数值范围表达式

      scala> 1 to 10
      res30: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
      
      scala> 1.to(10)
      res31: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
      
      scala> 1.until(10)
      res32: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)
      
    • for循环栗子

      scala> for(i <- 1 to 10) {println(i)}
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      
      scala> for(i <- 1 to 10) println(i)
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      
      scala> for(i <- 0 to 9) println(i)
      0
      1
      2
      3
      4
      5
      6
      7
      8
      9
      
  • 守卫条件

    • 功能:循环过程中实现数据过滤,增加循环条件,符合条件才会执行循环逻辑

      • 优点:不是每次循环都会执行循环体,只有符合条件才执行循环体

      • 语法

        for(x <- 集合/数值范围 守卫条件表达式){
        	循环逻辑
        }
      
      • 栗子
        scala> for(i <- 1 to 10) {if(i % 2 == 0) {println(i)}} 
        2
        4
        6
        8
        10
        
        scala> for(i <- 1 to 10 if i%2 == 0) {println(i)} 
        2
        4
        6
        8
        10
      
    • 推导式yield

      • 功能:在for循环后面加上表达式,针对循环的结果进行表达式的计算 ,计算结果组成一个新的集合

      • 关键字:yield

      • 语法

        for(i <- 集合/数值范围) yield {
        	循环表达式
          //计算表达式
        }
      
      - 栗子
      
        ```scala
      scala> for(i <- 1 to 10) yield i*2
        res40: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
        
        scala> for(i <- 1 to 10) yield {
             |    println(i)
             |    i*2
             | }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        res41: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
      

基础语法:while循环

- 语法
while(表达式){
	符合条件的循环逻辑
}

do {
   循环逻辑
} while( 表达式 );

栗子

scala> var a = 5
a: Int = 5

scala> while(a < 10){
   |     println(a)
   |     a = a + 1
   | }
5
6
7
8
9

scala> do{
   |     println(a)
   |     a = a + 1
   | }while(a < 10)
10

scala> do{
   |     println(a)
   |     a = a + 1
   | }while(a < 20)
11
12
13
14
15
16
17
18
19

基础语法:跳出循环Breaks

Java中break
和continue的作用

  • 通过关键字来实现

  • break:跳出循环

  • continue:终止当前循环,继续下一次循环

  • Scala中的continue与break

    • Scala中的continue与break基于函数式编程的思想通过函数来实现
    • 类:Breaks
    • 方法:break()
    • 语法:当遇到break方法时,跳出当前breakable的代码块
  • 栗子

    • 实现break
 import scala.util.control.Breaks._

breakable{
   for(i <- 1 to 10) {
       if(i >= 5) break()
       else println(i)
   }
}

实现continue

import scala.util.control.Breaks._

for(i <- 1 to 10){
   breakable{
      if(i == 5)  break()
      else println(i)
   }
}

你可能感兴趣的:(大数据,编程语言,scala)