Scala基础入门

已于 2022-09-26 22:11:33 修改
阅读量514 收藏
点赞数
文章标签： scala spark 大数据
于 2022-09-26 22:07:07 首次发布
原文链接：https://blog.csdn.net/qq_39346903/article/details/113562823?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166419619316800182735481%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=166419619316800182735481&biz_id=0&utm_me
版权

版权声明：本文为转载文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/qq_39346903/article/details/113562823

文章目录

第1章 Scala入门

1.1 概述

1.1.1 为什么学习Scala

1）Spark：新一代内存级大数据计算框架，是大数据的重要内容

2）Spark就是使用Scala编写的，因此为了更好的学习Spark，需要掌握Scala这门语言

3）Spark的兴起，带动Scala语言的发展！

1.1.2 Scala发展历史

在这里插入图片描述

1.1.3 Scala和Java关系

一般来说，学Scala的人，都会Java，而Scala是基于Java的，因此我们需要将Scala和Java以及JVM之间的关系搞清楚，否则学习Scala你会蒙圈。
在这里插入图片描述

1.1.4 Scala语言特点

在这里插入图片描述

1.2 Scala环境搭建

1）安装步骤

（1）首先确保JDK1.8安装成功

（2）下载对应的Scala安装文件scala-2.12.11.zip

（3）解压scala-2.12.11.zip，我这里解压到C:\develop

（4）配置Scala的环境变量

​ image-20210122104053838

image-20210122104123935

注意1：解压路径不能有任何中文路径，最好不要有空格。

注意2：环境变量要大写SCALA_HOME

2）测试

需求：计算两数a和b的和。

步骤

（1）在键盘上同时按win+r键，并在运行窗口输入cmd命令

image-20210122104801204

（2）输入Scala并按回车键，启动Scala环境。然后定义两个变量，并计算求和。

image-20210122104745269

1.3 Scala插件安装

默认情况下IDEA不支持Scala的开发，需要安装Scala插件。

1）插件离线安装步骤

（1）建议将该插件scala-intellij-bin-2019.3.23.zip文件，放到Scala的安装目录C:\develop\scala-2.12.11下，方便管理。

（2）打开IDEA，在左上角找到File->在下拉菜单中点击Setting… ->点击Plugins->点击右下角Install plugin from disk…，找到插件存储路径C:\develop\scala-2.12.11\scala-intellij-bin-2019.3.23.zip，最后点击ok。

image-20210122105115872

2）插件在线安装**（可选）**

（1）在搜索插件框里面输入Scala->点击Install->点击ok->点击apply。

（2）重启IDEA，再次来到Scala插件页面，已经变成Uninstall。

1.4 HelloWorld案例

1.4.1 创建IDEA项目工程

1）打开IDEA->点击左侧的Flie->选择New->选择Project…

2）创建一个Maven工程，并点击next

image-20210122105247532

3）GroupId输入com.atguigu->ArtifactId输入scala0421->点击next->点击Finish

注意：工程存储路径一定不要有中文和空格。

4）指定项目工作目录空间

5）默认下，Maven不支持Scala的开发，需要引入Scala框架。

在scala0421项目上，点击右键-> Add Framework Support… ->选择Scala->点击OK

image-20210122105427584

注意：如果是第一次引入框架，Use libary看不到，需要选择你的Scala安装目录，然后工具就会自动识别，就会显示user libary。

6）创建项目的源文件目录

右键点击main目录->New->点击Diretory -> 写个名字（比如scala）。

右键点击scala目录->Mark Directory as->选择Sources root，观察文件夹颜色发生变化。

image-20210122110511888

7）在scala包下，创建包com.atguigu.chapter01包名和Hello类名，

​ 右键点击scala目录->New->Package->输入com.atguigu.chapter01->点击OK。

右键点击com.atguigu.chapter01->New->Scala Class->Kind项选择Object->Name项输入Hello。

image-20210122111055005

8）编写输出Hello Scala案例

在类中中输入main，然后回车可以快速生成main方法；

在main方法中输入println(“hello scala”)

package com.atguigu.chapter1

