-
5.1 Scala概述
-
5.1.2 Windows环境下安装Scala
-
5.1.1 Scala特性
-
1.面向对象
-
2.函数式编程
-
3.扩展性
-
4.并发性
-
5.可以和Java混编
-
-
5.2 Scala基础语法
-
1.声明常量和变量
-
(1)声明常量
-
val 常量名：数据类型=初始值
-
val a:int =1或val a = 1
-
-
(2)声明变量
-
var 变量名：数据类型=初始值
-
注：
-
支持同时声明多个变量如var a,b = 1
-
可以重复使用同一变量名定义变量,解释器以最新定义为准
-
声明变量需要初始化,否则报错
-
(优先使用常量,除非确实需要修改)
-
-
-
-
2.输出值的方式
-
(1)直接调用变量名
-
(2)借助输出函数
-
差值字符串
-
字符串前加“s”或“f”
-
加s：不支持格式化
-
${varName}
-
-
加f：支持在$变量后指定格式化参数
-
$varNum%.2f (保留小数点两位)
-
-
-
${varName}插入变量名
-
-
1.print()函数结合加号对多个内容进行连接并输出
-
2.println()函数输出结束后自动换行
-
3.printf()函数格式化输出
-
-
-
3.数据类型 (首字母大写)
-
9种基本数据类型：String位于java.lang包,其余位于Scala包
-
Any是所有其他类型的超类(父类)
-
Nothing是任何其他类型的子类
-
Unit无返回值
-
String对象
-
字符串对象用双引号
-
常用方法
-
(1)String concat(String str)方法
-
将指定字符串连接到此字符串的结尾
-
"ABC",concat("DEF")
-
-
(2)Boolean endsWith(String sufix)方法
-
测试字符串是否以指定的后缀结束
-
"ABC". endsWith("C")
-
-
(3)Int length()方法
-
返回字符串的长度
-
"ScalaPythonJava".length()
-
res: Int = 15
-
-
-
(4)Boolean matches(String regex)方法
-
判断字符串是否匹配给定的正则表达式
-
"ScalaPythonJava".matches(".*Python.*")
-
res: Boolean = true
-
-
-
(5)String replace(char oldChar, char newChar)方法
-
返回一个新的字符串,newChar 字符串替换原字符串中出现的oldChar字符串得到
-
"I love Python".replace("Python","Scala")
-
res: String = I love Scala
-
-
-
(6)String replaceAll(String regex, String replacement)方法
-
使用给定的replacement字符串替换字符串中所有与给定的正则表达式相匹配的子字符串
-
"ab123sdab4543das756as876asd".replaceAll("\\d+","#num#")
-
res: String =abfnumtsdabfnumidastnumfasfnumfasd
-
-
(7)String replaceFirst(String regex,String replacement)方法
-
使用给定的replacement字符串替换字符串中与给定的正则表达式相匹配的第一个子字符串
-
-
(8)String[] split(String regex)方法
-
按正则表达式匹配的子字符串拆分字符串。
-
String[]表示split(String regex)执行结束后的返回值是字符串数组
-
"I love Python".split("")
-
res: Array[String]= Array(I, love, Python)
-
-
-
(9)Char[] toCharArray()方法
-
将字符串转换为一个字符数组
-
"Scala".toCharArray()
-
res: Array[Char] = Array(S, c, a, l, a)
-
-
-
(10)String toLowerCase()方法
-
将字符串中的所有字符都转换为小写
-
-
(11)String trim()方法
-
删除字符串的首尾空白符
-
-
(12)String take(num)方法
-
获取字符串前num个字符
-
//获取"hello"前两个字符 "hello".take(2)
-
res: String = he
-
-
-
(13)reverse属性
-
反转字符串
-
-
-
-
-
4.运算符
-
算术运算符
-
+、-、*、/、%(取余)
-
-
关系运算符(比较运算符)
-
==,!=,＞,＜,≥,≤
-
-
逻辑运算符
-
&&与(都满足),‖或(一个满足), !非
-
-
赋值运算符
-
=,+=,-=,*=,/=,%=
-
-
-
-
5.3 Scala控制结构
-
1.条件表达式
-
val s = if(x ＞0)1 else 0
-
-
2.if...else选择结构
-
单分支,双分支,多分支
-
-
3.编写和运行Scala脚本
-
一起执行的Scala语句序列放在同一文件,称为脚本
-
执行scala test.scala
-
-
4.循环结构
-
while,do while,for
-
for没有直接对应结构
-
(1)for(x<-Range)
-
Range 可以是一个数字区间,如
-
i to j表示的区间是[i,j]
-
i until j表示的区间是[i,j)
-
-
-
(2)for 循环可用分号隔开多个区间
-
可以迭代多个区间的所有可能值
-
for( a <- 1 to 2;b <-1 to 2) println( "a:"+a+"b:"+b)
-
-
(3)for 循环中使用数组、列表和集合
-
for 循环中使用列表 val list1=List(3,5,2,1,7)//创建列表 listl: List[Int] = List(3,5,2,1,7) for(x <- list1) print(""+x) 3 5 2 1 7
-
-
(4)for 循环中使用过滤器
-
for(x <- list1 if x%2==1) print(""+x) 3 5 1 7
-
-
-
-
-
5.4 数组
-
1.定长数组 使用()访问数组元素而不是[]
-
var z:Array[String] = new Array[String](3)
-
var z = new Array[String](3)
-
-
2.变长数组
-
1、ArrayBuffer创建变长数组
-
import scala.collection.mutable.ArrayBuffer
-
val arr1 = ArrayBuffer[Int]()//定义一个Int类型、长度为0的变长数组
-
-
2.追加、修改、删除变长数组的元素
-
val bigData = ArrayBuffer("Hadoop","Storm")//创建变长数组
-
(1)“+=”追加一个元素
-
bigData += "Spark"
-
-
(2)“++=”追加一个数组的元素
-
bigData ++= Array("Hbase","Graphx")
-
-
(3)“-=”删除元素
-
bigData -= "Graphx"
-
-
(4)“--=”删除在指定数组中出现的元素
-
bigData --= Array("Spark","Graphx")
-
-
(5)remove()方法删除指定位置的元素
-
调用变长数组对象的removeo方法从指定索引开始移除指定数量的元素。
-
bigData.remove(1,2)//从索引1处开始移除2个元素
-
-
(6)insert()方法在指定位置前插入元素
-
bigData.insert(0,"Spark")//在索引 0前插入元素"Spark"
-
定长数组和变长数组之间转换,调用toBuffer()和toArray()方法。
-
-
-
-
3.遍历数组
-
1.for 循环和until遍历数组
-
for(i <- 0 until a.length)
-
△注意：变量i的取值从0到a.length-1。
-
-
2.直接遍历数组元组
-
for(e <- b)
-
△注意：变量e先被设为b(0),然后被设为b(1),以此类推。
-
-
-
4.数组转换
-
按某种方式将一个数组转换为一个全新的数组,而原数组不变。
-
创建一个新数组 val a=Array(1,2,3,4)
-
1.for(...) yield
-
val result = for(elem <- a) yield 2 * elem
-
result: Array[Int] = Array(2, 4, 6, 8)
-
-
result中的值由yield之后的表达式2*elem产生,每次迭代为result产生一个值。
-
-
2.数组对象的map()方法
-
val result2 = a.map{3 * _}
-
result2: ArraylInt] = Array(3,6, 9,12)
-
-
-
3.数组对象的filter()和map()方法
-
val result3 = a.filter(_ % 2 == 0).map {2 * _}
-
result3: Array[Int] = Array(4, 8)
-
-
-
可以添加语句处理那些满足特定条件的元素。
-
-
-
5.数组对象的操作方法
-
1.map()方法映射数组 var arr = Array(1,2,3,4)
-
通过一个函数改变数组中的每个元素
-
arr.map(x => x* 5)
-
res: Array[Int] = Array(5, 10, 15, 20)
-
-
△注意：x=>x*5这种表达式称为Lambda表达式,用来创建临时使用的匿名函数。
-
Lambda 表达式的语法格式如下： (参数1,参数2,…)=>表达式
-
-
-
2.foreach()方法遍历数组中的元素
-
和map()方法类似,但是foreach()没有返回值。
-
-
3.min、max、sum分别输出数组的最小元素、最大元素、数组元素和
-
4.head、tail分别查看数组的第一个元素、除第一个元素外的其他元素
-
5.sorted、sortBy()、sortWith()排序
-
(1)sorted
-
sorted默认为升序排列,降序排列则需要反转。
-
arr.sorted//升序
-
arr.sorted.reverse//降序
-
-
(2)sortBy()
-
需要参数,表明进行排序的数组元素的形式。
-
arr.sortBy(x=>x)//升序
-
arr,sortBy(x =>-x)//降序
-
-
(3)sortWith() var arr = Array("a","d","F","B","e")
-
sortWith((String,String)=>Boolean) 需要匿名函数来说明排序规则,要有两个参数进行比较。
-
arr.sortWith((x:String, y:String) => x<y)
-
arr.sortWith((x,y) => x<y)
-
-
-
6.filter()方法进行过滤
-
filter()方法移除传入函数的返回值为 false的数组元素。
-
过滤掉数组 arr中奇数,得到只含偶数的数组。arr.filter(x=>x%2==0)
-
-
7.flatten扁平化操作 val arr = Array(Array(1,2),Array(3,4))//二维数组
-
把嵌套的结构展开,二维数组展开成一维数组。
-
arr.flatten
-
res: Array(Int) = Array(1, 2, 3,4)
-
-
-
8.flatMap 操作
-
结合map()和 fatten功能,相当于先进行map()操作再进行flatten操作,接收一个可以处理嵌套数组的函数,把返回结果连接起来。
-
arr.flatMap(x=> x.map(_*10))
-
res: Array[Int] = Array(10, 20, 30,40)
-
-
-
9.显示数组内容
-
mkString()方法显示数组的内容,允许指定元素之间的分隔符,该方法的另一个重载版本可以指定元素的前缀和后缀。
-
to*方法(*为数据类型名)
-
数据类型转换
-
-
-
-
-
5.5 列表
-
1.不可变列表
-
与数组的比较
-
(List声明)类似于数组,所有元素都具有相同的数据类型。
-
与数组不同的是,不可变列表的元素是不可变的,不可变列表的元素值一旦被觉了就不能改变。
-
-
1.创建不可变列表
-
val course: List[String] = List("Scala", "Python")
-
course: List[String] = List(Scala, Python)
-
-
//创建二维列表 val dim: List[List[Int]]= List(List(1,0),List(0,1)
-
dim: List[List[Int]] = List(List(1, 0), List(0, 1))
-
-
不可变列表具有递归的结构 (也即链接表结构) 数组不具有。即不变列表
-
要么是Nil(即空列表)
-
要么是一个head元素加上一个tail, 而tail又是一个列表
-
val nums：List[Int] = List(1,2,3,4)
-
nums: List[Int] = List(1, 2, 3, 4)
-
-
nums.head
-
res: Int = 1
-
-
nums.tail
-
res: List[Int] = List(2, 3,4)
-
-
-
-
(1)创建空列表
-
val L = Ni1
-
val L2 = List()
-
-
(2)“::”创建列表
-
“::”根据给定的head 和tail 创建一个新的列表。
-
△注意:“::”右结合,即从末端开始创建列表。
-
val newList=1::List(3, 5)
-
newList: List[Int] = List(1, 3, 5)
-
-
-
(3)“:::”连接列表创建新列表
-
val L4 = L3 ::: List("Hadoop","Hbase")
-
L4: List[String] = List(Spark, Scala, Python, Hadoop, Hbase)
-
-
-
-
2.不可变列表的操作9个
-
head：返回列表的第一个元素。
-
tail：返回一个列表,含除了第一个元素之外的其他元素。
-
init：返回一个列表,含除了最后一个元素之外的其他元素。
-
reverse：用于将列表的元素顺序反转。
-
last：返回列表的最后一个元素。
-
length：返回列表的长度。
-
range：创建数值范围的列表。 List.range(from,until)
-
创建从from 到until(不包括 until)的所有数值的列表。
-
step值作为第3个参数
-
将产生从from到uni的间隔为step 的列表元素,step值可正可负。
-
List.range(1,9,2)
-
res: List[Int] = List(1, 3, 5, 7)
-
-
-
-
isEmpty：判断列表是否为空,在列表为空时返回true。
-
sorted：排序。
-
-
3.不可变列表对象的常用方法15个
-
val L5= List("Spark","Scala", "Python", "Hadoop","Hbase")
-
L5: List(String)= List(Spark, Scala, Python, Hadoop, Hbase)
-
(1)count(s => s.length==num)
-
统计列表中长度为num的字符串的个数
-
//对L5中长度为5的字符串进行计数 L5.count (s =>s.length == 5)
-
res0: Int = 3
-
-
-
(2)drop(num)
-
返回去掉列表开头num个元素的列表
-
L5.drop(2)
-
res1: List[String] = List (Python, Hadoop, Hbase)
-
-
-
(3)dropRight(num)
-
返回去掉列最后num个元素的列表
-
L5.dropRight(3)
-
res2: List[String] = List(Spark, Scala)
-
-
-
(4)exists(s => s=="***")
-
判断列表中是否有字符串的值为"***"
-
L5.exists(s => s=="Spark")
-
res3: Boolean = true
-
-
-
(5)forall(s => s.endsWith(“k”)
-
判断列表里的元素是否都以”k”结尾
-
L5.forall(s => s.endsWith("k"))
-
res4: Boolean = false
-
-
-
(6)foreach(s => println(s))
-
遍历输出列表元素
-
L5.foreach(s => print(s+" "))
-
Spark Scala Python Hadoop Hbase
-
-
-
(7)map(f)
-
通过给定的函数f将所有元素重新计算
-
//对L5的元素都拼接$,并返回一个新的列表 scala> L5.map(s => s + "$")
-
List[String] = List(Spark$, Scalas$, Python$, Hadoops$, Hbases$)
-
-
-
(8)mkString("-")
-
对列表的元素以"-"拼接并返回
-
L5.mkString("-")
-
res11: String-Spark-Scala-Python-Hadoop-Hbase
-
-
-
(9)filterNot(s => s.length==5)
-
返回列表中长度不为5的元素所组成的列表
-
L5.filterNot(s => s.length == 5)
-
res12: List[String] = List(Python, Hadoop)
-
-
-
(10)take(num)
-
从列表左边取num个元素组成一个新列表
-
L5.take(3)
-
res13: List[String]=List(Spark, Scala, Python)
-
-
-
(11)takeRight(num)
-
从列表右边取num个元素组成一个新列表
-
L5.takeRight(3)
-
res14: List(String) = List(Python, Hadoop, Hbase)
-
-
-
(12)sortBy(x => x),升序排列
-
sortBy(x => -x),降序排列
-
-
(13)sortWith(_<_),升序排列
-
sortWith(_>_),降序排列
-
-
(14)“:+”和“+:”
-
“:+”在末端添加元素以得到一个新列表
-
list2.:+(10)
-
res25:List[Int] = List(3, 5,2, 1, 7,10)
-
-
-
“+:”在首端添加元素以得到一个新列表
-
list2.+:(0)
-
res26: List(Int] = List(0, 3, 5,2, 1,7)
-
-
-
-
(15)toString()
-
将列表转换为字符串
-
List(1,2,3).tostring()
-
res27: String = List(1, 2,3)
-
-
-
-
2.可变列表 ListBufer声明
-
对于可变列表,既可以修改某个位置的元素值,也可以增加或删除列表元素。
-
1.创建可变列表
-
import scala.collection.mutable.ListBuffer
-
val LBl = ListBuffer(1,2,3,4,5,6)
-
-
2.可变列表的常用操作
-
(1)按值删除列表元素
-
-
-
-
5.6 集合
-
集合（使用Set声明）是没有重复元素的合集，所有的元素都是唯一的。 和列表不同，集合并不保留元素插入的顺序，默认情况下，集合是以哈希函数实现的。 集合的元素是根据hashCode方法进行组织的（Scala和Java一样，每个对象都有hashCode方法）。 Scala集合分为可变集合和不可变集合。默认使用不可变集合，如果使用可变集合，需导入scala.collection.mutable.Set包。
-
不可变集合
-
1.创建不可变集合
-
val immutableset =Set("Scala"，"Python"，“Java")//创建不可变集合
-
val bSet=Set.range(1,6)//使用数值范围创建集合
-
-
2.集合的基本操作
-
（1)head 返回集合的第一个元素
-
bSet.head
-
-
（2）tail 返回集合除了第1个元素之外的其他元素所组成的集合
-
bSet.tail
-
-
（3）使用“-+”运算符或Set.++0方法连接两个集合
-
var Set3= Setl ++ Set2 //使用“++”运算符来连接两个集合
-
println("Setl.++(Set2):”+ Set1.++(Set2))
-
-
（4）查找集合中最大、最小元素及对集合中的元素求和
-
numSet.min
-
numSet.max
-
numSet.sum
-
-
-
3.集合的常用方法
-
（1）filter输出不可变集合中符合指定条件的所有元素
-
numSetl.filter(_%2==1)//获取集合中的奇数 numSetl.filter(e=>e%2==0)//获取集合中的偶数
-
-
（2）使用map方法按给定的函数f将所有元素重新计算
-
val result=numSet1.map(*L0)
-
charset.map（_.toUpper)//将小写字符转化成大写字符
-
val charSet1=charSet.map(ch=>Set (ch，ch.toUpper)) //将小写字符转化成大写字符
-
-
（3）使用forall方法对集合里面的每个元素做判断
-
numSet1. forall(e=>e>100) //判断集合中的每个元素是否都大于100
-
-
（4）使用foreach方法对集合里面的每个元素做处理
-
numSet1.foreach (e=>print(e+" "))
-
-
（5）使用+(elem)方法为集合添加新元素elem并创建一个新的集合
-
set.+(4) //为集合添加新元素4并创建一个新的集合
-
-
（6）使用-(elem)方法移除集合的元素elem并创建一个新的集合
-
set.-(1) //移除集合中的元素1并创建一个新的集合
-
-
（7）使用groupBy方法对集合中的元素进行分组
-
groupBy0方法对集合中的元素进行分组，得到的结果是一个Map对象（映射对象)。
-
set1.groupBy(x=>x%2==0)
-
-
实现对 set1中的数字根据奇偶性进行分组，groupBy方法接收的参数是一个计算偶数的函数，得到的结果是一个包含两个键值对的Map对象，键为false 对应的值为奇数的集合，键为true对应的值为偶数的集合。
-
-
-
-
可变集合
-
import scala.collection.mutable.Set //导包
-
注意差别
-
对不可变集合进行操作，会产生一个新的集合，原来的集合并没有改变。
-
而对可变集合进行操作，改变的是该集合本身。
-
-
-
-
5.7 元组
-
用圆括号将多个元素括起来就构成一个元组（使用（Tuple声明），元素之间用逗号隔开，元素的类型可以不一样。 元组是不可变的，元组和数据库中记录的概念类似。
-
创建元组
-
val person=(1,"XiaoMing"，“男”，23，“高新区”）
-
//创建一个元组(1,"XiaoMing"“男",23,"高新区”)就是一个元组，在元组中定义了5个元素，对应的类型分别为Int、String、String、Int 和 String。
-
-
获取元组元素
-
//通过“.1”方法获取元组的第一个元素
-
△注意：元组的索引是从1开始的，而列表的索引是从0开始的。
-
-
通常，使用模式匹配获取元组的元素
-
val (first,secona,third, fourth,fifth)= person
-
将first 设为1，second设为"XiaoMing"，third设为"男”，fourth设为23，fifth设为“高新区”。
-
-
-
-
元组的常用操作
-
1.遍历元组
-
通过元组对象的productIterator 属性的foreach方法可以遍历输出元组的每个元素。
-
person.productIterator.foreach(i =>println("遍历输出元组元素："+ i))
-
-
2.元组转化为字符串
-
toString方法可以将元组转化为字符串。
-
person.toString()
-
res5:String =(1,XiaoMing，男，23，高新区)
-
-
-
3.交换元组中的元素
-
使用元组对象的swap方法可以交换长度为2的元组的两个元素。
-
tl.swap
-
-
4.将数组、列表等中的元组分成不同的组
-
调用数组、列表等对象的groupBy(f：(A)→K）方法
-
-
-
拉链操作
-
使用元组的原因之一是元组能把多个值绑在一起，以便它们能够被一起处理，这通常可以用zip操作（拉链操作）来完成。
-
△注意：用toMap方法可以将对偶数组的集合转换成映射。如果有一个键的集合，以及一个与之对应的值的集合，那么可以用拉链操作将它们组合成映射。
-
操作
-
val symbols = Array ("<","-",">")symbols:Array[String] = Array(<,-,>) val counts = Array(2,10,2)
-
counts: ArraylInt] = Array(2,10,2)
-
val pairs=symbols.zip(counts)//得到对偶数组，对偶是最简单的元组
-
pairs: Arrayl(String, Int)]=Array((<,2)，(-,10)，(>,2))
-
-
-
-
5.8 映射
-
在Scala中，映射（使用Map声明）是一系列键值对的集合，所有值都可以通过键获取，并且映射中的健都是唯一的。映射也叫哈希表。
-
映射有两种类型，即可变映射与不可变映射，默认创建的都是不可变映射，如果要创建可变映射，需要导scala.collection.mutable.Map包。
-
不可变映射
-
1.创建映射
-
（1）使用“->”方式创建
-
在a->b中，a是键，b是值。
-
可使用“（)”查找某个键对应的值，如果不包含指定的键，则会抛出异常。
-
-
（2）使用（k，v)方式创建
-
在（k，v）中，k是键（key），v是值（value）。
-
-
-
2.映射的基本操作
-
keys：返回映射所有的键。
-
values：返回映射所有的值。
-
isEmpty：在映射为空时返回true。
-
-
3.映射合并
-
使用“++”或Map.++（)方法可以备并两个映射，映射合并时会移除重复的键。
-
-
4.查看映射中是否存在指定的键
-
使用映射的contains方法可以查看映射中是否存在指定的键。
-
-
5.映射的常用方法
-
（1）使用get(key)方法可返回指定键对应的值
-
（2）使用“+”可以为映射添加一个或者多个元素，创建新映射
-
val result = NameGrades + ("TangLi"->86,"LiuQiang"->95) print(result) HashMap (Yangbi -> 88, LiuQiang -> 95, LiHua -> 89, LiuTao -> 91, Tangli ->86 val resultl = NameGrades - "Tangli" - "LiuQiang"
-
-
（3）使用“-”可以删除一个或者多个元素
-
（4）映射的遍历
-
① 使用for循环遍历所有的映射元素
-
for((k,v) <- NameGrades) println(s"key: $k, value: $v") key: LiHua, value: 89 key: LiuTao, value: 91 key: YangLi, value: 88
-
-
②使用foreach方法访问映射元素
-
NameGrades.foreach{case(k,v) => printf("Name is %s and Grade is %s\n",k,v)} Name is Lilua and Grade is 89 Name is LiuTao and Grade is 91 Name is Yangli and Grade is 88
-
-
③ 使用foreach方法访问映射元素
-
NameGrades. foreach（x => println(s"key: $(x._1)，value：$(x._2)")) key: Lilua, value: 89 key: Liutao,value: 91 key: Yangli,value: 88
-
-
-
-
-
可变映射
-
默认情况下使用Map创建的是不可变映射，不可变映射是无法更新元素的，也无法增加新的元素。如果想要更新映射的元素，就需要定义可变映射，需要导scala.collection mutable.Map包创建可变映射
-
1.添加、更新和删除元素
-
（1）通过给键指定值的方式为可变映射添加元素
-
scala> NameScores("MaMing")= 90
-
-
（2）用“+=”添加一个或者多个元素
-
scala> NameScores += （("WangLi",89)，("WangHua",86))
-
-
（3）用“++=”通过列表添加多个元素
-
scala> NameScores ++= List(("WangQiang",80)，("YuHong",90))
-
-
（4）用“-=”通过指定元素的键从映射中删除一个或者多个元素
-
scala> NameScores -= "Yangxue"
-
-
（5）用“--=”删除列表里指定的元素
-
scala> NameScores --= List("MaMing","LiLi")
-
-
-
2.映射的遍历
-
（1）用for循环遍历映射的元素
-
for((k,v) <- NameScores) println(s"key： $k， value： $v")
-
key: Wangii, value: 89
-
-
（2）用foreach方法遍历映射的元素
-
NameScores.foreach(x => println(s"key: ${x._1},value:${x. _2}"))
-
key: Wangti,value: 89
-
-
-
-
-
5.9 Scala函数
-
函数的定义
-
1.有返回值的函数的定义
-
（2）省略返回值类型和retum语句
-
当有返回值的时候，可以不显式地写出返回值类型，Scala会自动判断，同时return语句也可以省略。
-
Scala 自动返回函数体中最后一个表达式的值并判断其类型。在Scala中，赋值语句返回的是空值。
-
所以，如果想要返回值，不要以赋值语句作为最后一条语句。
-
-
（3）省略花括号
-
当函数体只有一行语句的时候，可以省略花括号
-
-
-
2.无返回值的函数的定义
-
（1）显式标识无返回值
-
Unit 关键字表示函数无返回值。
-
-
（2）省略Unit
-
这里可以省略Unit关键字，让Scala推断这个函数无返回值。那么Scala是怎么知道的呢？通过省略等号。当函数的定义中没有等号的时候，无论函数内部有没有返回值，Scala都认为这个函数无返回值。
-
-
-
3.函数的调用
-
Scala 提供了多种函数调用方式，以下是调用函数的标准格式。
-
functionName（参数列表）
-
-
-
匿名函数
-
使用箭头“=>”定义，箭头的左边是参数列表，箭头的右边是表达式，表达式的值即匿名函数的返回值。
-
-
高阶函数
-
高阶函数是指使用其他函数作为参数，或者返回一个函数作为结果的函数。
-
-
-
5.10 Scala模式匹配
-
Scala的模式匹配方式是match case。
-
类似于Java中的switchcase语法，即对一个值进行条件判断，然后针对不同的条件进行不同的处理。
-
但Scala的match case 语法的功能比Java的switch case 语法的功能要强大得多。Java的switch case 语法只能对值进行匹配，而Scala的matchcase语法除了可以对值进行匹配，还可以匹配类型、数组、列表、case class，甚至匹配是否有值。
-
match case的语法格式如下：
-
变量match{case值=>代码}
-
说明：如果值为“_”，则代表了不满足以上所有情况的默认情况如何处理；
-
在match case中，只要有一个case分支满足并处理了，就不会继续判断下一个case分支了，而Java的switch case 需要用break语句阻止。
-
matchcase最基本的应用，是对变量的值进行模式匹配。
-
-
-
1.匹配字符串
-
2.匹配数组、列表
-
匹配数组
-
匹配列表
-
-
3.匹配类型
-
-
5.11 Scala面向对象编程
-
类与对象
-
单例对象和伴生对象
-
-
5.12 Scala读写文件
-
读文件
-
写文件
-
-
扫一扫
1320
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
