scala学习复习笔记超详细（流程控制）

最新推荐文章于 2023-03-06 08:56:24 发布
最新推荐文章于 2023-03-06 08:56:24 发布
阅读量497 收藏 5
点赞数 2
分类专栏： scala学习 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46964261/article/details/123941677
版权

文章目录

Scala流程控制语句

  1. 在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。
  2. Scala语言中控制结构和Java语言中的控制结构基本相同，在不考虑特殊应用场景的情况下，代码书写方式以及理解方式都没有太大的区别。
    1. 顺序控制
    2. 分支控制
    3. 循环控制

1. 顺序控制

程序从上到下逐行地执行，中间没有任何判断和跳转。

//Scala中定义变量时采用合法的前向引用。如：
def main(args : Array[String]) : Unit = {
        var num1 = 12
        var num2 = num1 + 2
}
//错误形式：
def main(args : Array[String]) : Unit = {
        var num2 = num1 + 2
        var num1 = 12
}

在这里插入图片描述

2. 分支控制

让程序有选择的的执行,分支控制有三种（与Java相同）：

  1. 单分支
  2. 双分支
  3. 多分支
单分支和双分支
import scala.io.StdIn
/**
  * @Date 2021/3/23 16:33
  * @Version 10.21
  * @Author DuanChaojie
  */
object IfDemo01 {
  /**
    * 小技巧：如何乍看某个包下包含的内容？
    *  1、比如我们想看 scala.io 包有什么内容的话
    *  2、强光标放在io上即可，输入ctrl + b
    *  3、强光标放在StdIn上即可，输入ctrl + b看的是StdIn源码
    * @param args
    */
  def main(args: Array[String]): Unit = {

    println("请输入年龄：")
    val age = StdIn.readInt()
    if (age > 18) {
      println("您已经成年！")
    } else {
      println("小屁孩一个")
    }
  }
}

单分支和双分支课后题

/**
  * @Date 2021/3/23 16:40
  * @Version 10.21
  * @Author DuanChaojie
  */
object IfElseExercise01 {
  def main(args: Array[String]): Unit = {
    test1(11, 111)
    test2(111.0, 11.0)
    test3(12, 3)
    test4(2000)
  }


  /**
    * 编写程序，声明2个Int型变量并赋值。判断两数之和，如果大于等于50，打印“hello world!”
    *
    * @param n1
    * @param n2
    */
  def test1(n1: Int, n2: Int): Unit = {
    if (n1 + n2 >= 50) {
      println("hello world!")
    }
  }

  /**
    * 编写程序，声明2个Int型变量并赋值。判断两数之和，如果大于等于50，打印“hello world!”
    *
    * @param d1
    * @param d2
    */
  def test2(d1: Double, d2: Double): Unit = {
    if (d1 > 10.0 && d2 < 20.0) {
      println(d1 + d2)
    }
  }

  /**
    * 定义两个变量Int，判断二者的和，是否既能被3又能被5整除，打印提示信息
    *
    * @param n1
    * @param n2
    */
  def test3(n1: Int, n2: Int): Unit = {
    var sum = n1 + n2
    if (sum % 3 == 0 && sum % 5 == 0) {
      println(s"$n1+$n2 既能被3整除又能被5整除")
    }
  }

  /**
    * 判断一个年份是否是闰年，闰年的条件是符合下面二者之一：
    * (1)年份能被4整除，但不能被100整除；(2)能被400整除
    *
    * @param year
    */
  def test4(year: Int): Unit = {
    if (year < 0) {
      println("请输入合理的年份！")
    } else {
      if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        println(s"$year 年是闰年")
      }
    }
  }
}
多分支
import scala.io.StdIn

/**
  * @Date 2021/3/23 16:54
  * @Version 10.21
  * @Author DuanChaojie
  */
object IfDemo02 {
  def main(args: Array[String]): Unit = {
    /**
      * 岳小鹏参加scala考试，他和父亲岳不群达成承诺：
      * 如果：
      * 成绩为100分时，奖励一辆BMW；
      * 成绩为(80，99]时，奖励一台iphone7plus；
      * 当成绩为[60,80]时，奖励一个 iPad；
      * 其它时，什么奖励也没有。
      * 成绩是从控制台输入
      **/
    println("请输入成绩")
    val score = StdIn.readDouble()
    if (score == 100) {
      println("成绩为100分时，奖励一辆BMW")
      //写法1使用范围，写法2就是严格的判断
    } else if (score > 80 && score <= 99) {
      println("成绩为(80，99]时，奖励一台iphone7plus")
    } else if (score >= 60 && score <= 80) {
      println("奖励一个 iPad")
    } else {
      println("没有任何奖励")
    }
  }
}

