基础语法TestFunc.scala:
package com.scala
object TestFunc {
//默认值函数
def
sayMyName(name : String = "Jack"){
println(name)
}
//多个int类型参数,相加
def sumMoreParameters(
elem : Int*
) = {
var sum = 0
for(
e <- elem
){
println(e)
sum += e
}
sum
}
//含参函数
def add(a:Int,b:Int) = a+b
//一个自定义数值,和一个固定数值
def add2 = add(_:Int,2)
// 递归函数
// 必须自行定义函数返回类型
//
f(n)=f(n)*f(n-1)
def fac(n:Int):Int = if( n <= 0) 1 else n*fac(n-1)
//
函数柯里化
// 柯里化,柯里化比较有意思,就是说定义
// 把这个参数一个个独立开来写,这就是柯里化,它可以达到什么效果呢
def mulitply(x:Int)(y:Int) = x*y
//一个固定值和一个传参
def m2 = mulitply(2)_
// 同学们可能会说,这个看起来没有什么用处啊,但是我们说柯里化在递归,和控制抽象方面比较有用
// 在目前我们不去深究这个使用场景,现在就是让大家知道有这么个形式,大家掌握到这就可以了
// 柯里化就是把参数可以分开来,把部分函数参数可以用下划线来代替
// =>
匿名函数声明方式
val t = ()=>{333;"xururyun"}//声明了一个函数对象付给了t
// :后面是数据类型,c代表传进来的参数
def testfunc02(c : ()=>String )={
c()
}
// 匿名函数
val d1 = (a:Int)=> a+100
// 匿名函数作为参数,其实就是参数名,后面跟上参数类型,然后是表达式
def testf1(callback : (Int,Int)=>Int )={
println(callback(123,123))
}
//
嵌套函数
,其实就是def里面套一个def
def add3(x:Int, y:Int ,z:Int) = {
def add2(x:Int, y:Int) = {
x + y
}
add2(add2(x,y),z)
}
// 能否看懂???
def sum(f : Int => Int) : (Int , Int) => Int = {
def sumF(a : Int , b : Int) : Int =
if (a >b ) 0 else f(a) + sumF( a + 1 , b)
sumF
}
// def sum(f : Int => Int) : (Int , Int) => Int = {
// def sumF(a : Int , b : Int) : Int ={
// if (a >b ) 0 else f(a) + sumF( a + 1 , b)
// }
// return sumF
// }
def main(args: Array[String]) {
val sumF = sum(x=>x*2)
println(sumF(2,3))
// sayMyName()
// println(sumMoreParameters(1,2,3,4,5,6,7,8,9,10))
// println(add(2,3))
// println(add2(3))
// println(fac(5))
// println(d1(4))
// println(t)
// println(t())
// println(testf1((x:Int, y:Int)=>{x*y}))
// println( mulitply(123)(123))
// println( m2(123))
// println(testfunc02( t ))
// println(testf1( (a:Int,b:Int)=> a+b))
// testf1(add)
// println(add3(1,2,3))
// def sum(f :Int => Int) : (Int , Int) => Int = {
// def sumF(a : Int , b : Int) : Int ={
// if (a >b ) 0 else f(a) + sumF( a + 1 , b)
// }
// return sumF
// }
// val tttt = (a:Int,b:Int)=>a*b;
// testf1(tttt);
// testf1((a:Int,b:Int)=>a*b)
}
}
=======================================================================
基本用法2TestFunc02.scala 遍历to until
package com.scala
object TestFunc02 {
def test() : Unit = {
for(i <- 1.to(100)){
println(i)
}
// for(i <- 1 to 100 ){
// println(i)
// }
}
def test2() = {
for(i <- 1 until 100 ){
println(i)
}
}
def test3() = {
for(i <- 0 to 100 if (i % 2) == 1 ; if (i % 5) > 3 ){
println("I: "+i)
}
}
// switch
def testmatch(n:Any)={
n match {
case x:Int => {println("111") ;n}
// break;
case s:String => println("2222") ;n
case _ => {println("other"); "test"}//default
}
}
def sum(elem : Int*) = {
var temp = 0
for(e <- elem){
temp += e
}
temp
}
def main(args: Array[String]) {
// test()
// test2()
// test3()
// println(testmatch(100.0))
// println(sum(1,2,3,4,5))
// println(sum(1 to 5))
println(sum(1 to 5 :_*))
}
}
========================================================================
基本用法3TestCollection.scala list map foreach distinct sortBy 元组
package com.scala
object TestCollection {
def main(args: Array[String]) {
var t =
List
(1,2,3,5,5)
// println("---001--"+t(2))
// map 个位置相加 函数编程
// 对集合里面的每个元素进行操作,有返回值,这里返回一个新的List
// println(t.
map
( x => {x+2}))
// println(t.map(_ + 2))
var t2 = t.+:("test") //添加元素
// println(t2)
// println(t)
// println(t.::("test"))
// println("test"::t)
// println(6::t2)
// println(t2.::(6))
// println(List(6).:::(t2))
// println((t2):::List(6))
// println(t2)
// t2 = t:::6::Nil //组成新的List t作为一个元素
// println(t2)
//遍历
// t2.
foreach
(a=>print("---+++"+a))
//去重复
// println("/--***---"+t.
distinct
)
//排序
// println(t.
sortBy
{ x => -x })
//切割
// println("---+++++********************Slice"+t.
slice
(0, 2))
// println("-*--*--*--*--*--*--*--*--*-")
// for(temp<-t2){
// print(temp)
// }
// println("-*--*--*--*--*--*--*--*--*-")
// for(i <- 0
until
t2.length){
// println(i)
// println(t2(i))
// }
// println("-*--*--*--*--*--*--*--*--*-")
// println(t./:(0)({
// (sum,num)=>sum-num
// }))
// 1,2,3,5,5
// reduce 就是对集合里面的每个元素依次进行操作
// println(t.
reduce
( (a,b) => a+b ))
// println(t.reduce( _ - _))
// // filter 是把匿名函数返回为True保留下来
// println(t.
filter
( _ > 3 ))
// println(t.
take
(3)) //取前三个元素
// println("-*--*--*--*--*--*--*--*--*-")
// println(t.
foldLeft
(0)((sum,num)=>{ //带初始值的reduce
// print(sum+"--"+num+" ");
// sum-num;
// }))
// println("-*--*--*--*--*--*--*--*--*-")
// println(t.map(v =>v+2))
// println("-*--*--*--*--*--*--*--*--*-")
//
元组
// var tuple01 = (1,2,3,5)
// println(tuple01._1)
// println(tuple01._4)
var list = List(("yasaka",100),("xuruyun",100),("liangyongqi",50))
val temp = list.sortBy(x => (-x._2,x._1))
println(temp)
}
}