Scala--第二天

一、Scala中有方法和函数俩种技术

　　1.方法

　　　　　定义：def 方法名(参数名：参数类型，参数名：参数类型):[返回值类型] = {

　　　　　　　　　　方法体

　　　　　　　　}

　　　　　e.g：

 1     def test1(): Unit = {
 2       println("我是一个方法")
 3     }
 4     //return需要同返回值类型一起使用，不可独立存在
 5     def test2(x: Int, y: Int): Int = {
 6       return x + y
 7     }
 8     //返回值类型可以省略 ，Scala会根据方法体的最后一行内容进行类型推导
 9     def test3(x: Int, y: Int) = {
10       x + y
11     }
12     //方法中没有参数的话，在调用方法的时候，可以省略（）
13     test1
14     var a = test2(1, 2)
15     println(a)
16     print(test3(1, 5))
17     //    我是一个方法
18     //    3
19     //    6

　　　　方法的注意事项：

　　　　　　方法的返回值类型可以不写，Scala会根据方法体的最后一行做类型推导
　　　　　　return和返回值类型，同生共死
　　　　　　方法中有递归操作时，返回值的类型必须指定，不可以省略，负责报错

1   def foop(x:Int):Int={
2     if (x<=1){
3       return 1
4     }
5     return x*foop(x-1)
6   }
7     print(foop(3))
8 //    6

　　　　方法的参数种类

　　　　1.默认参数

1     def test1(x: Int = 0):Int = {
2       return x
3     }
4     //这个括号不可省略，即使参数有默认值，但是方法依然有参数
5     println(test1())
6     println(test1(3))
7 ###结果
8 0
9 3

　　　　2.带名参数

1     def test2(x:Int=1,y:Int=2):Int={
2       return x+y
3     }
4     println(test2(x=3))
5     println(test2(x=3,y=3))
6 ###结果
7 5
8 6

　　　　3.变长参数：当一个方法的参数不可定，可以把其参数定义为变长参数

 1     def test3(x: Int, num: Int*): Int = {
 2       //查看num的类型
 3       println(num.getClass)
 4      //使用数组的方法sum求和
 5       return num.sum + x
 6     }
 7 
 8     println(test3(1, 2, 3, 4))
 9 
10 ###即使有默认参数，Scala依然会给其分配一个值，以防止变长参数收集参数的错误
11     def test4(y: Int = 1, num: Int*) = {
12       num
13     }
14 
15     println(test4(2, 3, 4))
16   }
17 ###结果
18 class scala.collection.mutable.WrappedArray$ofInt
19 10
20 WrappedArray(3, 4)

　　　　方法的调用

　　　　1.后缀调用

　　　　2.中缀调用

　　　　3.花括号调用

　　　　4.无括号调用

 1     //后缀调用
 2     var a = Math.abs(-1)
 3     println(a)
 4     //中缀调用 多个参数的话可以用()括起来
 5     var b=Math abs -1
 6     println(b)
 7 ###结果
 8 1
 9 1
10     //to方法也是
11     println(1 to 10)
12     println(1.to(10))
13 ###结果
14 Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
15 Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
16     //花括号调用 语句块中的返回值即为参数，必须是一个
17     var c=Math.abs{
18       println("我是第三种方式")
19       -1
20     }
21     println(c)
22 ###结果
23 我是第三种方式
24 1
25     //无括号调用，方法中没有参数，前面的数组求和就是，这里不举例

　　2.函数

　　Scala支持函数式编程，spark等大数据框架有很多的函数式编程

　　定义：

　　　　val 函数名 = (参数名：参数类型，...) =>{

　　　　　　函数体

　　　　}

 1     val fun1 = (x: Int, y: Int) => {
 2       x + y
 3     }
 4     println(fun1(1, 2))
 5     val fun2 = () => println("无参形式")
 6     fun2()
 7   }
 8 ###结果
 9 3
10 无参形式

　　函数的特点

　　函数本身是一个独立的对象
　　类似于方法有返回值，有参数
　　定义函数时，不用def关键字
　　无需指定返回值类型，也就不可以用return

　　3.方法与函数的区别

　　方法是面向对象的概念，隶属于对象或类，不独立存在
　　函数本身就是一个对象，继承自Function 的父类，有其apply，tuple等方法

　　4.方法转换为函数

1     def test1(x: Int): String = {
2       return s"我是一个方法${x}"
3     }
4     //方法转函数 格式  在方法的后面+一个空格+_
5     var a = test1 _
6     var b = a(2)
7     println(b)
8 ###结果
9 我是一个方法2

　　注意：方法可以转换成一个函数，但是函数不可以转换成一个方法，因为函数本身就是一个对象

二、数组

　　1.定义：是一个可以存储相同数据类型的容器

