scala函数式编程系列（二）--- scala基本语法

 

版权声明：本文为博主原创文章，未经博主允许不得转载!!

欢迎访问:https://blog.csdn.net/qq_21439395/article/details/80962497

交流QQ: 824203453

 

1. Scala基础

1.1.  函数式编程体验Spark-Shell之WordCount

Q1: 对上述文件内容使用Spark进行单词个数统计?

Q2: 对上述输出结果进行降序 ?

 

1.2.     常用类型

Scala和java一样，

有7种数值类型：Byte、Char、Short、Int、Long、Float和Double（没有包装类型）

2种非数值类型：Boolean      和   Unit 

注意：Unit表示无值，相当于java中的void。用作不返回任何结果的类型。Unit对象只有一个实例值，写成()。（小括号）

还有String类型

Nothing： 是所有类型的子类型 表示出错了。

Null： 是所有引用类型的子类型，表示空值。

 

1.3.     声明变量

定义变量使用var 或者 val关键字

语法:    var|val变量名称 (: 数据类型) = 变量值

变量在定义的时候必须进行初始化赋值。

使用val定义的变量是不可变的，相当于java中用final修饰的变量

使用var定义的变量是可变的，在Scala中推荐使用val

Scala编译器会自动推断变量的类型，必要的时候可以指定类型

object VariableTest {
  def main(args: Array[String]) {
    // 使用val定义的变量值是不可变的，相当于java里用final修饰的变量
    val name = “nvshen”
    // 使用var定义的变量是可变的，在Scala中鼓励使用val
    var age = 18
    //Scala编译器会自动推断变量的类型，必要的时候可以指定类型
//变量名在前，类型在后
    val str: String = "world"
 
Val str:String =100
// 这种会报错，类型不匹配
  }
}

 

lazy val变量名

lazy关键字修饰的变量，是一个惰性变量，实现延迟加载（懒加载），在使用的时候才会加载。

lazy关键字不能修饰 var类型的变量

 

可以使用通配符（占位符）_来指定变量

var  name:String = _

需要注意：

1， 使用占位符的时候，必须指定变量的类型

2， 变量只能使用var来修饰。

3， 使用占位符定义变量的时候，不能在main方法中定义。

 

可以同时声明多个变量，可以使用通配符声明变量：

java中的通配符是*,scala中的通配符是_

定义一个变量，必须赋予初始值，如果没有初始值，可以使用_占位符代替，但是变量必须指定类型。而且占位符变量不能定义在main方法内部。

 

// 声明多个变量
var age，fv = 18
var str: String = _

1.4.     条件表达式

 

 

表达式都是有返回值的。

条件表达式的值可以赋值给一个变量

支持混合类型的表达式，返回值是可选址

Scala的的条件表达式比较简洁，例如：

object ConditionTest {
  def main(args: Array[String]) {
    val x = 1
    //判断x的值，将结果赋给y
    val y = if (x > 0) 1 else -1
    //打印y的值
    println(y)
    
    //支持混合类型表达式
    val z = if (x > 1) 1 else "error"
    //打印z的值
    println(z)
    混合类型会返回父类类型。
    //如果缺失else，相当于if (x > 2) 1 else ()
    val m = if (x > 2) 1
    println(m)
  
    //在scala中每个表达式都有返回值，scala中有个Unit类，写做(),相当于Java中的void
    val n = if (x > 2) 1 else ()
    println(n)
  
    //if和else if
    val k = if (x < 0) 0
    else if (x >= 1) 1 else -1
    println(k)
  }
}

 

每一个条件语句，都有返回值，默认返回值是最后一行的内容，如果没有内容或者内容为空，那么返回值就是Unit,或者说是()。

 

多条件分支中，缺少了某一个分支，默认会返回Unit。

我们的条件表达式，可以使用{}，如果业务逻辑只有一行， 可以省略{},完全放在一行。

if(x>2)3 else 5

条件表达式里面，不能使用return这一关键字，默认返回最后一行的内容。

 

1.5.     块表达式

 

{} 称为块表达式，块表达式中可以包含一系列的表达式，最后一个表达式的值就是块的值。

object BlockExpressionTest {
  def main(args: Array[String]) {
    val x = 0
    //在scala中{}中可包含一系列表达式，块中最后一个表达式的值就是块的值
    //下面就是一个块表达式
    val result = {
      if (x < 0){
        -1
      } else if(x >= 1) {
        1
      } else {
        "error"
      }
    }
    // result的值就是块表达式的结果
    println(result)
  }
}

 

1.6.     for循环

在scala中有for循环和while循环，用for循环比较多

for循环语法结构：for (i <- 表达式/数组/集合)

传统for循环已经不再适用：for(i=1;i<10;i++)

 object ForTest {
  def main(args: Array[String]) {
    //for(i <- 数组)
    val arr = Array("a", "b", "c")
// 遍历打印数组中的每个元素
    for (i <- arr) // 类似Java中的增强for
      println(i)    
 
  // 通过角标获取数组中的元素
 
//for(i <- 表达式),表达式1 to 10返回一个Range（区间）
//每次循环将区间中的一个值赋给i
    for (i <- 1 to 6)
      println(i)
println(arr(i))
      for(i <- 1until 6) { // 0 until 6 => 会生成一个范围集合Range(0,1,2,3,4,5)
        println(array(i))
    }
  
    // to 和 until的区别就是to包含为前后都为闭区间, until为前闭后开区间
  
    // 打印数组中的偶数元素
// 在for循环中，通过添加守卫来实现输出满足特定条件的数据
    for(e <- arr  if e % 2 == 0) { // for表达式中可以增加守卫
        println(e)
    }
  
  
    //高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号
    for(i <- 1 to 3; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")
    println()
  
    //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i * 10
    println(v)
  }
}

 

 

 

两个生成器： to   until

1 to 10   生成  Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)    左闭右闭区间

1 until 10 生成  Range(1, 2, 3, 4, 5, 6, 7, 8, 9)       左闭右开区间

 

for循环总结：

循环的标识： <-

增强for循环: for(I <- arr)

普通for循环： to  until

带守卫的for循环 （if 条件）

嵌套for循环 （for(i<- 1 to 3 ;j <- 1 to 3 if(I != j )))）

yield推导式  返回一个满足条件的数组

 

 

 

1.7.  while循环

Scala的 while 循环和其它语言如 Java 功能一样，它含有一个条件，和一个循环体，只要条件满足，就一直执行循环体的代码。

语法结构：while(condition){ 循环体内容 }

var i = 0
while(i<5) {
  println(i)
  i += 1  // i = i + 1
}

Scala也有 do-while循环，它和 while 循环类似，只是检查条件是否满足在循环体执行之后检查。

i = 0
// while 直接判断
while(i>0 && i<=5) {
  println(i)
  i += 1
}
i = 0
// do while 先执行一次循环，再进行判断
do{
  println(i)
  i += 1
}while(i>0 && i<=5)

 

循环也有返回值，只不过都是Unit

 

val res = while(i>0 && i<=5) {
  println(i)
  i += 1
}
println(s"res = $res")

 

 

 

1.8.  函数式编程再体验：

map：对集合或者数组中的每一个元素进行操作，该方法接收一个函数，具体的业务逻辑是自己定义的。

filter:过滤，过滤出满足条件的元素。

 

版权声明：本文为博主原创文章，未经博主允许不得转载!!

欢迎访问:https://blog.csdn.net/qq_21439395/article/details/80962497

交流QQ: 824203453