Scala--第二天

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

　　1.方法

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

　　　　　　　　　　方法体

　　　　　　　　}

　　　　　e.g：

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

　　　　方法的注意事项：

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

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

　　　　方法的参数种类

　　　　1.默认参数

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

　　　　2.带名参数

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

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

    def test3(x: Int, num: Int*): Int = {
      //查看num的类型
      println(num.getClass)
     //使用数组的方法sum求和
      return num.sum + x
    }

    println(test3(1, 2, 3, 4))

###即使有默认参数，Scala依然会给其分配一个值，以防止变长参数收集参数的错误
    def test4(y: Int = 1, num: Int*) = {
      num
    }

    println(test4(2, 3, 4))
  }
###结果
class scala.collection.mutable.WrappedArray$ofInt
10
WrappedArray(3, 4)         

　　　　方法的调用

　　　　1.后缀调用

　　　　2.中缀调用

　　　　3.花括号调用

　　　　4.无括号调用

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

　　2.函数

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

　　定义：

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

　　　　　　函数体

　　　　}

    val fun1 = (x: Int, y: Int) => {
      x + y
    }
    println(fun1(1, 2))
    val fun2 = () => println("无参形式")
    fun2()
  }
###结果
3
无参形式

　　函数的特点

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

　　3.方法与函数的区别

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

　　4.方法转换为函数

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

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

 二、数组

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

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

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

　　3.定长数组

    //方式一 比较常用
    var a=Array(1,2,3)
    //用数组名(index)方式方位数组的元素，也可以赋值
    a(0)=2
    println(a.toBuffer)
###结果
    //    ArrayBuffer(2, 2, 3)
    //方式二 带new关键字
    var b=new Array[Int](4)
    b(0)=2
    //查看数组元素，与数组长度
    println(b.toBuffer)
    println(b.length)
    //不带new关键字
    var c= Array[Int](4)
    c(0)=2
    println(c.toBuffer)
    println(c.length)
###结果
//    ArrayBuffer(2, 0, 0, 0)
//    4
//    ArrayBuffer(2)
//    1

　　4.变长数组

import scala.collection.mutable.ArrayBuffer

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

  var a=ArrayBuffer[Int]()

    a+=1
    a+=1
    a+=1
    println(a.length)
    println(a.toBuffer)、
###结果
3
ArrayBuffer(1, 1, 1)

  //方式二：简单，而且常用，依旧使用 += 进行追加
  var b=ArrayBuffer(1,2,3)
    b+=4
    println(b.length)
    println(b.toBuffer)
###结果
4
ArrayBuffer(1, 2, 3, 4)

　　数组的操作

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

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

　　数组的遍历

    var b=ArrayBuffer(1,2,3)
    b+=4
    //方式一：for遍历
    for (i<-b)println(i)
    println("-------------")
    //方式二：使用下标遍历
    for(i<- 0 until b.length)println(b(i))
###结果
1
2
3
4
-------------
1
2
3
4

　　数组的一些相关操作

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

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

　　其他常见的方法

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

三、元组

　　1.三要素

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

　　2.定义格式

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

　　3.下标访问

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