　　2.分类：①定长数组：开辟的内存空间不可变；存储的内容可变

　　　　　　②变长数组：数组的长度可变，可以对数组进行添加和删除空间操作

　　3.定长数组

 1     //方式一 比较常用
 2     var a=Array(1,2,3)
 3     //用数组名(index)方式方位数组的元素，也可以赋值
 4     a(0)=2
 5     println(a.toBuffer)
 6 ###结果
 7     //    ArrayBuffer(2, 2, 3)
 8     //方式二 带new关键字
 9     var b=new Array[Int](4)
10     b(0)=2
11     //查看数组元素，与数组长度
12     println(b.toBuffer)
13     println(b.length)
14     //不带new关键字
15     var c= Array[Int](4)
16     c(0)=2
17     println(c.toBuffer)
18     println(c.length)
19 ###结果
20 //    ArrayBuffer(2, 0, 0, 0)
21 //    4
22 //    ArrayBuffer(2)
23 //    1

　　4.变长数组

 1import scala.collection.mutable.ArrayBuffer

//方式一：这种方法只能创建一个初始长度为0的可变长数组 后续通过 += 操作可以进行追加

 2   var a=ArrayBuffer[Int]()

 3     a+=1
 4     a+=1
 5     a+=1
 6     println(a.length)
 7     println(a.toBuffer)、
 8 ###结果
 9 3
10 ArrayBuffer(1, 1, 1)
11 
12   //方式二：简单，而且常用，依旧使用 += 进行追加
13   var b=ArrayBuffer(1,2,3)
14     b+=4
15     println(b.length)
16     println(b.toBuffer)
17 ###结果
18 4
19 ArrayBuffer(1, 2, 3, 4)

　　数组的操作

　　使用 += 添加元素在数组末尾添加
　　使用 -= 删除元素等号后面跟的是要删除的元素
　　使用 ++= 追加一个数组（定长或变长均可）到一个变长数组，只有变长数组才有这个操作

1  var b=ArrayBuffer(1,2,3)
2     b+=4
3     var a =Array(1,2,3)
4     var c = b++=a
5     println(c.toBuffer)
6 ###结果
7 ArrayBuffer(1, 2, 3, 4, 1, 2, 3)

　　数组的遍历

 1     var b=ArrayBuffer(1,2,3)
 2     b+=4
 3     //方式一：for遍历
 4     for (i<-b)println(i)
 5     println("-------------")
 6     //方式二：使用下标遍历
 7     for(i<- 0 until b.length)println(b(i))
 8 ###结果
 9 1
10 2
11 3
12 4
13 -------------
14 1
15 2
16 3
17 4

　　数组的一些相关操作

 1 数组的拷贝
 2      var a = Array(1, 2, 3, 4)
 3     //b是一个空的数组
 4     var b = new Array[Int](3)
 5     //参数一 目标数组，参数二 目标数组开始索引，参数三 原数组 的copy个数
 6     a.copyToArray(b, 0, 3)
 7     for (i <- b) println(i)
 8 ###结果
 9     //    1
10     //    2
11     //    3

 1     //将数组变成字符串
 2     var a = Array(1, 2, 3, 4)
 3     //使用"-"符号进行拼接
 4     var b = a.mkString("-")
 5     println(b)
 6 //    1-2-3-4
 7     //数组怕排序，默认升序，可以在进行反转得到降序结果
 8     var c =Array(5,4,8,6)
 9     var d=c.sorted
10     println(d.toBuffer)
11 //    ArrayBuffer(4, 5, 6, 8)
12     println(d.reverse.toBuffer)
13 //    ArrayBuffer(8, 6, 5, 4)

　　其他常见的方法

数组的长度
a.length
数组内容求和
a.sum
数组的最大值
a.max
数组的最小值
a.min
第一个数据
a.head
除掉第一个元素后面的数据
a.tial

三、元组

　　1.三要素

　　　　Scala 中的元组数据不要求同类型
　　　　元组的数据内容，不可变
　　　　Scala元组的个数是22个
用于网路进程见的数据传输

　　2.定义格式

 1     //方式一：简单常用 格式：var/val 元组 = （元素1，元素2，元素3）//最多能够容纳22元素
 2     var a = (1, "sss", 3)
 3     println(a.getClass)
 4     println(a)
 5     //class scala.Tuple3
 6     //(1,sss,3)
 7     //方式二：var/val 元组 = 元素1 -> 元素2 这种定义方式 元组中 只能有2个元素
 8     var b = 1 -> 2->3
 9     println(b)
10     //((1,2),3)

　　3.下标访问

1     //下标访问元组 元组的索引用 1 开始
2     var a = (1, "sss", 3)
3     println(a._1)
4     println(a._2)
5     //1
6     //sss