scala 编程函数，方法与数组(其二)

scala 函数与方法！
  1,在实际中，方法存在于对象中，用来处理对象的数据。
  2,scala 之中的所有的算术运算实际上是专门的方法，只是绑定到类型之中。 2+3 实际上是调用了值为2的一个Int 的加法方法，并提供参数3，返回值为5

object Hello{
  def main(args: Array[String]): Unit = {
    moth(8, 4)
    println(function0(1, 2))
    println(m(f1))
    println(powwer(2, 8)) // 递归函数
    println(greet(name = "hello world! "))
    println(fn(12, 12, 12))
    println(fn1(1)(2)) //两个输入参数分解到参数组之中去！
    println(add())
    //    调用匿名函数
    a()
    println(funinfun(3))
  }
  //  定义方法 "=" 可以省略, 省略之后,无论方法体最后一行计算结果是什么都会丢弃,返回Unit
  def add(){
    println("无返回值")
  }

  // Unit 表示无返回数值
  // 定义一个方法需要 def 指定
  // 方法的返回值可以不写，但是递归必须指定返回值
  def moth(a :Int,b :Int) ={
    println("Unit 表示无返回数值! ")
  }
  // 函数可以像数据类型一样传递和操作！
  val function0 = (x:Int,y:Int) => x+y

  // 函数作为形参传递方法！在方法之中调用函数(来自形参)
  def m(f:(Int,Int)=>Int) =f(2,6)

  val f1 = (x:Int,y:Int)=> x+y

  // 将方法转换成函数！
  def f2 = m _

  // k 的 w次幂
  def powwer(k:Int,w:Int):Long ={
    if (w>=1) k *powwer(k,w-1)
    else 1
  }
  // 有默认的参数   一般重要参数在前 其他参数在后
  def greet(prefix :String ="H",name:String)=s"$prefix$name"

  // 可变参数 求和计算（items 是 WrappedArry）
  def fn(items:Int*):Int ={
    var total = 0  // var 才能达到可变的效果！
    for (i <- items) total += i
    total
  }
  //参数组
  def fn1(x:Int)(y:Int) = if(x>y) x else y
  // 定义匿名函数
  val a = (name:String) =>{
    println("hello world!" + name)
  }
  // 函数之间的嵌套
  def funinfun(num:Int)={
    def fun(num:Int): Int ={
      if(num==1) 1 else num*fun(num-1)
    }
    fun(num)
  }
  // 原始函数
  def showlog(d:Date,log:String): Unit ={
    println("date is "+d+", log is "+log)
  }
  val data = new Date()
  showlog(data,"a")
  showlog(data,"b")
  showlog(data,"c")
  showlog(data,"d")
  // 使用偏应用函数达到省略部分传参的效果
  val fun1 = showlog(data:Date,_:String)
  fun1("a")
  fun1("b")
  fun1("c")
  fun1("d")
  //  高阶函数 传入的函数作为逻辑运算
  def fun_in(a:Int,b:Int): Int ={
    a+b
  }
  def fun_out(f:(Int,Int)=>Int,s:String)={
    val result = f(100,244)
    result + "~" + s
  }
  println(fun_out(fun_in, "hello"))
  //  高阶函数 函数的返回是函数
  //  (String,String) =>String 指的是 fun_retu 的返回类型
  def fun_retu(a:Int,b:Int): (String,String) =>String={
    val resu = a*b
    def fun2(s:String,s1:String): String ={
      s +"@" +s1+"$"+resu
    }
    fun2
  }
  println(fun_retu(10, 20)("hello", "world"))
  //  高阶函数 函数的传入与返回都是函数
  def fun_in_resu(f:(Int,Int)=>Int): (String,String) =>String ={
    val results = f(8,9)
    def fun4(s1:String,s2:String): String={
      s1+"@"+s2+"!"+results
    }
    fun4
  }
  fun_in_resu((a:Int,b:Int)=>{
    a+b
  })
}

关于数组的说明:
  1，Arry 类型是 scala 封装的一个 java 数组类
  2，scala 数组是通过 ()来访问的 每次遍历有时候是调用的 类型的 toString()方法,但是只是打印数组例外
  3,可变数组是一种静态类
  4,数组，元组，映射等默认都是不可变的 ，需要引入可变的包！

package day01

object Test2{
  def main(args: Array[String]): Unit = {
    // 不需要调用类 默认是定长数组
    val arr = new Array[Int](8) //默认 0填充
//    println(arr) // 是一个引用
//    println(arr.toBuffer) //转换成数组缓冲！ 也可以for循环遍历
    val arrstr = new Array[String](8) //默认是 null填充
//    println(arrstr) // 打印的是一个引用！
//    println(arrstr.toBuffer) //转换成数组缓冲
    val arr2 =Array("python","scala","java")//在此处可以看出 调用的是静态类 不需要 new
//    println(arr2.toBuffer)
//    println(arr2(2)) //使用的 () 不是[]

    //scala 生成一个动态类需要引用包
    import scala.collection.mutable.ArrayBuffer
    val arr3 = ArrayBuffer[Int]()
    arr3 += 1 //数组追加 1
    arr3+=(2,3,4) //追加多个元素 使用元组 或者数组
    arr3++=Array(5,6)
    arr3++=ArrayBuffer(7,8,9)
    arr3.insert(0,-1,0) // 在下标 0前处加入 -1 和 0
    arr3.remove(2,3) // 2(包括)下标开始删除 删除三个
    for(i<-arr3) println(i) //使用 for 打印每一个值
    for (i <- (0 until arr3.length).reverse) println(arr3(i)) //反转取值
    val yie = for (i <- arr3) yield i //此时是生成一个新的数组
    val arr4 = Array(arr3.max,arr3.sum,arr3.sorted) //求和与最大值,排序升序生成的数组
    println(arr4.toBuffer)

//    println(yie)
//    println(arr3.toBuffer)

  }
}