多分支课后题：

/*
求ax2+bx+c=0方程的根。a,b,c分别为函数的参数，
如果：
	b2-4ac>0，则有两个解；
	b2-4ac=0，则有一个解；
	b2-4ac<0，则无解； 
	[a=3 b=100 c=6]
提示1：
	x1=(-b+sqrt(b2-4ac))/2a
	X2=(-b-sqrt(b2-4ac))/2a
提示2：
	sqrt(num)  在 scala 包中(默认引入的) 的math 的包对象有很多方法直接可用.
*/

/**
  * @Date 2021/3/23 17:02
  * @Version 10.21
  * @Author DuanChaojie
  */
object IfElseExercise02 {
  def main(args: Array[String]): Unit = {

    /**
      思路的分析
      1. 定义三个变量a,b,c
      2. 使用多分支完成
      3. 因为 b2-4ac会多次使用，因此我们可以先计算，并保持到变量中
      4. 判断，写逻辑
    */

    val a = 3
    val b = 100
    val c = 6
    val m = b * b - 4 * a * c
    var x1 = 0.0
    var x2 = 0.0

    if (m > 0) {
      x1 = (-b + Math.sqrt(m)) / 2 * a
      x2 = (-b - Math.sqrt(m)) / 2 * a
      println("有两个解: \nx1=" + x1.formatted("%.2f") + "\nx2=" + x2.formatted("%.2f"))
    } else if (m == 0) {
      x1 = (-b + Math.sqrt(m)) / 2 * a
      println("有一个解 x1=" + x1)
    } else {
      println("无解..")
    }
  }
}
分支控制if-else 注意事项
  1. 如果大括号{}内的逻辑代码只有一行，大括号可以省略, 这点和java 的规定一样。
  2. Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容。
  3. Scala中是没有三元运算符，因为 Scala 的if-else 是有返回值的，因此，本身这个语言也不需要三元运算符了，并且可以写在同一行，类似 三元运算
/**
  * @Date 2021/3/23 17:11
  * @Version 10.21
  * @Author DuanChaojie
  */
object IfElseExercise03 {
  def main(args: Array[String]): Unit = {
    var sumVal = 9
    val result = if (sumVal > 20) {
      "结果大于20"
    }
    //返回的是() 即 Unit
    println("res=" + result)
  }
}
嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。嵌套分支不要超过3层

案例一：

/**
  * @Date 2021/3/23 17:13
  * @Version 10.21
  * @Author DuanChaojie
  */
object IfElseExercise04 {
  def main(args: Array[String]): Unit = {
    /**
      * 参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰。
      * 并且根据性别提示进入男子组或女子组。
      * 【可以让学员先练习下5min】, 输入成绩和性别，进行判断。
      */
    println("请输入运动员的成绩：")
    val speed = StdIn.readDouble()
    if (speed <= 8) {
      println("请输入性别")
      val gender = StdIn.readChar()
      if (gender == '男') {
        println("进入男子组")
      } else {
        println("进入女子组")
      }
    } else {
      println("你被淘汰...")
    }
  }
}

案例二：

/**
  * @Date 2021/3/23 17:16
  * @Version 10.21
  * @Author DuanChaojie
  */
object IfElseExercise05 {
  def main(args: Array[String]): Unit = {

    /**
      应用案例2
      出票系统：根据淡旺季的月份和年龄，打印票价 [考虑学生先做5min]
      4_10 旺季：
        成人（18-60）：60
        儿童（<18）:半价
        老人（>60）:1/3
      淡季：
        成人：40
        其他：20
      思路分析
        1. 定义至少三个变量 month , age, ticket
        2. 逻辑上有月份和年龄的判断因此，会使用嵌套分支
        3. 根据对应的业务逻辑完成代码
     */
    println("输入月份")
    val month = StdIn.readInt()
    println("输入年龄")
    val age = StdIn.readInt()
    val tikcet = 60

    if (month >= 4 && month <= 10) {
      if (age >= 18 && age <= 60) {
        println("你的票价是" + tikcet)
      } else if (age < 18) {
        println("你的票价是" + tikcet / 2)
      } else {
        println("你的票价是" + tikcet / 3)
      }
    } else {
      if (age >= 18 && age <= 60) {
        println("你的票价是" + 40)
      } else {
        println("你的票价是" + 20)
      }
    }
  }
}
switch分支结构TODO

