基本概念:
//方法
Object Demo01Method{
def main(args:Array[String]) : Unit ={
println(method01())
println(method01)
println(method02)
println(method03("yubanmeiqin"))
println(method04("xuenai",18))
}
//使用def定义一个方法。
//方法的定义: def 方法名(参数列表):返回值={方法体}
def method01():String ={
"this is method01"
}
//没有方法参数,可以省略 ,不写返回值类型,可以自动推导。
def method02 ={
"this is method02"
}
//指定一个参数的方法
def method03(name:String):String={
name
}
//方法重载
def method03(name:String,age,Int):String={
//字符串内取值
s "name is $name,age is $age"
}
}
//函数
object Demo02Function {
def mian(args:Array[String]):Unit={
println(function01(10))
println(function02(10,20))
println(method01(10,function01))//110
println(method02(10,function02))//30
}
//函数的定义: val /var 函数名称=(函数的参数列表)=>函数体
val func01 = (a:Int) =>{
a*10
}
val func02=(a:Int,b:Int)=>{
if(a>b) a else b
}
//a:Int 常量
//func:Int=>Int 函数 一个Int类型参数 返回值是Int
def method01(a:Int,func(Int)=>Int):Int={
a+func(a)
}
def method02(a:Int,func:(Int,Int)=>Int):Int ={
val m=10
val n=20
a+func(m,n)
}
}
//方法参数
object Demo03MethodArguments{
def main(args:Array[String]):Unit={
method01("yuban","nv")
method01("yuban")
method02("xiamuguizhi",16)
//可以不按照给定参数顺序,但必须带上参数名
method02(age=16,name="xiamuguizhi")
method03(1,2,3)
method03(1,2,3,4,5,6)
}
//声明参数给定默认值 调用时不传值 就使用默认值
def method01(name:String,sex:String="nv"):Unit={
println(s"$name $sex")
}
def method02(name:String,age:Int):Unit ={
println(s"$name $age" )
}
//变长参数指 参数个数不确定
def method03(num:Int*):Unit ={
println(num.toBuffer)
}
}
//lazy 懒加载
object Demo04Lazy
def main(args:Array[String]):Unit={
//lazy 懒加载,当调用的时候被执行
val age=18
var study ="unknow"
println(study) //unknow
lazy val res= if(age>17){
study="资深码农"
study
}else{
study="小白"
study
}
println("执行前:"+study)
println(res) //lazy 执行
println("执行后:"+study)
应用场景:scala 从本地读取文件
lazy val lines=Source.fromFile("E://file/a.txt").getLines()
for(line <-lines){
println(line)
}
}
}
//Array数组
object Demo05Array{
def main(args:Array[String]):Unit={
//array 可变和不可变
//不可变
val arr01:Array[Int] =new Array[Int](10)
println(arr01.toBuffer)
arr01(0)=0//给对应下标元素 赋值
arr01(1)=1
arr01(2)=2
println(arr01(1))
println(arr01.toBuffer)
//arr01(10)=2 //报错:ArrayIndexOutOfBoundsException: 10 长度不可变
val arr02:Array[Int]=Array(1,2,5,3,7)//通过apply的方式添加
//遍历
// for(i <- arr02)
//println(i)
arr02.length
println(arr02.filter(_%2==0).toBuffer) //_ 代表每个元素, filter会留下返回为true 的元素
arr02.size
println(arr02.sorted.reverse.toBuffer)
arr02.max
arr02.min
println(arr02.mkString)
println(arr02.mkString(","))
//_+_ 第一个_ 代表累加的和 第二个_ 代表累加的元素
println(arr02.reduce(_+_)) //累加
println(arr02.toBuffer) //转换成成可变数组
println("------------------------------")
// ---------ArrayBuffer 可变的数组
val arrBuffer01 = ArrayBuffer(1,2,3,4)
val arrBuffer02 =new ArrayBuffer[Int]()
arrayBuffer02+=0
arrayBuffer02+=1
arrayBuffer02+=2
arrayBuffer02+=3
arrayBuffer02.append(4)
arrayBuffer02.remove(0)
arrayBuffer02.length
arrayBuffer02.size
arrayBuffer02.sorted.reverse
arrayBuffer02.insert(0,1,2,3,5) //指定位置插入多个元素
arrayBuffer02.foreach(println(_))
println("---------------------------")
arrayBuffer02.foreach(num=>println(num))
println(arrayBuffer02)
}
}
//Map集合
/**
* Created by young on 2019.3.1.
* desc: Map(映射)是一种可迭代的键值对(key/value)结构。
* 所有的值都可以通过键来获取。
* Map 中的键都是唯一的。
* Map 也叫哈希表(Hash tables)。
* Map 有两种类型,可变与不可变,区别在于可变对象可以修改它,而不可变对象不可以。
* 默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合,你需要显式的引入 import scala.collection.mutable.Map 类
* 在 Scala 中 你可以同时使用可变与不可变 Map,不可变的直接使用 Map,可变的使用 mutable.Map。
*/
object Demo06Map{
def main(args:Array[String]):Unit={
//map 可变 不可变
//不可变: 以元组的形式创建map ("hadoop1",10000)
val map01:Map[String,Int]=Map(("hadoop1",10000),("hadoop2",18000),("hadoop3",23333))
val v1:Int=map01("hadoop1")
println(v1)
//Option 有两个子类 Some none
val option:Option[Int]=map01.get("hadoop1")
println(option.get) //Some(10000).get
val option01:Option[Int]=map01.get("hadoop3") //none
//推荐使用
println(map01.getOrElse("hadoop4",0))
//遍历
for(ele<- map01){ // ele 是一个元组
println(ele._1+" "+ele._2)
}
println("-------------------------")
for((k,v)<-map01){
println(k+" "+v)
}
//使用映射的方式
val map03 =Map("lao"->1,"zi"->2,"le"->3,"yi"->4)
map03("lao")=100
map03.contains("")
}
}
//元组 Tuple
object DemoTuple{
def main(args:Array[String]):Unit={
//元组
val tuple=(1,"name",100.0,235151515L)
println(tuple._1)
println(tuple._2)
for(i<- tuple.productIterator){
println(i)
}
val tuple01=((1,"name",100.0,1434134148L),(2,"name1",200.0,341341378L))
println(tuple01._1._2)
//特殊的元组 对偶元组 只有两元素的元组
val tuple02=(1,2)
}
}