scala 基础(2) -------------------------方法、函数、数组、集合、元组

---

                                        方法和函数

scala面向函数式编程（最有特色的一部分）-》将函数作为函数的参数传递过去
    （*）方法和函数的区别
        1.方法：
            相对于OOP来说
            类class
                属性：名词
                方法：动词，如一个函数在类中，则该函数为方法
        2.函数：
            不在类中的方法，称此方法为函数
            将函数作为函数的参数传递过去
        3.OOP编程中
            比如JAVA语言来说，方法必须在类中，不能脱离class独立存在
            但是FP（函数式编程）中， 函数可以独立存在，不需要依赖类class
        4.SCALA语言，既可以面向对象编程，又可以面向函数式编程，所以类和函数，对象都是“一等公民”，地位相同，都可以独立存在，不需要依赖任何类和对象

    （*）如何表示一个方法：
        def m(x:Int, y:Int): Int
            - def：声明一个方法
            - m：方法名（如果没有方法名，那么这个方法是匿名方法）
            - (x:Int, y:Int)：左边的参数（指明了参数的个数和类型）
            - : Int：函数的返回值（返回值类型）

    （*）定义一个方法
        //def：定义方法使用def关键字
        //m: 方法名
        //x,y参数列表
        //Unit:方法返回值类型。Unit表示无返回值，类似于JAVA的void
        //x+y 方法体
        scala> def m(x:Int, y:Int):Unit = x+y
        m: (x: Int, y: Int)Unit

        //如果不指名返回值类型，则根据方法体进行自动推导
        scala> def m2(x:Int, y:Int) = { x + y }
        m2: (x: Int, y: Int)Int

        //无返回值
        scala> def m3(x:Int, y:Int) = { println("") }
        m3: (x: Int, y: Int)Unit

        //如果显式指定返回值类型，若无返回值，则报错
        scala> def m4(x:Int, y:Int):Int = { println("") }
        <console>:11: error: type mismatch;
         found   : Unit
         required: Int
               def m4(x:Int, y:Int):Int = { println("") }

        //不传递参数
        scala> def m5() = println(100)
        m5: ()Unit

        //scala中，若无参数传递，则可以不加()
        scala> m5
        100

        //定义的时候，若不需要传递参数，则不需要加()
        scala> def m6 = print(100)
        m6: Unit

        //若定义的时候不加(), 调用时也不能加()
        scala> m6()
        <console>:13: error: Unit does not take parameters
               m6()
                 ^
    注意：方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归方法，必须指定返回类型
    （*）如何定义一个函数
        #val: 定义一个函数
        #=>： 函数里面使用=>
        #省略返回值
        #func: 函数名称
        #(Int, Int) ：函数参数列表
        #=> Int：函数返回值
        #<function2>：函数参数个数， 最多只能有22个，如果想使用更多的参数，使用变长参数
        scala> val func = (x: Int, y:Int) => x*y （）
        func: (Int, Int) => Int = <function2>

        #不指名函数名称，则称为匿名函数
        scala> (x:Int) => x*2
        res7: Int => Int = <function1>

        #无参函数
        scala> () => 2
        res8: () => Int = <function0>

        #输出函数签名
        scala> res8
        res9: () => Int = <function0>

        #调用函数
        scala> res8()
        res10: Int = 2

        #简单写法
        scala> val f2 = (x:Int, y:Int) => x * y
        f2: (Int, Int) => Int = <function2>

        #完整写法，
        #f3：函数名称
        #(Int, Int)：函数参数类型
        #=> Int：函数返回值类型
        #{(x, y) => x * y}：函数体，（参数名+函数体）组成
        scala> val f3:(Int, Int) => Int = {(x, y) => x * y}
        f3: (Int, Int) => Int = <function2>

        #也可以这样写，但是比较臃肿
        scala> val f4:(Int, Int) => Int = {(x:Int, y:Int) => x * y}
        f4: (Int, Int) => Int = <function2>

---

                                 数组、集合和元组