在Scala中没有switch，而是使用模式匹配来处理。

模式匹配涉及到的知识点较为综合，因此我们放在后面讲解。

3. 循环控制

☆for循环控制☆

Scala 也为for 循环这一常见的控制结构提供了非常多的特性，这些for 循环的特性被称为for 推导式（for comprehension）或for 表达式（for expression）

范围数据循环方式1

/**
  * @Date 2021/3/23 17:34
  * @Version 10.21
  * @Author DuanChaojie
  */
object ForDemo01 {
  def main(args: Array[String]): Unit = {
    //输出10句 "hello,尚硅谷!"
    val start = 1
    val end = 10
    //说明
    //1. start 从哪个数开始循环
    //2. to 是关键字
    //3. end 循环结束的值
    //4. start to end 表示前后闭合
    for (i <- start to end) {

      println("你好，尚硅谷" + i)
    }

    //说明for 这种推导时，也可以直接对集合进行遍历
    var list = List("hello", 10, 30, "tom")
    for (item <- list) {
      println("item=" + item)
    }

  }
}

范围数据循环方式2

/**
  * @Date 2021/3/23 17:38
  * @Version 10.21
  * @Author DuanChaojie
  */
object ForUntilDemo02 {
  def main(args: Array[String]): Unit = {
    //输出10句 "hello,尚硅谷!"
    val start = 1
    val end = 11
    // 循环的范围是 start --- （end - 1）
    for (i <- start until end) {
      println("你好，尚硅谷" + i)
    }
  }
}

循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue

object ForGuard {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 3 if i != 2) {
      println("i = " + i)
    }
  }
}

引入变量

object ForVar {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 3; j = 4 - i) {
      println("j = " + j)
    }
  }
}

嵌套循环

object ForMulti {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 3; j <- 1 to 3) {
      println("i = " + i + "\tj = " + j)
    }

    println("----------------------------")
    // 上面的写法也可以写成：
    for (i <- 1 to 3) {
      for (j <- 1 to 3) {
        println("i = " + i + "\tj = " + j)
      }
    }
  }
}

循环返回值：

  • 将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字
  • val res = for(i <- 1 to 10) yield i
object ForYield {
  def main(args: Array[String]): Unit = {
    /**
      * 说明 val res = for(i <- 1 to 10) yield i 含义
      *     1. 对1 to 10 进行遍历
      *     2. yield i 将每次循环得到i 放入到集合Vector中，并返回给res
      *     3. i 这里是一个代码块，这就意味我们可以对i进行处理
      *     4. 下面的这个方式，就体现出scala一个重要的语法特点，就是将一个集合中个各个数据
      * 进行处理，并返回给新的集合
      */
    val res = for(i <- 1 to 10) yield {
                if(i % 2 == 0){
                  i
                }else{
                  "不是偶数"
                }
              }
    // Vector(不是偶数, 2, 不是偶数, 4, 不是偶数, 6, 不是偶数, 8, 不是偶数, 10)
    println(res)
  }
}

使用花括号{}代替小括号()

//基本案例
for(i <- 1 to 3; j =  i * 2) {
  println(" i= " + i + " j= " + j)
}

//可以写成
for{
      i <- 1 to 3
      j = i * 2} {
      println(" i= " + i + " j= " + j)
 }

对基本案例说明

  1. {}和()对于for表达式来说都可以
  2. for 推导式有一个不成文的约定：当for 推导式仅包含单一表达式时使用圆括号，当其包含多个表达式时使用大括号
  3. 当使用{} 来换行写表达式时，分号就不用写了

注意事项和细节说明

  1. Scala 的for循环形式和java是较大差异，这点请同学们注意，但是基本的原理还是一样的。
  2. 思考题：如何使用循环守卫控制步长？
/**
  * @Date 2021/3/23 20:42
  * @Version 10.21
  * @Author DuanChaojie
  */