object Hello {
def main(args: Array[String]): Unit = {
println(“hello scala”)
System.out.println(“hello scala”)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

运行后，观察控制台打印输出：

hello scala

hello scala

说明：Java中部分代码也是可以在Scala中运行。

1.4.2 class和object说明

对第一个程序进行说明

//main 方法名
//小括号表示参数列表
//  参数声明方式: java  ->  类型  参数名
//                      scala ->  参数名 : 类型
//  public修饰符:  scala中没有public关键字,如果不声明访问权限,那么就是公共的
//  static修饰符:  scala中没有静态方法,所以没有static关键字
//  void关键字:  表示返回值,但是不遵守面向对象语法,所以scala中没有,但是又Unit类型,表示没有返回值
//  scala中: 方法名(参数列表):返回值类型
//  scala中方法必须采用关键字def声明
//  scala中方法实现赋值给方法声明,所以中间需要等号连接

// scala是一个完全面向对象的语言,所以没有静态语法,为了能调用静态语法(模仿静态语法)
// 采用伴生对象单例的方式调用方法

/*

  • Scala 完全面向对象,故scala去掉了Java中非面向对象的元素,如static关键字,void类型
    1. static
  • scala无static关键字,由object实现类似静态方法的功能(类名.方法名)

  • class关键字和Java中的class关键字作用相同,用来定义一个类
    1. void
  • 对于无返回值的函数,scala定义其返回值类型为Unit类型
  • */
    package com.atguigu.chapter1

object Hello {
def main(args: Array[String]): Unit = {
println(“hello scala”)
System.out.println(“hello scala”)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

1.4.3 Scala程序反编译

1）在项目的target目录Hello文件上点击右键->Show in Explorer->看到object底层生成Hello$.class和Hello.class两个文件

2）采用Java反编译工具jd-gui.exe反编译代码，将Hello.class拖到jd-gui.exe页面

image-20210122115115776

image-20210122120028267

1.5 关联Scala源码

在使用Scala过程中，为了搞清楚Scala底层的机制，需要查看源码，下面看看如何关联和查看Scala的源码包。

1）查看源码

例如查看Array源码。按住ctrl键->点击Array->右上角出现Choose Sources…

​ image-20210122120155079 image-20210122122100583

​

2）关联源码

（1）将我们的源码包scala-sources-2.12.11.tar.gz拷贝到C:\develop\scala-2.12.11\lib文件夹下，并解压为scala-sources-2.12.11文件夹

（2）点击Choose Sources…->选择C:\develop\scala-2.12.11\lib\scala-2.12.11-source，这个文件夹，就可以看到源码了

image-20210122122216197

1.6 官方编程指南

1）在线查看：https://www.scala-lang.org/

2）离线查看：解压scala-docs-2.11.8.zip，可以获得Scala的API操作。

image-20210122122436837

第2章 变量和数据类型

2.1 注释

Scala注释使用和Java完全一样。

注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

1）基本语法

（1）单行注释：//

（2）多行注释：/* */

（3）文档注释：/**
*
*/

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

2）案例实操

package com.atguigu.chapter1

object Test1 {
def main(args: Array[String]): Unit = {
//单行注释
println(“单行”)
//多行
/*
println(“多行”)
/
//文档注释
/*

  • println(“文档注释”)
    */
    }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

3） 代码规范

（1）使用一次tab操作，实现缩进，默认整体向右边移动，用shift+tab整体向左移

（2）或者使用ctrl + alt + L来进行格式化

（3）运算符两边习惯性各加一个空格。比如：2 + 4 * 5

（4）一行最长不超过80个字符，超过的请使用换行展示，尽量保持格式优雅

2.2 变量和常量（重点）

常量：在程序执行的过程中，其值不会被改变的变量

0）回顾：Java变量和常量语法

​ 变量类型 变量名称 = 初始值 int a = 10

​ final常量类型 常量名称 = 初始值 final int b = 20

1）基本语法

​ var 变量名 [: 变量类型] = 初始值 var i:Int = 10

​ val 常量名 [: 常量类型] = 初始值 val j:Int = 20

​ 注意：能用常量的地方不用变量

2）案例实操

（1）声明变量时，类型可以省略，编译器自动推导，即类型推导

（2）类型确定后，就不能修改，说明Scala是强数据类型语言。

（3）变量声明时，必须要有初始值

（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。

package com.atguigu.chapter2

object TestValueTransfer {
def main(args: Array[String]): Unit = {
var n = 1 + 2.2222
println(n) //Double

var n2: Double = 2.2222
// var n3: Int = n2 //报错

var n4 : Byte = 44
// var c1 : Char = n4 //报错
var n5 : Int = n4

var n6 : Byte = 66
var c2 : Char = 22
// var n : Short = n6 + c2 //报错，结果是Int类型
// var n7 : Short = 10 + 20 //报错，byte，short，char他们三者可以计算，在计算时首先转换为int类型。

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

（5）var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）

package com.atguigu.chapter1

object TestVar {
def main(args: Array[String]): Unit = {
var age = 22
age = 29
// age = “hh” //报错

var n1 = 1 //可变
n1 = 2

val n2 = 2 //不可变
//n2 = 3

//p1 是var修饰的，p1的属性可以变，p1本身也可以变
var p1 = new Person()
p1.name = “varp1”
p1 = null

val p2 = new Person()
p2.name = “valp2”
// p2 = null //报错
}

class Person {
var name: String = “who”
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

2.3 标识符的命名规范

Scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以起名字的地方都叫标识符。

1）命名规则

Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化，有以下三种规则：

（1）以字母或者下划线开头，后接字母、数字、下划线

（2）以操作符开头，且只包含操作符（+ - * / # !等）

（3）用反引号....包括的任意字符串，即使是Scala关键字（39个）也可以

• package, import, class, object, trait, extends, with, type, for

• private, protected, abstract, sealed, final, implicit, lazy, override

• try, catch, finally, throw

• if, else, match, case, do, while, for, return, yield

• def, val, var

• this, super

• new

• true, false, null

2）案例实操

​ 需求：判断hello、Hello12、1hello、h-b、x h、h_4、ab、Int、、+-/#!、+-/#!1、if、if，这些名字是否合法。

package com.atguigu.chapter1

object TestName {
def main(args: Array[String]): Unit = { 

<span class="token comment">//1.以字母或者下划线开头，后接字母、数字、下划线</span>
<span class="token keyword">var</span> hello<span class="token operator">:</span> <span class="token builtin">String</span> <span class="token operator">=</span> <span class="token string">""</span>
<span class="token keyword">var</span> hello2<span class="token operator">:</span> <span class="token builtin">String</span> <span class="token operator">=</span> <span class="token string">" "</span>

<span class="token comment">//    var 1 hello:String = ""  数字不能开头</span>
<span class="token comment">//    var h - b: String = ""  不能用-</span>
<span class="token comment">//    var x h: String = ""  不能用空格</span>

<span class="token keyword">var</span> h_4<span class="token operator">:</span> <span class="token builtin">String</span> <span class="token operator">=</span> <span class="token string">""</span>
<span class="token keyword">val</span> _ab<span class="token operator">:</span> <span class="token builtin">String</span> <span class="token operator">=</span> <span class="token string">""</span>
<span class="token keyword">var</span> <span class="token builtin">Int</span><span class="token operator">:</span> <span class="token builtin">String</span> <span class="token operator">=</span> <span class="token string">""</span> <span class="token comment">//ok 因为在Scala中Int是预定义的字符,不是关键字，但不推荐</span>
<span class="token keyword">var</span> _<span class="token operator">:</span> <span class="token builtin">String</span> <span class="token operator">=</span> <span class="token string">""</span> <span class="token comment">// ok 单独一个下划线不可以作为标识符，因为_被认为是一个方法</span>



<span class="token comment">//2.以操作符开头，且只包含操作符（+ - * / # ! 等）</span>
<span class="token keyword">var</span> <span class="token operator">+</span><span class="token operator">*</span><span class="token operator">-</span><span class="token operator">/</span>#<span class="token operator">!</span> <span class="token operator">:</span> <span class="token builtin">String</span> <span class="token operator">=</span> <span class="token string">""</span>
<span class="token comment">//    var +*-/#!1 : String = "" 以操作符开头必须都是操作符</span>

<span class="token comment">//3.用反引号`...`包括的任意字符串，即使是Scala关键字（39）个也可以</span>
<span class="token comment">//    var if:String = ""  不用用关键字</span>
<span class="token keyword">var</span> `<span class="token keyword">if</span>`<span class="token operator">:</span> <span class="token builtin">String</span> <span class="token operator">=</span> <span class="token string">""</span>

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

2.4 字符串输出

1）基本语法

（1）字符串，通过+号连接

（2）printf用法：字符串，通过%传值。

（3）字符串模板（插值字符串）：通过$获取变量值

2）案例实操

package com.atguigu.chapter1

object TestCharType {
def main(args: Array[String]): Unit = {
var name: String = “zhangsan”
var age: Int = 22

//1.字符串 通过 + 号连接
println(name + " " + age)

//2.printf 用法字符串，通过%传值
printf(“name=%s age=%d\n”, name, age)

//3.字符串，通过$引用
//多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现。//输入的内容，带有空格、\t之类，导致每一行的开始位置不能整洁对齐。
//应用scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符，//在多行换行的行头前面加一个“|”符号即可。

val s =

“”"
| select
| name
|,
|age
|from user
|where name = “zhangsan”
“”".stripMargin
println(s)

//如果需要对变量进行运算，那么可以加 < / s p a n > < s p a n c l a s s = " t o k e n k e y w o r d " > v a l < / s p a n > s 1 < s p a n c l a s s = " t o k e n o p e r a t o r " > = < / s p a n > < s p a n c l a s s = " t o k e n s t r i n g − i n t e r p o l a t i o n " > < s p a n c l a s s = " t o k e n i d f u n c t i o n " > s < / s p a n > < s p a n c l a s s = " t o k e n s t r i n g " > " " " ∣ s e l e c t ∣ n a m e ∣ , ∣ a g e ∣ f r o m u s e r ∣ w h e r e n a m e = " < / s p a n > < s p a n c l a s s = " t o k e n i n t e r p o l a t i o n " > < s p a n c l a s s = " t o k e n p u n c t u a t i o n " > {}</span> <span class="token keyword">val</span> s1 <span class="token operator">=</span> <span class="token string-interpolation"><span class="token id function">s</span><span class="token string">""" | select | name |, |age |from user |where name="</span><span class="token interpolation"><span class="token punctuation"> </span><spanclass="tokenkeyword">val</span>s1<spanclass="tokenoperator">=</span><spanclass="tokenstring−interpolation"><spanclass="tokenidfunction">s</span><spanclass="tokenstring">"""∣select∣name∣,∣age∣fromuser∣wherename="</span><spanclass="tokeninterpolation"><spanclass="tokenpunctuation">name" and age= < ! − − − − > < / s p a n > < s p a n c l a s s = " t o k e n e x p r e s s i o n " > a g e < s p a n c l a s s = " t o k e n o p e r a t o r " > + < / s p a n > < s p a n c l a s s = " t o k e n n u m b e r " > 2 < / s p a n > < / s p a n > < s p a n c l a s s = " t o k e n p u n c t u a t i o n " > < / s p a n > < / s p a n > < s p a n c l a s s = " t o k e n s t r i n g " > " " " < / s p a n > < / s p a n > < s p a n c l a s s = " t o k e n p u n c t u a t i o n " > . < / s p a n > s t r i p M a r g i n < s p a n c l a s s = " t o k e n k e y w o r d " > v a l < / s p a n > s 2 < s p a n c l a s s = " t o k e n o p e r a t o r " > = < / s p a n > < s p a n c l a s s = " t o k e n s t r i n g − i n t e r p o l a t i o n " > < s p a n c l a s s = " t o k e n i d f u n c t i o n " > s < / s p a n > < s p a n c l a s s = " t o k e n s t r i n g " > " n a m e = < / s p a n > < s p a n c l a s s = " t o k e n i n t e r p o l a t i o n " > < s p a n c l a s s = " t o k e n p u n c t u a t i o n " > {<!-- --></span><span class="token expression">age <span class="token operator">+</span> <span class="token number">2</span></span><span class="token punctuation">}</span></span><span class="token string"> """</span></span><span class="token punctuation">.</span>stripMargin <span class="token keyword">val</span> s2 <span class="token operator">=</span> <span class="token string-interpolation"><span class="token id function">s</span><span class="token string">"name=</span><span class="token interpolation"><span class="token punctuation"> <!−−−−></span><spanclass="tokenexpression">age<spanclass="tokenoperator">+</span><spanclass="tokennumber">2</span></span><spanclass="tokenpunctuation"></span></span><spanclass="tokenstring">"""</span></span><spanclass="tokenpunctuation">.</span>stripMargin<spanclass="tokenkeyword">val</span>s2<spanclass="tokenoperator">=</span><spanclass="tokenstring−interpolation"><spanclass="tokenidfunction">s</span><spanclass="tokenstring">"name=</span><spanclass="tokeninterpolation"><spanclass="tokenpunctuation">name"
println(s2)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

2.5 键盘输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

1）基本语法

StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

2）案例实操

需求：可以从控制台接收用户信息，【姓名，年龄，薪水】。

package com.atguigu.chapter1

import scala.io.StdIn

object TestInput {
def main(args: Array[String]): Unit = {
// 输入姓名
println(“input name:”)
var name = StdIn.readLine()

// 输入年龄
println(“input age:”)
var age = StdIn.readShort()

// 输入薪水
println(“input sal:”)
var sal = StdIn.readDouble()

// 打印
println(“name=” + name)
println(“age=” + age)
println(“sal=” + sal)
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

2.6 数据类型（重点）

  • Java 数据类型

    Java基本数据类型：char、byte、short、int、long、float、double、boolean

    Java引用类型：（对象类型）

    由于Java有基本类型，而且基本类型不是真正意义的对象，即使后面产生了基本类型的包装类，但是仍然存在基本数据类型，所以Java语言并不是真正意义上的面向对象

    Java基本类型的包装类：Character、Byte、Short、Integer、Long、Float、Double、Boolean

    注意：Java中基本类型和引用类型没有共同的祖先。

  • Scala 数据类型

image-20210122145806755

2.7 整数类型（Byte、Short、Int、Long）

Scala的整数类型就是用于存放整数值的，比如12，30，3456等等。

1）整型分类

数据类型描述
Byte [1]8位有符号补码整数。数值区间为 -128 到 127
Short [2]16位有符号补码整数。数值区间为 -32768 到 32767
Int [4]32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long [8]64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 = 2的(64-1)次方-1

2）案例实操

（1）Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性。

（2）Scala的整型，默认为Int型，声明Long型，须后加‘l’或‘L’

package com.atguigu.chapter1

object TestDataType {
def main(args: Array[String]): Unit = {

// 正确
var n1: Byte = 127
var n2: Byte = -128

// 错误
// var n3:Byte = 128
// var n4:Byte = -129

// Scala的整型，默认为Int型，声明Long型，然后加”i“ 或者 ”L“
var n5 = 10
println(n5)

var n6 = 98989898989898989L
println(n6)

var n7 = 2.43434309898f
var n8 = 2.4343662343223
println(n7)
println(n8)

var God = new God()
God = null

//var n1 : Int = null //错误
//println(“n1:” + n1)
}

class God {
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

（3）Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long

2.8 浮点类型（Float、Double）

Scala的浮点类型可以表示一个小数，比如123.4f，7.8，0.12等等。

1）浮点型分类

数据类型描述
Float [4]32 位, IEEE 754标准的单精度浮点数
Double [8]64 位 IEEE 754标准的双精度浮点数

2）案例实操

Scala的浮点型常量默认为Double型，声明Float型常量，须后加‘f’或‘F’。

package com.atguigu.chapter1

object TestDataType {
def main(args: Array[String]): Unit = {

// 正确
var n1: Byte = 127
var n2: Byte = -128

// 错误
// var n3:Byte = 128
// var n4:Byte = -129

// Scala的整型，默认为Int型，声明Long型，然后加”i“ 或者 ”L“
var n5 = 10
println(n5)

var n6 = 98989898989898989L
println(n6)

var n7 = 2.43434309898f
var n8 = 2.4343662343223
println(n7)
println(n8)

var God = new God()
God = null

//var n1 : Int = null //错误
//println(“n1:” + n1)
}

class God {
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

2.9 字符类型（Char）

1）基本说明

字符类型可以表示单个字符，字符类型是Char。

2）案例实操

（1）字符常量是用单引号 ’ ’ 括起来的单个字符。

（2）\t ：一个制表位，实现对齐的功能

（3）\n ：换行符

（4）\ ：表示\

（5）" ：表示"

package com.atguigu.chapter1

object TestCharType2 {
def main(args: Array[String]): Unit = {
var c1: Char = ‘a’
println(“c1=” + c1)

//注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围
//不过idea提示报错
var c2: Char = ‘a’ + 1
println(c2)

// \t ：一个制表位，实现对齐的功能
println(“姓名\t年龄”)

// \n ：换行符
println(“西门庆\n潘金莲”)

//（4）\ ：表示</span>
println(“c:\天黑了\饿狼来了”)

//（5）" ：表示"
println(“你过来：“看我一拳打死你””)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

2.10 布尔类型：Boolean

1）基本说明

（1）布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false

（2）boolean类型占1个字节。

2）案例实操

package com.atguigu.chapter1

object TestBooleanType {
def main(args: Array[String]): Unit = {
var isResult : Boolean = false
var isResult2 : Boolean = true

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

2.11 Unit类型、Null类型和Nothing类型（重点）

1）基本说明

数据类型描述
Unit表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Nullnull , Null 类型只有一个实例值null
NothingNothing类型在Scala的类层级最低端；它是任何其他类型的子类型。 当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

2）案例实操

（1）Unit类型用来标识过程，也就是没有明确返回值的函数。

由此可见，Unit类似于Java里的void。Unit只有一个实例——( )，这个实例也没有实质意义

package com.atguigu.chapter1

object TestSpecialType {
def main(args: Array[String]): Unit = {
def sayOk: Unit = { // unit 表示没有返回值，即void
}

println(sayOk)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

（2）Null类只有一个实例对象，Null类似于Java中的null引用。Null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）

package com.atguigu.chapter1

object TestDataType {
def main(args: Array[String]): Unit = {

// 正确
var n1: Byte = 127
var n2: Byte = -128

// 错误
// var n3:Byte = 128
// var n4:Byte = -129

// Scala的整型，默认为Int型，声明Long型，然后加”i“ 或者 ”L“
var n5 = 10
println(n5)

var n6 = 98989898989898989L
println(n6)

var n7 = 2.43434309898f
var n8 = 2.4343662343223
println(n7)
println(n8)

// null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
var God = new God()
God = null

// var n1: Int = null //错误
// println(“n1:” + n1)
}

class God {
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

（3）Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。

package com.atguigu.chapter1

object TestSpecialType {
def test(): Nothing = {
throw new Exception
}

test()
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

2.12 类型转换

扩展Java面试题（隐式类型转换）：

package com.atguigu.chapter1;

public class TestTypeConversion {
public static void main(String[] args) {
byte b = 10;
test(b);
}

<span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">test</span><span class="token punctuation">(</span><span class="token keyword">byte</span> b<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"bbbb"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">test</span><span class="token punctuation">(</span><span class="token keyword">short</span> s<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"ssss"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">test</span><span class="token punctuation">(</span><span class="token keyword">char</span> c<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"cccc"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">test</span><span class="token punctuation">(</span><span class="token keyword">int</span> i<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"iiii"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

2.12.1 数值类型自动转换

当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：

image-20210122153533213

1）基本说明

（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。

（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。

（3）（byte，short）和char之间不会相互自动转换。

（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。

2）案例实操

package com.atguigu.chapter2

object TestValueTransfer {
def main(args: Array[String]): Unit = {

//（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
var n = 1 + 2.2222
println(n) //Double

//（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
var n2: Double = 2.2222
// var n3: Int = n2 //报错

//（3）（byte，short）和char之间不会相互自动转换。
var n4: Byte = 44
// var c1 : Char = n4 //报错
var n5: Int = n4

//（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
var n6: Byte = 66
var c2: Char = 22
// var n : Short = n6 + c2 //报错，结果是Int类型
// var n7 : Short = 10 + 20 //报错，byte，short，char他们三者可以计算，在计算时首先转换为int类型。

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

注意：Scala还提供了非常强大的隐式转换机制（隐式函数，隐式类等），我们放在高级部分专门用一个章节来讲解。

2.12.2 强制类型转换

1）基本说明

自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。

Java : int num = (int)2.5

Scala : var num : Int = 2.7.toInt

2）案例实操

（1）将数据由高精度转换为低精度，就需要使用到强制转换

（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

package com.atguigu.chapter1

object TestForceTransfer {

def main(args: Array[String]): Unit = {

//（1）将数据由高精度转换为低精度，就需要使用到强制转换
var n1: Int = 2.5.toInt // 这个存在精度损失

//（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
var r1: Int = 10 3.5.toInt + 6 1.5.toInt // 10 3 + 61 = 36
var r2: Int = (10 3.5 + 6 1.5).toInt // 44.0.toInt = 44

println(“r1=” + r1 + " r2=" + r2)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

2.12.3 数值类型和String类型间转换

1）基本说明

在程序开发中，我们经常需要将基本数值类型转成String类型。或者将String类型转成基本数值类型。

2）案例实操

（1）基本类型转String类型（语法：将基本类型的值+“” 即可）

（2）String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）

package com.atguigu.chapter2

object TestStringTransfer {
def main(args: Array[String]): Unit = {
//（1）基本类型转String类型（语法：将基本类型的值+“” 即可）
var str1: String = true + “你kin”
println(str1)
var str2: String = 4.444 + “拜拜”
println(str2)
var str3: String = 4444 + “”
println(str3)

//（2）String类型转基本数值类型（语法：调用相关API）
var s1: String = “11”
var n1: Byte = s1.toByte
var n2: Short = s1.toShort
var n3: Int = s1.toInt
var n4: Long = s1.toLong
println(s1)
println(n1)
println(n2)
println(n3)
println(n4)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

（3）注意事项

在将String类型转成基本数值类型时，要确保String类型能够转成有效的数据，比如我们可以把"123"，转成一个整数，但是不能把"hello"转成一个整数。

var n5:Int = “12.6”.toInt会出现NumberFormatException异常。

扩展面试题

package com.atguigu.chapter2

object TestType {
def main(args: Array[String]): Unit = {
// 00000000 00000000 00000000 10000010
// var n: Int = 128 //转换成-128
var n: Int = 130 //转换成-126
var b: Byte = n.toByte

// 10000000 为当前字节范围最小值，约定-128
// 负数补码：符号位不变，其他位按位取反 + 1
println(b)
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

第3章 运算符

Scala运算符的使用和Java运算符的使用基本相同，只有个别细节上不同。

3.1 算术运算符

1）基本语法

运算符运算范例结果
+正号+33
-负号b=4; -b-4
+加5+510
-减6-42
*乘3*412
/除5/51
%取模(取余)7%52
+字符串相加“He”+”llo”“Hello”

（1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。

（2）对一个数取模a%b，和Java的取模规则一样。

2）案例实操

package com.atguigu.chapter2

object TestArithmetic {
def main(args: Array[String]): Unit = {

// 1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
var r1: Int = 10 / 3
println(r1) //3

var r2: Double = 10 / 3
println(r2) //3.0

var r3: Double = 10.0 / 3
println(r3) //3.3333333333333335
println(r3.formatted(“%.2f”)) //3.33 含义：保留小数点2位，使用四舍五入

//（2）对一个数取模a%b，和Java的取模规则一样。
var r4 = 10 % 3
println(r4) //1

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

3.2 关系运算符（比较运算符）

1）基本语法

运算符运算范例结果
==相等于4==3false
!=不等于4！=3true
<小于4<3false
>大于4>3true
<=小于等于4<=3false
>=大于等于4>=3true

2）案例实操

​ （1）需求1：

package com.atguigu.chapter2

object TestRelation {
def main(args: Array[String]): Unit = {

// 测试：>、>=、<=、<、==、!=
var a: Int = 2
var b: Int = 1

println(a > b) // true
println(a >= b) // true
println(a < b) // false
println(a <= b) // false
println("ab" + (a b)) // false
println(a != b) // true
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

（2）需求2：Java和Scala中关于==的区别

Java：==比较两个变量本身的值，即两个对象在内存中的首地址；equals比较字符串中所包含的内容是否相同。

package com.atguigu.chapter2;

public class TestRelation2 {
public static void main(String[] args) {
String s1 = “hhhh”;
String s2 = new String(“hhhh”);

System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

Scala：==更加类似于Java中的equals，参照jd工具

package com.atguigu.chapter2

object TestRelationScala {
def main(args: Array[String]): Unit = {
val s1 = “aaa”
val s2 = new String(“aaa”)

println(s1 == s2) // true
println(s1.eq(s2)) // false
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

3.3 逻辑运算符

1）基本语法

用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个Boolean值。

假定：变量A为true，B为false

运算符描述实例
&&逻辑与(A && B) 运算结果为 false
||逻辑或(A || B) 运算结果为 true
!逻辑非!(A && B) 运算结果为 true

2）案例实操

package com.atguigu.chapter2

object TestLogic {

def main(args: Array[String]): Unit = {

// 测试：&&、||、！
var a = true
var b = false

println(“a&&b=” + (a && b)) // a&&b=false
println(“a || b =” + (a || b)) // a || b =true
println(“!(a&&b)” + (!(a && b))) // !(a&&b)true
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

3.4 赋值运算符

1）基本语法

赋值运算符就是将某个运算后的值，赋给指定的变量。

运算符描述实例
=简单的赋值运算符，将一个表达式的值赋给一个左值C = A + B 将 A + B 表达式结果赋值给 C
+=相加后再赋值C += A 等于 C = C + A
-=相减后再赋值C -= A 等于 C = C - A
*=相乘后再赋值C *= A 等于 C = C * A
/=相除后再赋值C /= A 等于 C = C / A
%=求余后再赋值C %= A 等于 C = C % A
<<=左移后赋值C <<= 2等于 C = C << 2
>>=右移后赋值C >>= 2 等于 C = C >> 2
&=按位与后赋值C &= 2 等于 C = C & 2
^=按位异或后赋值C ^= 2 等于 C = C ^ 2
|=按位或后赋值C |= 2 等于 C = C | 2

注意：Scala中没有++、–操作符，可以通过+=、-=来实现同样的效果；

2）案例实操

package com.atguigu.chapter2

object TestAssignment {
def main(args: Array[String]): Unit = {
var r1 = 11

// 没有++
r1 += 1 //12
println(r1)
// 没有–
r1 -= 2 //10
println(r1)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

3.5 位运算符

1）基本语法

​ 下表中变量 a 为 60，b 为 13。

运算符描述实例
&按位与运算符(a & b) 输出结果 12 ，二进制解释： 0000 1100
|按位或运算符(a | b) 输出结果 61 ，二进制解释： 0011 1101
^按位异或运算符(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~按位取反运算符(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<左移动运算符a << 2 输出结果 240 ，二进制解释： 0011 0000
>>右移动运算符a >> 2 输出结果 15 ，二进制解释： 0000 1111
>>>无符号右移a >>>2 输出结果 15, 二进制解释: 0000 1111

2）案例实操

package com.atguigu.chapter2

object TestPositon {
def main(args: Array[String]): Unit = {

// 测试：1000 << 1 =>10000
var n1: Int = 8
n1 = n1 << 1
println(n1) // 16
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

3.6 Scala运算符本质

在Scala中其实是没有运算符的，所有运算符都是方法。

1）当调用对象的方法时，点.可以省略

2）如果函数参数只有一个，或者没有参数，()可以省略

object TestOpt {
   def main(args: Array[String]): Unit = { 
// 标准的加法运算
 val i:Int = 1.+(1)

// （1）当调用对象的方法时，.可以省略
val j:Int = 1 + (1)

// （2）如果函数参数只有一个，或者没有参数，()可以省略
val k:Int = 1 + 1

println(1.toString())
println(1 toString())
println(1 toString)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

第4章 流程控制

4.1 分支控制if-else

让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支

4.1.1 单分支

1）基本语法

if (条件表达式) {

执行代码块

}

说明：当条件表达式为ture时，就会执行{ }的代码。

2）案例实操

需求：输入人的年龄，如果该同志的年龄小于18岁，则输出“童年”

package com.atguigu.chapter3

import scala.io.StdIn

object TestIfElse {
def main(args: Array[String]): Unit = {
println(“input age:”)
var age=StdIn.readShort()
if (age < 18){
println(“童年”)
}
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

4.1.2 双分支

1）基本语法

if (条件表达式) {

执行代码块1

} else {

执行代码块2

}

2）案例实操

需求：输入年龄，如果年龄小于18岁，则输出“童年”。否则，输出“成年”。

package com.atguigu.chapter3

import scala.io.StdIn

object TestIfElse {
def main(args: Array[String]): Unit = {
println(“input age:”)
var age = StdIn.readShort()
if (age < 18) {
println(“童年”)
} else {
println(“成年”)
}

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

4.1.3 多分支

1）基本语法

if (条件表达式1) {

执行代码块1

}

else if (条件表达式2) {

执行代码块2

}

……

else {

执行代码块n

}

2）案例实操

（1）需求1：需求：输入年龄，如果年龄小于18岁，则输出“童年”。如果年龄大于等于18且小于等于30，则输出“中年”，否则，输出“老年”。

package com.atguigu.chapter3

import scala.io.StdIn

object TestIfElse {
def main(args: Array[String]): Unit = {
println(“input age:”)
var age = StdIn.readShort()
if (age < 18) {
println(“童年”)
} else if (age >= 18 && age < 30) {
println(“中年”)
} else {
println(“老年”)
}
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

（2）需求2：Scala中if else表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。

package com.atguigu.chapter3

import scala.io.StdIn

object TestIfElse {
def main(args: Array[String]): Unit = {
println(“input age:”)
var age = StdIn.readShort()

val res :String = if (age < 18) {
“童年”
} else if (age >= 18 && age < 30) {
“中年”
} else {
“老年”
}

println(res)

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

（3）需求3：Scala中返回值类型不一致，取它们共同的祖先类型。

package com.atguigu.chapter3

import scala.io.StdIn

object TestIfElse {
def main(args: Array[String]): Unit = {

println(“input age:”)
var age = StdIn.readShort()

val res :Any = if (age < 18) {
“童年”
} else if (age >= 18 && age < 30) {
“中年”
} else {
100
}

println(res)

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

（4）需求4：Java中的三元运算符可以用if else实现

如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if只对最近的一行逻辑代码起作用。

package com.atguigu.chapter3

import scala.io.StdIn

object TestIfElse {
def main(args: Array[String]): Unit = {

// Java
// int result = flag?1:0

// Scala
println(“input age:”)
var age = StdIn.readShort()
val res: Any = if (age < 18) “童年” else “成年”

println(res)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

4.2 嵌套分支

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

1）基本语法

if(){
if(){

}else{

}

}

2）案例实操

需求：如果输入的年龄小于18，返回“童年”。如果输入的年龄大于等于18，需要再判断：如果年龄大于等于18且小于30，返回“中年”；如果其他，返回“老年”。

package com.atguigu.chapter3

import scala.io.StdIn

object TestIfElse {
def main(args: Array[String]): Unit = {

// Scala
println(“input age:”)
var age = StdIn.readShort()
val res: Any = if (age < 18) {
“童年”
} else {
if (age >= 18 && age < 30) {
“中年”
} else {
“老年”
}
}

println(res)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

4.3 Switch分支结构

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

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

4.4 For循环控制

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

4.4.1 范围数据循环（To）

1）基本语法

for(i <- 1 to 3){

print(i + " ")

}

println()

（1）i 表示循环的变量，<- 规定to

（2）i 将会从 1-3 循环，前后闭合

4.4.2 范围数据循环（Until）

1）基本语法

for(i <- 1 until 3) {

print(i + " ")

}

println()

（1）这种方式和前面的区别在于i是从1到3-1

（2）即使前闭合后开的范围

2）案例实操

4.4.3 循环守卫

1）基本语法

for(i <- 1 to 3 if i != 2) {

print(i + " ")

}

println()

说明：

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

（2）上面的代码等价

for (i <- 1 to 3){
if (i != 2) {
print(i + " ")
}
}

4.4.4 循环步长

1）基本语法

for (i <- 1 to 10 by 2) {

println(“i=” + i)

}

说明：by表示步长

2）案例实操

​ 需求：输出1到10以内的所有奇数

for (i <- 1 to 10 by 2) {
println(“i=” + i)

}

输出结果

i=1

i=3

i=5

i=7

i=9

4.4.5 嵌套循环

1）基本语法

for(i <- 1 to 3; j <- 1 to 3) {

println(" i =" + i + " j = " + j)

}

说明：没有关键字，所以范围后一定要加；来隔断逻辑

2）基本语法

上面的代码等价

for (i <- 1 to 3) {
for (j <- 1 to 3) {
println(“i =” + i + " j=" + j)
}
}

4.4.6 引入变量

1）基本语法

for(i <- 1 to 3; j = 4 - i) {

println(“i=” + i + " j=" + j)

}

  • 1
  • 2
  • 3
  • 4
  • 5

说明：

（1）for推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑

（2）for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下

for {
i <- 1 to 3

j = 4 - i

} {

println(“i=” + i + " j=" + j)

}

2）案例实操

上面的代码等价于

for (i <- 1 to 3) {
var j = 4 - i
println(“i=” + i + " j=" + j)
}

4.4.7 循环返回值

1）基本语法

val res = for(i <- 1 to 10) yield i

println(res)

说明：将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字。

注意：开发中很少使用。

2）案例实操

​ 需求：将原数据中所有值乘以2，并把数据返回到一个新的集合中。

object TestFor {
def main(args: Array[String]): Unit = {
    var res = for(i <-1 to 10) yield {
      i * 2
    }
    println(res)

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

输出结果：

Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

4.4.8 倒序打印

1）说明：如果想倒序打印一组数据，可以用reverse。

2）案例实操：

需求：倒序打印10到1

for(i <- 1 to 10 reverse){
   println(i)
 }

 
 

 
 
  • 1
  • 2
  • 3

4.5 While和do…While循环控制

While和do…While的使用和Java语言中用法相同。

4.5.1 While循环控制

1）基本语法

循环变量初始化

while (循环条件) {

循环体(语句)

循环变量迭代

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

说明：

（1）循环条件是返回一个布尔值的表达式

（2）while循环是先判断再执行语句

（3）与for语句不同，while语句没有返回值，即整个while语句的结果是Unit类型()

（4）因为while中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。

package com.atguigu.chapter3

object For01 {
def main(args: Array[String]): Unit = {

// 1.范围循环 To
for (i <- 1 to 3)
println(“生如”)
println(“to----------------------”)

// 2.范围循环 Unit
for (i <- 1 until 3)
println(“夏花”)
println(“until----------------------”)

// 3.循环守卫
for (i <- 1 to 6) {
if (i != 2) {
println(i)
}
}
println(“!=----------------------”)
// 4.循环步长 by
for (i <- 1 to 6 by 2)
println(i)

println(“by----------------------”)
for (i <- -10 to -1 by 2)
println(i)
println(“by----------------------”)

// 5.循环嵌套
for (i <- 1 to 4; j <- 1 to 6) {
print(“i=” + i + “,j=” + j + “\t”)
if (j == 6)
println()
}
println(“嵌套----------------------”)

// 6.引入变量
for (i <- 1 to 10; j = 10 - i) {
println(“i=” + i + “,j=” + j)
}
println(“引入变量----------------------”)

for {
i <- 1 to 3
j = 3 - i
} {
println(“i=” + i + “,j=” + j)
}
println(“引入变量----------------------”)

// 7.循环返回值
val res = for (i <- 1 to 10) yield i
println(res)
println(“----------------------”)

//需求：将原数据中所有值乘以2，并把数据返回到一个新的集合中。
var res1 = for (i <- 1 to 10) yield {
i * 2
}
println(res1)
println(“循环返回值----------------------”)

// 8.倒序打印
for (i <- 1 to 10 reverse) {
println(i)
}
println(“倒序----------------------”)
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77

4.5.2 do…while循环控制

1）基本语法

 循环变量初始化;
  do{
    循环体(语句)
    循环变量迭代
  } while(循环条件)

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

​ 说明

（1）循环条件是返回一个布尔值的表达式

（2）do…while循环是先执行，再判断

4.6 循环中断

1）基本说明

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

2）案例实操

需求1：采用异常的方式退出循环

//  1.正常结束循环
try {
 for (elem <- 1 to 10) {
   println(elem)
   if (elem == 5) throw new RuntimeException
 }
} catch {
 case e =>
}
println("正常结束循环")
}

  
  

  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

需求2：采用Scala自带的函数，退出循环

//  2.采用scala自带的函数，退出循环
Breaks.breakable(
for (e <- 1 to 5) {
println(e)
if (e == 5) Breaks.break()
}
)
println("正常结束循环")

  
  

  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

​ 需求3：对break进行省略

package com.atguigu.chapter3

import scala.util.control.Breaks._

object TestBreak {
def main(args: Array[String]): Unit = {
breakable {
for (elem <- 1 to 10) {
println(elem)
if (elem == 5) break
}
}
println(“正常结束循环”)
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

​ 需求4：循环遍历10以内的所有数据，奇数打印，偶数跳过（continue）

package com.atguigu.chapter3

//循环遍历10以内的所有数据，奇数打印，偶数跳过（continue）

object TestBreak02 {
def main(args: Array[String]): Unit = {
for (elem <- 1 to 10) {
if (elem % 2 == 1){
println(elem)
}else{
println(“continue”)
}
}
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

4.7 多重循环

1）基本说明

（1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】

（2）设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

2）案例实操

需求：打印出九九乘法表

package com.atguigu.chapter3

object TestWhile02 {
def main(args: Array[String]): Unit = {
for (i <- 1 to 10) {
for (j <- 1 to i) {
print(j + ““ + i + ”=" + (i j) + ”\t")
}

println()
}
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

第5章 函数式编程

1）面向对象编程

解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。

对象：用户

行为：登录、连接JDBC、读取数据库

属性：用户名、密码

Scala语言是一个完全面向对象编程语言。万物皆对象

对象的本质：对数据和行为的一个封装

2）函数式编程

解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。

例如：请求->用户名、密码->连接JDBC->读取数据库

Scala语言是一个完全函数式编程语言。万物皆函数。

函数的本质：函数可以当做一个值进行传递

3）在Scala中函数式编程和面向对象编程完美融合在一起了。

5.1 函数基础

5.1.1 函数基本语法

1）基本语法

​ image-20210125144848932

2）案例实操

​ 需求：定义一个函数，实现将传入的名称打印出来。

object TestFunction {

def main(args: Array[String]): Unit = {

​ // （1）函数定义

​ def f(arg: String): Unit = {

​ println(arg)

​ }

​ // （2）函数调用

​ // 函数名（参数）

​ f(“hello world”)

}

}

5.1.2 函数和方法的区别

1）核心概念

（1）为完成某一功能的程序语句的集合，称为函数。

（2）类中的函数称之方法。

2）案例实操

（1）Scala语言可以在任何的语法结构中声明任何的语法

（2）函数没有重载和重写的概念；方法可以进行重载和重写

（3）Scala中函数可以嵌套定义

package com.atguigu.chapter5

object TestFunction01 {

// 2.方法可以进行重载和重写，程序可以执行
def main(): Unit = { }

def main(args: Array[String]): Unit = {
// 1.Scala语言可以在任何的语法结构中声明任何的语法
import java.util.Date
new Date()

// 3.函数没有重载和重写的概念，程序报错
def test(): Unit = {
println(“无参，无返回值”)
}

test()

def test1(name: String): Unit = {
println()
}

// 4.Scala 中函数可以嵌套定义
def test2() :Unit = {
def test3(name:String):Unit={
println(“函数可以嵌套定义”)
}
}
}

}package com.atguigu.chapter5

object TestFunction01 {

// 2.方法可以进行重载和重写，程序可以执行
def main(): Unit = { }

def main(args: Array[String]): Unit = {
// 1.Scala语言可以在任何的语法结构中声明任何的语法
import java.util.Date
new Date()

// 3.函数没有重载和重写的概念，程序报错
def test(): Unit = {
println(“无参，无返回值”)
}

test()

def test1(name: String): Unit = {
println()
}

// 4.Scala 中函数可以嵌套定义
def test2() :Unit = {
def test3(name:String):Unit={
println(“函数可以嵌套定义”)
}
}
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

​

5.1.3 函数定义

1）函数定义

（1）函数1：无参，无返回值

（2）函数2：无参，有返回值

（3）函数3：有参，无返回值

（4）函数4：有参，有返回值

（5）函数5：多参，无返回值

（6）函数6：多参，有返回值

2）案例实操

package com.atguigu.chapter5

object TestFunctionDeclare {
def main(args: Array[String]): Unit = {
//1.无参，无返回值
def t1():Unit={
println(“1.无参，无返回值”)
}
t1()

//2.无参，有返回值
def t2():String ={
return “2.无参，有返回值”
}
println(t2())

//3.有参，无返回值
def t3(s:String):Unit={
println(s)
}
t3(“t3”)

//4.有参，有返回值
def t4(s:String):String={
return s+“4.有参，有返回值”
}
println(t4(“hello”))

//5.多参，无返回值
def t5(name:String,age:Int):Unit={
println(s“ < / s p a n > < s p a n c l a s s = " t o k e n e x p r e s s i o n " > n a m e < / s p a n > < / s p a n > < s p a n c l a s s = " t o k e n s t r i n g " > , < / s p a n > < s p a n c l a s s = " t o k e n i n t e r p o l a t i o n " > < s p a n c l a s s = " t o k e n p u n c t u a t i o n " > </span><span class="token expression">name</span></span><span class="token string">,</span><span class="token interpolation"><span class="token punctuation"> </span><spanclass="tokenexpression">name</span></span><spanclass="tokenstring">,</span><spanclass="tokeninterpolation"><spanclass="tokenpunctuation">age”)
}
t5(“monika”,22)

}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

5.1.4 函数参数

1）案例实操

（1）可变参数

（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后

（3）参数默认值，一般将有默认值的参数放置在参数列表的后面

（4）带名参数

package com.atguigu.chapter5

object TestFunction02 {
def main(args: Array[String]): Unit = {
// 1.可变参数
def test(s: String*): Unit = {
println(s)
}
// 有输入参数：输出Array
test(“Hello”, “Scala”)

// 无输入参数：输出List()
test()

// 2.如果参数列表中存在多个参数，那么可变参数一般放置在最后
def test2(name: String, s: String): Unit = {
println(name + “,” + s)
}

test2(“jinlian”, “dalang”)

// 3.参数默认值
def test3(name: String, age: Int = 30): Unit = {
println(s“ < / s p a n > < s p a n c l a s s = " t o k e n e x p r e s s i o n " > n a m e < / s p a n > < / s p a n > < s p a n c l a s s = " t o k e n s t r i n g " > , < / s p a n > < s p a n c l a s s = " t o k e n i n t e r p o l a t i o n " > < s p a n c l a s s = " t o k e n p u n c t u a t i o n " > </span><span class="token expression">name</span></span><span class="token string">,</span><span class="token interpolation"><span class="token punctuation"> </span><spanclass="tokenexpression">name</span></span><spanclass="tokenstring">,</span><spanclass="tokeninterpolation"><spanclass="tokenpunctuation">age”)
}
// 如果参数传递了值，那么会覆盖默认值
test3(“jinlian”, 20)
// 如果参数有默认值，在调用的时候，可以省略这个参数
test3(“dalang”)

// 一般情况下，将有默认值的参数放置在参数列表的后面
def test4(sex: String = “男”, name: String): Unit = {
println(s“name,sex”)
}

// Scala函数中参数传递是，从左到右
// test4(“wusong”) //报错
test4(“女”, “jinlian”)

// 4.带名参数
test4(name = “ximenqing”)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

5.1.5 函数至简原则（重点）

函数至简原则：能省则省

1）至简原则细节

（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值

（2）如果函数体只有一行代码，可以省略花括号

（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）

（4）如果有return，则不能省略返回值类型，必须指定

（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用

（6）Scala如果期望是无返回值类型，可以省略等号

（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加

（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略

（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

2）案例实操

package com.atguigu.chapter5

object TestFunction {
def main(args: Array[String]): Unit = {

def f(s: String): String = {
return s + “f”
}

println(f(“f”))
println(“-------------------”)

//1.return可以省略，scala会使用函数体的最后一行代码作为返回值
def f1(s: String): String = {
s + “f1”
}

println(f1(“f1”))
println(“-------------------”)

//2.如果函数体只有一行代码，可以省略花括号
def f2(s: String): String = s + “f2”

println(f2(“f2”))
println(“-------------------”)

//3.返回值类型如果能够推断出来，那么可以省略
def f3(s: String) = s + “f3”

println(f3(“f3”))
println(“-------------------”)

//4.如果有return，则不能省略返回值类型，必须指定
def f4(): String = {
return “f4”
}

println(f4())
println(“-------------------”)

//5.如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
def f5(): Unit = {
return “f5”
}

println(f5())
println(“-------------------”)

//6.如果期望是无返回值类型，那么可以省略等号
def f6(): Unit = {
“f6”
}

println(f6())
println(“-------------------”)

//7.如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
def f7() = “f7”

println(f7())
println(f7)
println(“-------------------”)

//8.如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
def f8 = “f8”

println(f8)
println(“-------------------”)

//9.
def f9 = (str: String) => {
println(“f9”)
}

println(“-------------------”)

def f10(f: String => Unit) = {
f(“”)
}

f10(f9)
println(f10((str: String) => {
println(“f10”)
}))
println(“-------------------”)

def f11(fun: (String) => Unit): Unit = {
println(“调用别的函数，做为参数传入”)
fun(“f11”)
}

f11(f9)
f11((x: String) => println(x))

f11((x) => {
println(x)
})
f11(x => {
println(x)
})
f11(x => println(x))
f11(println(_))
f11(println)
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107

5.2 函数高级

5.2.1 高阶函数

在Scala中，函数是一等公民。怎么体现的呢？

对于一个函数我们可以：定义函数、调用函数

object TestFunction {

def main(args: Array[String]): Unit = {
// 调用函数

foo<span class="token punctuation">(</span><span class="token punctuation">)</span>

}
// 定义函数
def foo():Unit = {
println(“foo…”)
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

但是其实函数还有更高阶的用法

1）函数可以作为值进行传递

package com.atguigu.chapter5

object TestFunction03 {
def main(args: Array[String]): Unit = {

// (1)调用foo函数，把返回值给变量f
// val f = foo()
val f = foo
println(f)

// (2)在被调用函数foo后面加上 _, 相当于把函数foo当成一个整体，传递给变量 f1
val f1 = foo _

foo()
f1()

// (3)如果明确变量类型，那么不适用下划线也可以将函数作为整体传递给变量
var f2: () => Int = foo

}

<span class="token com

南城学徒
关注
scala基础入门
qq_42005540的博客
04-24 192
scala基础入门一、数据类型分类二、字符串插值三、条件控制语句四、循环控制五、for 循环过滤六、中断七、 scala数组创建八、 scala创建元组 一、数据类型分类 Any: 所有类型的超类（顶级类型） 包含：AnyVal:值类型的超类 AnyRef引用类型的超类 AnyVal: 表示值类型的超类 包含Double,Float,Int,Short,Long,Char,Byte,Unit,Boolean —Nothing AnyRef: 表示引用类型的超类，对应java.lang.Object 包
Scala基础入门：从零开始学习Scala编程
weixin_41859354的博客
08-05 1928
Scala是由Martin Odersky于2003年设计的一种现代编程语言，其名称来源于“Scalable Language”（可扩展语言）。Scala运行在Java虚拟机（JVM）上，可以与Java进行无缝集成。它既支持面向对象编程，也支持函数式编程，允许开发者编写简洁、高效的代码。val：定义不可变变量（类似于Java中的finalvar：定义可变变量y = 30.5 // 允许修改// x = 15 // 不允许修改，会报错函数使用def// 函数体// 返回值使用class。
【Spark】scala基础入门
发现问题，并解决问题，批判性思维
06-29 4349
scala基础教程（面向对象、函数式编程、静态类型等等特点），附带基础简单的栗子
Scala入门基础
Anchor
08-30 4138
Scala是一门多范式的编程语言。是一种纯面向对象的语言，每个值都是对象。同时也是一种函数式语言，其函数也能当成值来使用。由于Scala整合了面向对象和函数式编程的特性，因此Scala相对于Java、C#、C++等其它语言更简洁。本文章将通过简单的案例教会大家如何简单的使用Scala编程，大家也可以模仿案例动手实践有助于自己入门学习 Scala也是运行在JVM上的语言，所以必须确认环境中安装了Java Windows安装直接在官网下载后，在本地高级系统设置中添加bin目录地址环境即可............
Scala基础入门学习
liangxueyuan0的博客
03-27 444
摘自：http://www.runoob.com/scala/scala-tutorial.html 认识Scala：scala是一门多范式的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。运行在java虚拟机上并兼容现有的java程序，与Java一样，scala源代码会被编译成Java字节码运行在JVM之上。 几个特性： 面向对象特性：是一种纯面向对象的语言，每个值都是对象，对象...
Scala 基础入门教程
热门推荐
tomcat的专栏
03-16 1万+
1.前言最近在参加Hadoop和Spark培训，需要使用Scala，自学了一下作为入门，这里作一个记录。2.下载1) 在scala官网下载，地址: http://www.scala-lang.org/2) 下载IDE，地址: http://scala-ide.org/3）配置环境变量SCALA_HOME:C:\Program Files (x86)\scalaPath:C:\Program Fil
Scala语言入门
qq_40068304的博客
04-18 1118
方法定义由一个def关键字开始，紧接着是可选的参数列表，一个冒号和方法的返回类型，一个等于号，最后是方法的主体。def functionName ([参数列表]) : [return type] = {//以下两个demo例子//1.以下方法的功能是将两个传入的参数相加并求和：return sum//2.如果方法没有返回值，可以返回为 Unit，这个类似于 Java 的 void, 实例如下：")
Scala 基础入门 内容整理及课后习题
cqhblg的博客
07-10 1146
第1章 基础 1. 在Scala中键入3.，然后按Tab键。有哪些方法可以被应用？ 答：输入3.，按下Tab后，出现如下函数： 2. 在Scala REPL中，计算3的平方根，然后再对该值求平方，现在这个结果与3相差多少？（提示：res变量是你的朋友。） 3. res变量是val还是var？ 答：val，在doc窗口下改变一下值就知道了。 4. Scala允许你用数字去乘字符串——去REPL中...
Scala基础入门 (一)
金玉良缘
01-06 372
http://www.donghongchao.cn 1.Scala概述 什么是Scala Scala是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台（Java虚拟机），并兼容现有的Java程序。 2.Scala编译器安装 2.1、安装JDK（因为Scala是运行在JVM平台上的，所以安装Scala之前要安装JDK
Scala语言课程：班级总分计算与SCALA基础入门
课程内容涵盖了Scala语言的基础知识，如语言概述、变量、开发环境设置以及编程实践。 在第一章"SCALA的概述"中，作者介绍了学习Scala的原因，包括其与Java的对比以及与JVM的关系。Scala的特点被重点阐述，包括其...
掌握Spark必备：Scala基础入门与安装指南
"Scala基础知识笔记" 是一份详细介绍了Scala编程语言的基础内容和其在大数据处理中的应用，特别是与Apache Spark的关系。Scala是一种多范式编程语言，它结合了面向对象和函数式编程的特点，使其在数据处理和分布式...
Scala的List（可变)
2401_83378805的博客
11-13 431
println(s"200在不在List中${li1.contains(200)}")println(li1(1)) //1就是第二个元素。//2.2删除某个位置的元素列如，删除第三个。// 有序:下表从0开始，可以依次访问。//操作：添加，删除，修改，查询，遍历。//5.合并 ++ 简单的合并。//2.1 删除某个元素。//通过下标来访问元素。// 链表结构:有头有尾。//分类：可变，不可变。
Scala-键盘输入（StdIn）-用法详解
最新发布
喻师傅的学习笔记
11-17 230
Scala—StdIn键盘输入用法
scala 迭代更新
2301_80936715的博客
11-13 515
在Scala中，迭代器（Iterator）是一种用于遍历集合（如数组、列表、集合等）的元素而不暴露其底层表示的对象。迭代器提供了一种统一的方法来访问集合中的元素，而无需关心集合的具体实现。在Scala中，可以通过调用集合的`iterator`方法或`toIterator`方法来获取一个迭代器。迭代器是Scala集合框架中非常重要的一部分，它们提供了一种高效且灵活的方式来遍历和处理集合中的元素。next(): 返回迭代器的下一个元素，并移动到下一个元素。1.hasNext: 检查迭代器是否还有更多元素。
Scala 的List
2301_81748087的博客
11-13 548
在集合中添加多个集合元素使用..方式，例如 List(1,2)=11,List(3,4)=12,结合这两个集合可以使用1:12=(1,2,3,4)。Scala中的List 与Java中的完全不同，它是基于链表实现的并且是一个不可变的集合，无论大小还是元素都是不可变的。首先，列表是不可变的，值一旦被定义了就不能改变，其次，列表具有递归的结构(也就是链表结构)， 而数组不是。定义List的类型方式为List[T],T表示数据类型，指定List集合中只能存放T类型的元素。2.Scala的List的类型。
set的特点
wjwjssjjs的博客
11-13 353
val book1 =new Book("西游记","吴承恩",100)val book2 =new Book("西游记","吴承恩",100)val book3 =new Book("西游记","吴承恩",100)
Scala学习记录，case class，迭代器
2402_87076376的博客
11-13 1036
方法创建的子迭代器是从原迭代器的开头开始，跳过指定数量的元素后包含剩余的元素。创建一个新的列表用于存储每个学生的平均成绩（三门课的平均绩），再创建该列表的选代器。的构造函数除了初始化数据外，还可能用于初始化可变的数据成员，并且可以在构造函数中进行复杂的初始化逻辑，如资源分配、数据库连接等操作。为学生列表创建迭代器，使用选代器的hasNext 和next方法遍历学生信息，打印每个学生的姓名。1.使用case class创建图书信息类Book：包含四个属性:ID，书名，作者，价格，数量。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值