scala的数组、集合、元组
        1）数组
            scala> val v1 = Array(1,2,3,4,5,8)
            v1: Array[Int] = Array(1, 2, 3, 4, 5, 8)
            #数组里面既可以放Int， 也可以放String，都继承自Any，在scala中所有类型都继承自Any
            #class Int private extends AnyVal {
            #class AnyVal extends Any
            scala> val v2 = Array("Hadoop", "Hive", "Spark")
            v2: Array[String] = Array(Hadoop, Hive, Spark)

            scala> val v3 = Array(1,2,3,"Tom")
            v3: Array[Any] = Array(1, 2, 3, Tom)

            #显式指定数据类型，不可以放其他类型数据
            scala> val v3 = Array[Int](1,2,3,"Tom")
            <console>:11: error: type mismatch;
             found   : String("Tom")
             required: Int
                   val v3 = Array[Int](1,2,3,"Tom")
                                     ^

            #动态初始化一个数组，这里的5是数组的长度，
            #对于Int来说，初始化的默认值是0
            #对于String来说，初始化的默认值是null
            scala> val v4 = new Array(5)
            v4: Array[Nothing] = Array(null, null, null, null, null)

            scala> val v4 = new Array[String](5)
            v4: Array[String] = Array(null, null, null, null, null)

            scala> val v5 = new Array[Int](5)
            v5: Array[Int] = Array(0, 0, 0, 0, 0)

            #给元素赋值
            scala> v5(2) = 10

            scala> v5
            res2: Array[Int] = Array(0, 0, 10, 0, 0)

            #取得集合总值，在scala中是在java基础上又一次进行高度的封装，方便用户使用
            scala> v5.sum
            res5: Int = 23

            #升序排序
            scala> v5.sorted
            res8: Array[Int] = Array(0, 0, 10, 12, 13)

            #降序排序
            scala> v5.sorted.reverse
            res9: Array[Int] = Array(13, 12, 10, 0, 0)

            #通过匿名函数进行排序
            scala> v5.sortBy(x => x)
            res10: Array[Int] = Array(0, 0, 10, 12, 13)

            scala> v5.sortBy(x => -x)
            res11: Array[Int] = Array(13, 12, 10, 0, 0)
        2）集合
            #定义一个集合
            scala> val ls = List(1,2,3,4,5)
            ls: List[Int] = List(1, 2, 3, 4, 5)

            #取得集合大小和长度
            scala> ls.length
            res12: Int = 5

            #取得汇总
            scala> ls.sum
            res13: Int = 15 

            #取得某个元素
            scala> ls(1)
            res14: Int = 2
        3）Map
            scala> val map = Map("a"-> 1, "b"->2, "c"->3)
            map: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2, c -> 3)

            #指定类型
            scala> val map2 = Map[String, Int]("a"-> 1, "b"->2, "c"->3)
            map2: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2, c -> 3)

            #取得一个值
            scala> map("a")
            res15: Int = 1

            #取得一个不存在的key
            scala> map("d")
            java.util.NoSuchElementException: key not found: d
              at scala.collection.MapLike$class.default(MapLike.scala:228)
              at scala.collection.AbstractMap.default(Map.scala:59)
              at scala.collection.MapLike$class.apply(MapLike.scala:141)
              at scala.collection.AbstractMap.apply(Map.scala:59)
              ... 32 elided

            #取得不存在的key，如果没有返回一个默认值0， 避免程序报错
            scala> map.getOrElse("d", 0)
            res17: Int = 0

            #遍历映射中所有的键/值对偶
            scala> for((k, v) <- map) {
                 | println(k + " " + v)
                 | }
            a 1
            b 2
            c 3

        4）元组
            1）定义
                使用一堆圆括号包含起来
            2）下标
                访问元组中元素下标从1开始
            3）元素个数
                最多22个元素
            4）数据类型
                任意的scala语言支持的数据类型

            #一个简单的元组
            scala> val t = (1, "a", 2.0, 5L)
            t: (Int, String, Double, Long) = (1,a,2.0,5)

            #报错， 因为下标从1开始
            scala> t._0
            <console>:13: error: value _0 is not a member of (Int, String, Double, Long)
                   t._0
                     ^
            元组的好处：
            1：可以放多种类型数据，在java中返回多个参数，需要将参数放到一个集合或者写个model实体类，返回该实体对象，但是在scala中可以放到元组中非常方便

            //定义一个函数，返回的是一个元组
            scala> val f:(Int, Double) => (Double, Int) = {(x, y) => (y, x)}
            f: (Int, Double) => (Double, Int) = <function2>

            scala> val f1 = f(1, 2.5)
            f1: (Double, Int) = (2.5,1)

            scala> f1._1
            res23: Double = 2.5

            scala> f1._2
            res24: Int = 1

            #map中存放很多的对偶元组
            scala> val m1 = Map(("a", 100), ("b", 200))
            m1: scala.collection.immutable.Map[String,Int] = Map(a -> 100, b -> 200)片