object ForStep {
  def main(args: Array[String]): Unit = {
    
    for (i <- 1 to 10) {
      println("i=" + i)
    }
    
    //步长控制为2
    println("-------------")

    /**
      * Range(1,10,2)的对应的构建方法是
      * def apply(start: Int, end: Int, step: Int): Range = new Range(start, end, step)
      */
    for (i <- Range(1, 10, 2)) {
      println("i=" + i)
    }

    //控制步长的第二种方式-for循环守卫
    println("**************************")
    for (i <- 1 to 10 if i % 2 == 1) {
      println("i=" + i)
    }
  }
}

For循环练习题


/**
  * @Date 2021/3/23 19:08
  * @Version 10.21
  * @Author DuanChaojie
  */
object ForExercise01 {
  def main(args: Array[String]): Unit = {
    /**
    for循环练习题：
      打印1~100之间所有是9的倍数的整数的个数及总和.
      完成下面的表达式输出
    */
    val start = 1
    val end = 100
    var count = 0
    var sum = 0

    for (i <- start to end) {
      if (i % 9 == 0) {
        count += 1
        sum += i
      }
    }
    printf("count=%d, sum=%d\n", count, sum)

    //输出加法的循环表达式
    val num = 6
    for (i <- 0 to num) {
      printf("%d + %d = %d\n", i, (num - i), num)
    }

    var list = List(1,2)
  }
}
while循环控制
object WhileDemo01 {
  def main(args: Array[String]): Unit = {
    var i = 0
    while(i < 10){
      println("Hello 尚硅谷" + i)
      // 循环变量迭代
      i += 1
    }
  }
}

注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. while循环是先判断再执行语句
  3. 与If语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()
  4. 因为while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。
do…while循环控制
object DoWhileDemo01 {
  def main(args: Array[String]): Unit = {
    var i = 0
    do {
      println(i + "Hello Scala")
      i += 1
    } while (i < 10)
  }
}

注意事项和细节说明：

  1. 循环条件是返回一个布尔值的表达式
  2. do…while循环是先执行，再判断
  3. 和while 一样，因为do…while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在do…while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环
多重循环控制
  1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】
  2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
  3. 设外层循环次数为m次，内层为n次， 则内层循环体实际上需要执行m*n=mn次。

案例一：

object Exercise01 {
  /**
    *应用实例：
    *1.统计三个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
    * 分析思路
    * (1) classNum 表示 班级个数 , stuNum 表示学生个数
    * (2) classScore 表示各个班级总分 totalScore 表示所有班级总分
    * (3) score 表示各个学生成绩
    * (4) 使用循环的方式输入成绩
    *2.统计三个班及格人数，每个班有5名同学。
    *3.打印出九九乘法表
    */

  def main(args: Array[String]): Unit = {
    val classNum = 3
    val stuNum = 5
    var score = 0.0 //分数
    var classScore = 0.0 //班级的总分
    var totalScore = 0.0 //所有班级总分

    for (i <- 1 to classNum) {
      //先将 classScore 清0
      classScore = 0.0
      for (j <- 1 to stuNum) {
        printf("请输入第%d班级的第%d个学生的成绩\n", i, j)
        score = StdIn.readDouble()
        classScore += score
      }
      //累计 totalScore
      totalScore += classScore
      printf("第%d班级的平均分为%.2f\n", i, classScore / stuNum)
    }
    printf("所有班级的平均分为%.2f", totalScore / (stuNum * classNum))
  }
}

案例二：

object Exercise02 {
  def main(args: Array[String]): Unit = {
    /**
      * 2.统计三个班及格人数，每个班有5名同学。
      */
    val classNum = 3
    val stuNum = 5
    var score = 0.0 //分数
    var classScore = 0.0 //班级的总分
    var totalScore = 0.0 //所有班级总分
    var passNum = 0 //统计及格人数
    for (i <- 1 to classNum) {
      //先将 classScore 清0
      classScore = 0.0
      for (j <- 1 to stuNum) {
        printf("请输入第%d班级的第%d个学生的成绩\n", i, j)
        score = StdIn.readDouble()
        if (score >= 60) {
          passNum += 1
        }
        classScore += score
      }
      //累计 totalScore
      totalScore += classScore
      printf("第%d班级的平均分为%.2f\n", i, classScore / stuNum)
    }
    printf("所有班级的平均分为%.2f", totalScore / (stuNum * classNum))
    printf("所有班级的及格人数为%d", passNum)
  }
}

案例三：

