scala方法和函数

-   

- 方法：由方法名、参数、方法体构成，一般指的是类中定义的函数即为方法

- 函数：由函数名、参数、函数体构成，一般指的是可以独立构建的称为函数

方法

def funcName(args1:Type1,args2:Type2……):ResultType = {
	//方法体
}
def m4(x:Int) = { if(x<= 1) 1 else m4(x-1)*x }

函数

函数的定义及语法规则
(参数) => {
	//函数体
}
(x:Int,y:Int) => { x + y }

高阶函数的功能及定义

定义：如果使用函数值作为参数，或者返回值为函数值的“函数”和“方法”，均称之为“高阶函数”。

- 如果一个函数/方法A，它的参数是一个函数B，称A为高阶函数

def f3(p:(Int,Int) => Int):Int = {    p(4,2)}
​val fa = (x:Int,y:Int) => x+y
val fb = (x:Int,y:Int) => x-y
val fc = (x:Int,y:Int) => x*y
val fd = (x:Int,y:Int) => x/y​f3(fa) 
--使用值函数作为参数​|​f3((x:Int,y:Int) => x+y)    
    --使用匿名函数作为参数

数组与集合的分类

  - 可变：mutable
    - 可变指的是元素的值或者长度是可变的
- 不可变：immutable
  - 不可变的指的是元素的值或者长度是不可变的
- 推荐使用不可变
  - 工作场景经常需要做可变的集合
  - 实现的时候
    - 初始化：构建一个可变的
    - 处理完成以后：转换为一个不可变的
    
 **实施**

ArrayBuffer与Array的区别

• Array：数组长度不可变，定长数组

• ArrayBuffer：数组长度可变，变长数组

  //用于指定数组长度，没有指定初始值，必须加new
  scala> val a1 = new Array[Int](5)
  a1: Array[Int] = Array(0, 0, 0, 0, 0)
  //指定了初始值可以不加new
  scala> val a2 = Array(1,2,3,4,5)
  a2: Array[Int] = Array(1, 2, 3, 4, 5)
  

增加 +=

scala> ab1 += 10
res13: ab1.type = ArrayBuffer(10)

scala> ab1 += 9
res14: ab1.type = ArrayBuffer(10, 9)

scala> ab1 += 7
res15: ab1.type = ArrayBuffer(10, 9, 7)

scala> ab1.append(8)

scala> ab1
res17: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 9, 7, 8)

scala> a1
res18: Array[Int] = Array(10, 0, 0, 0, 0)

取值

scala> for(x <- ab1) println(x)
10
8
7
8

删除：-= 、remove

//按照值进行剔除
scala> ab1 -= 8
res23: ab1.type = ArrayBuffer(10, 7, 8)

//按照下标剔除
scala> ab1.remove(1)
res24: Int = 7

scala> ab1
res25: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 8)

数组中的常用操作

排序

scala> ab2.sorted
res31: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 3, 5, 7, 10)

反转

  scala> ab2.sorted.reverse
  res32: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 7, 5, 3, 3, 2, 1)

求和

scala> ab2.sum
res33: Int = 31

求最值

scala> ab2.max
res34: Int = 10
scala> ab2.min
res35: Int = 1

转换为字符串：mkString

-scala> ab2.mkString
                       def mkString(sep: String): String                             
def mkString: String   def mkString(start: String,sep: String,end: String): String   

scala> ab2.mkString
res38: String = 12373510

scala> ab2.mkString("-")
res39: String = 1-2-3-7-3-5-10

scala> ab2.mkString(",")
res40: String = 1,2,3,7,3,5,10

scala> ab2.mkString("<",",",">")
res41: String = <1,2,3,7,3,5,10>

scala> ab2.mkString("<","-",">")
res42: String = <1-2-3-7-3-5-10>

列表List与ListBuffer

List与ListBuffer的区别

• List：不可变的集合，长度和元素值都不可变
• ListBuffer：可变的集合，长度和元素值都可变

List集合常用操作

取第一个元素

scala> list1.head
res64: Int = 1

取除了第一个元素以外的元素：tail

scala> list1.tail
res65: List[Int] = List(2, 3, 4, 5, 6, 6, 1, 2)

取前N个元素：take

scala> list1.take(3)
res66: List[Int] = List(1, 2, 3)

取除了前N个元素以外的所有元素：drop

scala> list1.drop(3)
res67: List[Int] = List(4, 5, 6, 6, 1, 2)

定义一个空list集合：Nil

scala> val list2 = Nil
list2: scala.collection.immutable.Nil.type = List()

集合头部添加元素返回新的集合：+：、:：

集合尾部添加元素返回新的集合：:+

拼接两个集合的元素返回新的集合：++、:::

扁平化操作：将两层集合转换为一层集合：flatten

scala> val list5 = List(List(1,2),List(3,4),List(5,6))
list5: List[List[Int]] = List(List(1, 2), List(3, 4), List(5, 6))

