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)
}
}