/**
  * @Date 2021/3/23 19:44
  * @Version 10.21
  * @Author DuanChaojie
  */
object Exercice03 {
  def main(args: Array[String]): Unit = {
    //3.打印出九九乘法表
    var num = 9
    for (i <- 1 to num) {
      for (j <- 1 to i) {
        print(s"$j * $i = ${i * j} \t")
      }
      println()
    }
  }
}
while循环的中断

Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数化编程，推荐使用函数式的风格解决break和contine的功能，而不是一个关键字。

package com.atguigu.chapter04

import util.control.Breaks._

/**
  * @Date 2021/3/23 19:48
  * @Version 10.21
  * @Author DuanChaojie
  */
object WhileBreak {
  def main(args: Array[String]): Unit = {
    //breakable()函数
    //说明
    //1. breakable 是一个高阶函数：可以接收函数的函数就是高阶函数（后面详解）

    //2. def breakable(op: => Unit) {
    //    try {
    //      op
    //    } catch {
    //      case ex: BreakControl =>
    //        if (ex ne breakException) throw ex
    //    }
    //  }
    // (1) op: => Unit 表示接收的参数是一个没有输入，也没有返回值的函数
    // (2) 即可以简单理解可以接收一段代码块
    // 3. breakable 对break()抛出的异常做了处理,代码就继续执行
    // 4. 当我们传入的是代码块，scala程序员会将() 改成{}
      
    var n = 0
    breakable {
      while (n <= 20) {
        n += 1
        println("n = " + n)
        if (n == 18) {
          break()
        }
      }
    }
  }
}

如何实现continue的效果?Scala内置控制结构特地也去掉了continue，是为了更好的适应函数化编程，可以

使用if – else 或是循环守卫实现continue的效果。

object ContinueDemo {
  def main(args: Array[String]): Unit = {
    /**
      * 1. 1 to 10
      * 2. 循环守卫 if (i != 2 && i != 3) 这个条件为ture
      *    才执行循环体,即当i ==2 或者 i == 3时，就跳过
      */
    for (i <- 1 to 10 if (i != 2 && i != 3)) {
      println("i=" + i)
    }

    //也可以写成如下的形式
    for (i <- 1 to 10) {
      if (i != 2 && i != 3) {
        println("i=" + i)
      }
    }
  }
}

☆