scala> for(x <- list5) println(x)
List(1, 2)
List(3, 4)
List(5, 6)

scala> list5.flat
flatMap   flatten

scala> list5.flatten
res78: List[Int] = List(1, 2, 3, 4, 5, 6)

拉链操作：zip、zipWithIndex

scala> val list6 = List(1,2,3,4)
list6: List[Int] = List(1, 2, 3, 4)

scala> val list7 = List("a","b","c","d")
list7: List[String] = List(a, b, c, d)

scala> list6.zip(list7)
res79: List[(Int, String)] = List((1,a), (2,b), (3,c), (4,d))

scala> list7.zipWithIndex
res80: List[(String, Int)] = List((a,0), (b,1), (c,2), (d,3))
一般用于将List集合转换为Map集合

拉开操作：unzip

scala> val list8 = list6.zip(list7)
list8: List[(Int, String)] = List((1,a), (2,b), (3,c), (4,d))

scala> list8.unzip
res81: (List[Int], List[String]) = (List(1, 2, 3, 4),List(a, b, c, d))

scala> val list9 = list8.unzip
list9: (List[Int], List[String]) = (List(1, 2, 3, 4),List(a, b, c, d))

scala> list9._1
res82: List[Int] = List(1, 2, 3, 4)

scala> list9._2
res83: List[String] = List(a, b, c, d)

并集：union

scala> list3.union(list4)
res86: List[Int] = List(1, 2, 3, 4, 3, 4, 5, 6)

交集：intersect

scala> list3.intersect(list4)
res87: List[Int] = List(3, 4)

差集：diff

scala> list3.diff(list4)
res88: List[Int] = List(1, 2)

scala> list4.diff(list3)
res89: List[Int] = List(5, 6)

Set

- Set集合的特点

  - 无序不重复集合，一般用于实现数据的去重功能

- 可变Set集合与不可变Set的区别

  - immutable.Set：不可变Set集合，长度不可变
  - mutable.Set：可变Set集合，长度可变

Map

Map集合的特点**

• 存储KeyValue格式数据的集合
• 作为大数据工程师：处理最多的数据结构类型：KV结构类型

可变Map与不可变Map的区别

• immutable.Map：不可变Map，不可添加、删除、更新元素
• mutable.Map：可变Map，可以添加、删除、更新元素

读取

scala> map1.getOrElse("name1","null")
res112: String = null

scala> map1.getOrElse("name","null")
res113: String = laoda

操作

添加：+=

scala> map3 += "addr" -> "shanghai"
res116: map3.type = Map(addr -> shanghai, age -> 22, name -> laoer, gender -> female)

更新：=

scala> map3("addr") = "beijing"

scala> map3
res120: scala.collection.mutable.Map[String,String] = Map(addr -> beijing, age -> 22, gender -> female)

删除：remove

scala> map3.remove("name")
res117: Option[String] = Some(laoer)

scala> map3
res118: scala.collection.mutable.Map[String,String] = Map(addr -> shanghai, age -> 22, gender -> female)

遍历

for(x <- map3) println(x)
for((key,value)<- map3) println(key+"\t"+value)
for(key <- map3.keys) println(map3(key))

元组

• 标**：掌握Scala中元组的使用

• 路径：什么是元组？元组的使用方式和场景？

  • 元组的功能和特点
  • 元组的定义
  • 元组的取值

• 实施

  • 元组的功能和特点

    • 功能：类似于数组，用于存储不同类型的元素的集合
    • 区别
      • 数组：数组中只能存储一种类型的元素
      • 元组：元组中可以存储不同类型的元素

  • 元组的语法

  •   - val/var tupleName = (元素1，元素2，元素3，元素4……)
    val/var tupleName = TupleN(元素1，元素2，元素3，元素4……元素N)
    
    例如
    scala> val tuple1 = (1,2,"itcast",14.9,true)
    tuple1: (Int, Int, String, Double, Boolean) = (1,2,itcast,14.9,true)
    
    scala> val tuple2 = new Tuple3(1,2,"heima")
    tuple2: (Int, Int, String) = (1,2,heima)
    

特殊：二元组就是KeyValue对

元组的取值*

- 通过tuple._N来引用元组中的元素（N从1开始）

- 举例
- scala> tuple1._1
res126: Int = 1

scala> tuple1._2
res127: Int = 2

scala> tuple1._3
res128: String = itcast

迭代器Iterator

- scala针对每一类集合都提供了一个迭代器（iterator）用来迭代访问集合

- 迭代器的两个基本方法

  - hasNext：查询容器中是否有下一个元素
  - next：返回迭代器的下一个元素，如果没有，抛出NoSuchElementException

- 举例
	-scala> val array = Array(1,2,3,4,5)
array: Array[Int] = Array(1, 2, 3, 4, 5)

scala> val itera = array.iterator
itera: Iterator[Int] = non-empty iterator

scala> while(itera.hasNext) println(itera.next)
1
2
3
4
5