Scala
11.方法定义
语法
def methodName (参数名:参数类型, 参数名:参数类型) : [return type] = {
// 方法体：一系列的代码
}
- scala定义方法可以省略返回值，由scala自动推断返回值类型。这样方法定义后更加简洁。
示例
定义递归方法（求阶乘）
参考代码
scala> def m2(x:Int) = {
| if(x<=1) 1
| else m2(x-1) * x
| }
<console>:13: error: recursive method m2 needs result type
else m2(x-1) * x
12.方法参数
- 默认参数
- 在定义方法时可以给参数定义一个默认值。
示例
- 定义一个计算两个值相加的方法，这两个值默认为0
- 调用该方法，不传任何参数
参考代码
// x，y带有默认值为0
def add(x:Int = 0, y:Int = 0) = x + y
add()
-
带名参数
- 在调用方法时，可以指定参数的名称来进行调用。
-
示例
- 定义一个计算两个值相加的方法，这两个值默认为0
- 调用该方法，只设置第一个参数的值
参考代码
def add(x:Int = 0, y:Int = 0) = x + y add(x=1) -
变长参数
-
语法格式：
def 方法名(参数名:参数类型*):返回值类型 = { 方法体 }参考代码
scala> def add(num:Int*) = num.sum add: (num: Int*)Int scala> add(1,2,3,4,5) res1: Int = 15
13.方法调用方式
在scala中，有以下几种方法调用方式，
- 后缀调用法
- 中缀调用法
- 花括号调用法
- 无括号调用法
后缀调用法
这种方法与Java没有区别。
语法
对象名.方法名(参数)
中缀调用法
语法
对象名 方法名 参数
例如：1 to 10
花括号调用法
语法
Math.abs{
// 表达式1
// 表达式2
}
无括号调用法
- 如果方法没有参数，可以省略方法名后面的括号
参考代码
def m3()=println("hello")
m3
14.函数
语法
val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体
示例
- 定义一个两个数值相加的函数
- 调用该函数
参考代码
scala> val add = (x:Int, y:Int) => x + y
add: (Int, Int) => Int = <function2>
scala> add(1,2)
res3: Int = 3
- 方法和函数的区别
- 方法是隶属于类或者对象的，在运行时，它是加载到JVM的方法区中
- 可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中
- 函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方法。方法则没有
scala-day01
- 实现正方形
***
***
***
scala> for(i <- 1 to 3){
| println("*"*3)}
scala> def zfx(n:Int)={
| for(i <- 1 to n){
| println("*"*n)}
| }
- 实现三角形
---*--- 3 1
--***-- 2 3
-*****- 1 5
******* 0 7
scala> for(i <- 1 to 4){
| println(" "*(4-i)+"*"*(2*i-1))}
scala> def sjx(n:Int)={
| for(i <- 1 to n){
| println(" "*(n-i)+"*"*(2*i-1))}
| }
- 宝塔
---*---
---*---
---*---
--***--
--***--
--***--
-*****-
-*****-
-*****-
*******
*******
*******
scala> for(i <- 1 to 4; j <- 1 to 3){
| println(" "*(4-i)+"*"*(2*i-1))}
scala> def bt(x:Int,y:Int)={
| for(i <- 1 to x;j <- 1 to y){
| println(" "*(x-i)+"*"*(2*i-1))}
| }
- breakable
breakabe{
}
for(){
breakable{
}
}
scala> breakable{
| for(i <- 1 to 100){
| breakable{
| if(i % 10 == 0) break()
| else println(i)}
| if(i > 50) break()}
| }
13.方法调用方式
在scala中，有以下几种方法调用方式
在scala里，所有的值类型，也都是对象。算数运算符是方法。
- 后缀调用法
- 中缀调用法
- 花括号调用法
- 无括号调用法
后缀调用法
这种方法与Java没有区别。
语法
对象名.方法名(参数)
中缀调用法
语法
对象名 方法名 参数
例如：1 to 10
花括号调用法
语法
Math.abs{
// 表达式1
// 表达式2
}
无括号调用法
- 如果方法没有参数，可以省略方法名后面的括号
参考代码
def m3()=println("hello")
m3
14.函数
scala是一个多范式的编程语言，既支持面向对象编程，又支持函数式编程。
语法
val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体
示例
- 定义一个两个数值相加的函数
- 调用该函数
参考代码
scala> val add = (x:Int, y:Int) => x + y
add: (Int, Int) => Int = <function2>
scala> add(1,2)
res3: Int = 3
-
方法和函数的区别
- 方法是隶属于类或者对象的，在运行时，它是加载到JVM的方法区中
- 可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中
- 函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方法。方法则没有
- 函数不能接受多参数（*），能转函数。
- 函数最多支持22个参数。所以函数不支持多参数*的方式 val f1 = (x:Int*) => x*10
val f1= (x7:Int,y8:Int,x1:Int,y2:Int,y3:Int,x4:Int,y5:Int,y6:Int,x9:Int,y10:Int,y11:Int,x12:Int,y13:Int,y14:Int,x15:Int,y16:Int,y17:Int,x18:Int,y19:Int,y20:Int,x21:Int,y22:Int)=>y2*1 -
数据结构
15.数组-定长数组
String[] str
Array[String]
- scala中数组的概念是和Java类似，可以用数组来存放一组数据。scala中，有两种数组，一种是定长数组，另一种是变长数组
- 定长数组
- 定长数组指的是数组的长度是不允许改变的
- 数组的元素是可以改变的
16.数组-变长数组
- 变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素
语法
-
创建空的ArrayBuffer变长数组，语法结构：
val/var a = ArrayBuffer[元素类型]() -
创建带有初始元素的ArrayBuffer
val/var a = ArrayBuffer(元素1，元素2，元素3....) -
数组的增删改查
scala> arr += ("wyf","yy") res39: arr.type = ArrayBuffer(tom, cxk, zjl, xg, wyf, yy) scala> arr += ("wyf","yy") res40: arr.type = ArrayBuffer(tom, cxk, zjl, xg, wyf, yy, wyf, yy) scala> arr -= "yy" res41: arr.type = ArrayBuffer(tom, cxk, zjl, xg, wyf, wyf, yy) scala> arr ++= Array("swk","ts") res42: arr.type = ArrayBuffer(tom, cxk, zjl, xg, wyf, wyf, yy, swk, ts) scala> arr -= ("zjl","cxk")
17.数组-遍历数组
参考代码1
scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> for(i<-a) println(i)
参考代码2
scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> for(i <- 0 to a.length - 1) println(a(i))
scala> for(i <- 0 until a.length) println(a(i))
18.数组-常用算法
scala中的数组封装了一些常用的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现。以下为常用的几个算法：
-
求和——sum方法
-
求最大值——max方法
-
求最小值——min方法
-
排序——sorted方法
19.元组(tuple)
- 元组可以用来包含一组不同类型的值。例如：姓名，年龄，性别，出生年月。元组的元素是不可变的。
语法
使用括号来定义元组
val/var 元组 = (元素1, 元素2, 元素3....)
使用箭头来定义元组（元组只有两个元素）
val/var 元组 = 元素1->元素2
- 使用_1、_2、_3…来访问元组中的元素，_1表示访问第一个元素，依次类推
scala> val (name,sex,age) = ("zs","nan",21)
- 在自己开发的过程中，一般都会使用可变的集合（arrayBuffer/ListBuffer…）
- 在调用一些api的时候，返回值类型不可变集合。
20.不可变列表 List
列表是scala中最重要的、也是最常用的数据结构。List具备以下性质：
-
可以保存重复的值
-
有先后顺序
-
不能修改里面的元素，大小不能变。
21.可变列表 LIstBuffer
可变列表就是列表的元素、长度都是可变的。
要使用可变列表，先要导入import scala.collection.mutable.ListBuffer
使用ListBuffer[元素类型]()创建空的可变列表，语法结构：
val/var 变量名 = ListBuffer[Int]()
使用ListBuffer(元素1, 元素2, 元素3…)创建可变列表，语法结构：
val/var 变量名 = ListBuffer(元素1，元素2，元素3...)
scala> l += (5,6)
res60: l.type = ListBuffer(1, 2, 3, 4, 5, 6)
scala> l
res61: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 5, 6)
scala> l -= (1,2,3,23)
res62: l.type = ListBuffer(4, 5, 6)
22.列表常用操作一
-
判断列表是否为空（ isEmpty ）
-
拼接两个列表（ ++ ）
-
获取列表的首个元素（ head ）和剩余部分( tail )
-
反转列表（ reverse ）
-
获取前缀（ take ）、获取后缀（ drop ）
-
扁平化（ flatten ）
-
拉链（ zip ）和拉开（ unzip ）
scala> val personAndAge = name.zip(age) personAndAge: List[(String, Int)] = List((swk,500), (zbj,600), (xbl,200)) scala> personAndAge.unzip unzip unzip3 scala> personAndAge.unzip res91: (List[String], List[Int]) = (List(swk, zbj, xbl),List(500, 600, 200)) scala> val res = personAndAge.unzip res: (List[String], List[Int]) = (List(swk, zbj, xbl),List(500, 600, 200)) scala> res._1 res92: List[String] = List(swk, zbj, xbl) scala> res._2 res93: List[Int] = List(500, 600, 200) scala> val (name1,age1) = personAndAge.unzip name1: List[String] = List(swk, zbj, xbl) age1: List[Int] = List(500, 600, 200)
23.列表常用操作二
-
转换字符串（ toString ）
-
生成字符串（ mkString ）
scala> l.mkString("|") res98: String = 1|2|3|4 scala> l.mkString("[","|","]") res99: String = [1|2|3|4] -
并集（ union ）
-
交集（ intersect ）
-
差集（ diff ）
24.不可变集
-
val a = Set(1,1,2,3,4,5)
-
获取集的大小（ size ）
遍历集（ 和遍历数组一致 ）
添加一个元素，生成一个Set（ + ）
拼接两个集，生成一个Set（ ++ ）
拼接集和列表，生成一个Set（ ++ ）
25.可变集
- import scala.collection.mutable.Set
-
- 定义一个可变集，包含以下元素: 1,2,3, 4
- 添加元素5到可变集中
- 从可变集中移除元素1
26.映射（Map）
-
Map可以称之为映射。它是由键值对组成的集合。在scala中，Map也分为不可变Map和可变
Map。
-
不可变map
-
定义语法
val/var map = Map(键->值, 键->值, 键->值…) // 推荐，可读性更好
val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)…)
-
增删改查操作
-
可变的map
-
import scala.collection.mutable.Map
scala> map.get("name")
res102: Option[Any] = Some(zbj)
scala> map.get("sex")
res103: Option[Any] = None
scala> for((x,y) <- map) println(s"$x $y")
map.getOrElse("wangwu", -1)
27.iterator迭代器
- 先定义一个list集合
- val iter = list.iterator
- while（iter.hasNext）{ println(iter.next) }
- for(i <- iter) println(i)
28.函数式编程-foreach方法 算子RDD
-
val a = List(1,2,3,4)
-
a.foreach((x:Int)=>println(x))
a.foreach(x=>println(x))
a.foreach(println(_))
a.foreach(println)
scala> def m1(f1:(Int,Int)=>Int)={
| val res = f1(2,3)
| println(res)}
m1: (f1: (Int, Int) => Int)Unit
scala> val f = (x:Int,y:Int) => x+y
f: (Int, Int) => Int = <function2>
scala> m1(f)
5
scala> def m2(x:Int,y:Int,f2:(Int,Int)=>Int)={
| val res = f2(x,y)
| println("answer is :"+res)}
m2: (x: Int, y: Int, f2: (Int, Int) => Int)Unit
scala> m2(5,6,f)
answer is :11
29.函数式编程 -map方法
- List(1,2,3,4).map(x=>x+1)
- List(1,2,3,4).map(_ + 1)
scala> l.map(x => (x*10).toString)
res113: List[String] = List(10, 20, 30)
30.函数式编程-flatMap方法
-
理解为先map，然后再flatten
-
val a = List(“hadoop hive spark flink flume”, “kudu hbase sqoop storm”)
-
a.flatMap(_.split(" "))
31.函数式编程-filter方法
- 过滤出所有的偶数
- List(1,2,3,4,5,6,7,8,9).filter(_ % 2 == 0)
32.函数式编程-排序
-
sorted 、sortBy、sortWith
-
对列表升序排序
-
List(3,1,2,9,7).sorted
scala> val l = List(1,7,5,6,3,4) l: List[Int] = List(1, 7, 5, 6, 3, 4) scala> l.sorted res119: List[Int] = List(1, 3, 4, 5, 6, 7) scala> l.sorted.reverse res120: List[Int] = List(7, 6, 5, 4, 3, 1) scala> val l2 = List(("zs",20),("ls",11),("ww",13)) l2: List[(String, Int)] = List((zs,20), (ls,11), (ww,13)) scala> l2.sortBy(_._2) res121: List[(String, Int)] = List((ls,11), (ww,13), (zs,20)) scala> l2.sortBy(_._2).reverse res122: List[(String, Int)] = List((zs,20), (ww,13), (ls,11)) scala> l.sortBy(x => x) res123: List[Int] = List(1, 3, 4, 5, 6, 7) scala> l.sortWith((x,y) => x < y) res127: List[Int] = List(1, 3, 4, 5, 6, 7) scala> l.sortWith((x,y) => x > y) res128: List[Int] = List(7, 6, 5, 4, 3, 1) scala> l.sortWith(_ > _) res129: List[Int] = List(7, 6, 5, 4, 3, 1)
33.函数式编程-groupBy
- List((“男” -> 2), (“女” -> 1)) .groupBy(_._2)
34.函数式编程-reduce、fold
-
聚合操作，可以将一个列表中的数据合并为一个。
-
使用reduce计算List所有元素的和
- List(1,2,3,4,5,6,7,8,9,10) .reduce((x,y) => x + y)
-
fold与reduce很像，但是多了一个指定初始值参数
- fold和foldLet效果一致，表示从左往右计算
- List(1,2,3,4,5,6,7,8,9,10) .fold(0)(_ + _)
- foldRight表示从右往左计算
- fold和foldLet效果一致，表示从左往右计算
272
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