爱敲代码的小黑
关注
专栏目录
小菜的Scala学习笔记，主要部分更新完成
5akura's Blog
01-13 1111
文章目录Scala简介快速入门之HelloWorldIDEA开发Scala工程创建Scala开发规范Scala基础语言学习Chap01.内容输出与文档查看Chap02.变量2.1 声明/定义2.2 val与var2.3 数据类型2.3.1Char类型使用注意2.3.2、Unit、Null和Nothing2.3.3、类型转换Chap03.运算符Chap04.流程控制Scala函数式编程学习Chap05.函数编程入门5.1、函数function 和 方法method5.2、函数的定义5.3、函数的使用注意5.4
【学习笔记】尚硅谷大数据项目之Flink实时数仓---数据采集
prague6695的博客
07-14 4255
【学习笔记】尚硅谷大数据项目之Flink实时数仓---数据采集
Scala学习笔记(全)
01-08
该文档详细的讲述了Scala的基础操作方法和高级使用方法
Scala核心编程 第四章—Scala程序流程控制概述
星星的博客
09-18 1万+
一、程序流程控制介绍 在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。 Scala语言中控制结构和Java语言中的控制结构基本相同，在不考虑特殊应用场景的情况下，代码书写方式以及理解方式都没有太大的区别 1.顺序控制 （1）顺序控制介绍 程序从上到下逐行地执行，中间没有任何判断和跳转。 （2）顺序...
Scala学习笔记
weixin_44342332的博客
05-09 611
一、概述 Scala语言特点 Scala是一门以Java虚拟机(JVM)为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言（静态语言需要提前编译的如: Java、 c、 c++等, 动态语言如: js）。 1）Scala是一门多范式的编程语言，Scala支持面向对象和函数式编程。(多范式，就是多种编程方法的意思。有面向过程、面向对象、泛型、函数式四种程序设计方法。) 2）Scala源代码(.scala)会被编译成Java字节码(.class) ，然后运行于JVM之上，并可以调用现有的J
Scala 的学习笔记
weixin_45866849的博客
11-15 4269
Scala 是 Scalable Language 的简写，是一门多范式的编程语言。Scala 是一种纯面向对象的语言，每个值都是对象。对象的数据类型以及行为由类和特质描述。类抽象机制的扩展有两种途径：一种途径是子类继承，另一种途径是灵活的混入机制。这两种途径能避免多重继承的种种问题。Scala 也是一种函数式语言，其函数也能当成值来使用。Scala 提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。
Scala 学习笔记
weixin_34112030的博客
12-05 158
2019独角兽企业重金招聘Python工程师标准>>> ...
Spark学习笔记——龟速更新。。
5akura's Blog
01-13 2300
文章目录Spark学习笔记第一章、基本认识与快速上手1.1、认识Spark1.2、对比Hadoop1.3、Spark组成基本介绍1.4、快速上手之WorldCount实现1.4.1、方式一（Scala类似集合操作实现）1.4.2、方式二(MR思维实现)1.4.3、方式三(Spark实现)第二章、环境搭建2.1、Local模式2.1.1、SparkShell命令行执行2.1.2、spark-sublime提交任务2.1.3、提交任务的参数说明2.2、Standalone模式2.2.1、配置改动与启动2.2.2
超全大数据面试宝典-大数据面试有这套就够了.pdf
10-29
找工作流程是大数据面试宝典的开篇，包括学习技能、编写简历、投递简历、预约面试时间、面试、等待回复、拿到offer、入职以及准备必备资料和签订合同九个步骤。这个流程帮助求职者了解从开始求职到成功入职整个过程...
大数据、云计算该如何学习？
yyyyyyyyyooi的博客
06-06 9333
大数据之Linux+大数据开发篇 【大数据开发学习资料领取方式】：加入大数据技术学习交流群458345782，点击加入群聊，私信管理员即可免费领取 阶段一、大数据、云计算 - Hadoop大数据开发技术 课程一、大数据运维之Linux基础 本部分是基础课程，帮大家进入大数据领域打好Linux基础，以便更好地学习Hadoop，hbase,NoSQL，Spar...
scala核心编程总结
11-14
内容详尽，结构清楚，简单易学！Scala编程语言抓住了很多开发者的眼球。如果你粗略浏览Scala的网站，你会觉得Scala是一种纯粹的面向对象编程语言，而又无缝地结合了命令式编程和函数式编程风格。Christopher Diggins认为： 不太久之前编程语言还可以毫无疑意地归类成“命令式”或者“函数式”或者“面向对象”。Scala代表了一个新的语言品种，它抹平了这些人为划分的界限。
scala学习笔记整理
05-09
学习scala笔记，学习scala笔记，学习scala笔记，学习scala笔记，学习scala笔记，
Scala核心编程 第一章—Scala语言概述
热门推荐
星星的博客
09-17 1万+
一、Scala语言解释 1.什么是Scala语言 Spark—新一代内存级大数据计算框架，是大数据的重要内容。 Spark就是使用Scala编写的。因此为了更好的学习Spark, 需要掌握Scala这门语言。 Scala 是 Scalable Language 的简写，是一门多范式(范式/编程方式[面向对象/函数式编程])的编程语言 联邦理工学院洛桑（EPFL）的Martin Odersk...
大数据处理学习笔记1.5 掌握Scala内建控制结构
最新发布
qq_61324603的博客
03-06 811
Scala中继承了Java的异常机制，提供了程序中产生意外情况时处理的机制，抛出异常的过程和Java中基本一致，通过throw，一旦抛出可以当场捕获处理或接着向上抛，捕获异常是通过来实现的。
SCALA笔记
编程笔记
10-30 248
一.环境搭建 二.数据类型 三.基本语法 四.函数式编程
scala笔记
飞翔的宇宙
09-10 295
1.val和var的区别: val : 值 类似 final 不能再次赋值 val 值名称:类型 = xxx var : 变量 可以再次赋值 scala的基本数据类型: Byte/Char Short/Int/Long/Float/Double Boolean 类型转换: val a:Int = 10 ...
Scala学习笔记：安装与基础语法
Scala自学笔记涵盖了从安装到基本编程概念的多个方面，对于初学者来说是一份很好的学习材料，同时也提示了Scala语言的灵活性和强大功能。通过深入学习，开发者可以充分利用Scala的优势，如函数式编程特性、强大的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱敲代码的小黑

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值