声明变量
val
:类似于Java里的常量,一旦赋值就不能在改变。例如:val result = 1 val person =new Persion() //以下两行会报错,因为val类型的变量不允许再次被赋值或者被引用 val result = 2 val person =new PersionSub()
var
:类似于Java里的变量,可以随意赋值改变var result = 1 var person =new Persion() //以下不会报错,因为常量可以随意赋值 var result = 2 var person =new PersionSub()
声明多个变量
var firtst,last = 0 var firtst,last = "li"
条件表达式,条件表达式里的最后一行作为返回值,这一点跟Java是有所区别的
if
:后边没有跟else,如果if里的判断为false,那么返回值为就会是默认的Unit()
,类似于Java里的void或者是nullprint(if(false){}) //控制台输出的结果为()
if( false | true){ } else{ }
:if代码块里与else
代码块里的数据类型可以不一致,那么返回值类型为他们的公共父类Any
类型val result = if(false|true){ "a" } else{ 1 } print(result) //那么返回值类型为Any
if( ){ } else if( ) { } else{ }
:符合要求的代码块会以最后一行为返回值
循环语句
while do
var n =10 while(n<10){ println(n) n -=1 }
for
循环:scala没有类似于java的for循环只能使用while代替for循环或者使用简易版的for语句var n = 10 for(i <- 1 to n){ println(i) } for(i <- "hallo word"){ print(i) } for(i <- 1 to 10){ print(i) //不包含10 }
双重
for
循环for (i <- 1 to 10;j <- 1 to 10){ println(i*j) }
for
循环带有if
表达式:for (i <- 1 to 10 if i ==2;j <- 1 to 10 if j==2 ){ println(i*j) }
for
推到式:构建一个集合
val lists = for (i<-1 to 10) yield i print(lists)
函数
函数入门
object Learn2 { def main(args: Array[String]): Unit = { print(sayHello("liyz", 15)) print(sum(1)) } //返回值类型scala会自动推断出返回值类型 def sayHello(name: String, age: Int) = { if (age > 10) { print("未成年人") age //返回值 } else { print("成年人") age //返回值 } } def sum(age: Int): Any = { var result = 2 for (i <- 1 to 10) { result += i } result //返回值 } }
函数之默认参数与带名参数:在sacla中我们调用某些函数时,不希望给出参数的具体值。而是希望使用默认参数值,此时就可以定义函数参数的默认值,如果参数不够会从左向后一次应用参数
object Learn2 { def main(args: Array[String]): Unit = { print(sayHello("liyuzhi")) } //第一个参数为必须传的参数,后俩个为不是必须传的参数,如果调用该方法传后俩个参数,则默认值被覆盖 def sayHello(firstName:String,name:String="liyzhi",lastName:String="xiaolizi"): Any ={ val n = firstName+"-"+name+"-"+lastName n } }
函数之变长参数:利用
*
单纯的只有一个可变长参数
object Learn2 { def main(args: Array[String]): Unit = { print(moreParam(1,2,3,4,5,6,7,8,9,10)) } def moreParam(param:Int*): Any ={ var num =0 for (elem <- param) { num+=elem } num+param2 } }
单个参数与可变长参数混用:可变长参数一定要放在参数列表的最后边
object Learn2 { def main(args: Array[String]): Unit = { print(moreParam("a",2,3,4,5,6,7,8,9,10)) } //可变长参数一定要放在最后边,否则语法错误 def moreParam(param2:String,param:Int*): Any ={ var num =0 for (elem <- param) { num+=elem } num+param2 } }
函数之已有序列调用变长参数函数,是不对的,例如val s = sum(1 to(5)) 。此时需要使用Scala特殊的语法(
val s = sum(1 to(5):_*)
)来将参数定义为序列,让Scala解释器识别改序列。package com.lyz object Learn3 { def main(args: Array[String]): Unit = { print(sum(1 to 10:_*)) //利用已有的序列调用可变长参数函数,需要加上能够让Scala识别的语法来标记该参数是一个已有序列 } def sum(age: Int*): Int = { var sum = 0 if (age.isEmpty) { print(1) 0 } else { for (elem <- age) { sum += elem } sum } } }
Scala惰性赋值:
lazy
的使用。有时候我们在使用变量的时候希望在用到的时候再去初始化,并且不再被重复计算,那么我们就会用到Lazy
这个关键字去修饰声明变量,并且Lazy
只能修饰val
所声明的变量。应用场景为文件IO,网络IO,初始化数据库连接等等。object Learn3 { def main(args: Array[String]): Unit = { lazy val result = init() //懒加载,只有调用的时候才会初始化 println("1") //首先打印的是 1 println(result) //第二打印的是 "初始化init",第三打印的是 2 //如果去掉lazy那么根据程序执行的顺序他就会先初始化init函数,打印的顺序是,第一打印的是 "初始化init",第二打印的是 1,第三打印的是 2 } def init(): Int = { println("初始化init") 2 } }
Scala异常:根Java的异常语法很相似
def main(args: Array[String]): Unit = { def detailException(): Unit = { try { val f = new FileReader("") } catch { case IOException => { //跟java有所区别的地方 println("this is IOException") } case IllegalArgumentException => { println("IllegalArgumentException") } } finally { //跟java执行机制一样,都会执行该代码块的代码 println("contine process") } }
数组:对应Java里的数组
数组之
Array
:在Scala
中Array
代表的含义与Java
中的类似,也是长度不可变的数据,此外由于Scala
与Java
都运行在Java
虚拟机上,地方可以互相调用,因此Scala
的数据的底层就是Java
数据,例如字符串数据就是Java
中的String[]
,整数数据就是Java
中的int[]
package com.lyz object Learn4 { def main(args: Array[String]): Unit = { //初始化数组,并指定数组的长度 val strAarry = new Array[String](10)//声明长度为10的字符串数组,默认值就是数据类型的默认值,每个元素的默认值是0 val intArray= new Array[Int](10)//声明长度为10的整数数组,每个元素的默认值为 null //直接使用Array创建数据 val strAarry1 = Array("aaaa","bbbbbb") val intArray2 = Array(1,2,3,4,5) val anyArray = Array(2,3,4,"resutl") //Sacla会自动推断数据类型,改数组的数据类型是Any类型 } }
数组之
ArrayBuffer
:跟Java里的ArrayList类似,是一个可变长度的数组package com.lyz import scala.collection.mutable.ArrayBuffer object Learn4 { def main(args: Array[String]): Unit = { //直接使用Array创建数据 val strAarry = Array("aaaa", "bbbbbb") val arrayBuffer = new ArrayBuffer[String]() //创建一个可变长数组 arrayBuffer += "b0" //向可变长数组里添加单个元素 arrayBuffer += ("b1", "b2", "b3") //像可变长数组里添加多个元素 var arrayBuffer1 = new ArrayBuffer[String]() //创建第二个可变长数组 arrayBuffer += ("a4", "a5", "a6") //向数组里添加多个元素 arrayBuffer ++= arrayBuffer1 //将一个数组的全部元素添加到另一个数组里 arrayBuffer.remove(0) //移除指定位置的元素 arrayBuffer.insert(0, "a", "a8") //在指定的位置插入元素,将"a"插入到0下标的位置,"a8" 插入下标为1的位置 arrayBuffer.remove(1) arrayBuffer.trimEnd(1) //从尾部截断指定个数的元素 arrayBuffer.trimStart(1) //从开头截断指定个数的元素 arrayBuffer.toArray //将ArrayBuffer转化成Aarry arrayBuffer.toBuffer //将Arrary转换成AarryBuffer //遍历数组里的元素 for (elem <- arrayBuffer) { println(elem) } for (elem <- arrayBuffer.indices) { println(arrayBuffer(elem)) } //倒叙遍历 for (elem <- arrayBuffer.distinct.reverse) { println(elem) } //跳跃遍历,步长为2 for (elem <- 0 until(arrayBuffer.length, 2)) { println(arrayBuffer(elem)) } println(arrayBuffer.sum) //数组求和,一定是数值类型 println(arrayBuffer.min)//数组最小值,一定是数值类型 println(arrayBuffer.max)//数组最大值,一定是数值类型 println(arrayBuffer.sorted)//数组排序 //指定每个元素下标位置进行排序 for (elem <- arrayBuffer.sortBy(_.charAt(0))) { println(elem) } println(arrayBuffer.mkString(",")) //将数组里的每个元素利用 "," 拼接起来,返回值为String,控制台打印为:b1,b2,b3,a4,a5 println(arrayBuffer.mkString) //将数组里的元素拼起来 控制台打印为:b1b2b3a4a5 }
object Learn4 { def arrayBufferConversion(arrayBuffer: ArrayBuffer[String]): ArrayBuffer[String] = { /** * 第一种方式是利用yield 语法来转换,利用filter过滤含有"a"字符串的元素 * 打印结果为: * a4:conversion is ok * a5:conversion is ok * a6:conversion is ok */ val change = for (elem <- arrayBuffer.filter(_.contains("a"))) yield elem + ":conversion is ok" //对数组进行转换,而不改变原来的的数组 for (elem <- change) { println(elem) } /** * 第二种为利用map函数来转换,过滤条件为元素里包含"a"的元素 * 打印结果为: * a4:conversion is ok map * a5:conversion is ok map * a6:conversion is ok map */ for (elem <- arrayBuffer.filter(_.contains("a")).map(_ + ":conversion is ok map")) { println(elem) } /** * 元数据没有被改变 * 打印结果为: * b0 * b1 * b2 * b3 * a4 * a5 * a6 */ for (elem <- arrayBuffer) { println(elem) } arrayBuffer } def main(args: Array[String]): Unit = { val arrayBuffer = new ArrayBuffer[String]() //创建一个可变长数组 arrayBuffer += "b0" //向可变长数组里添加单个元素 arrayBuffer += ("b1", "b2", "b3") //像可变长数组里添加多个元素 var arrayBuffer1 = new ArrayBuffer[String]() //创建第二个可变长数组 arrayBuffer += ("a4", "a5", "a6") //向数组里添加多个元素 arrayBuffer ++= arrayBuffer1 //将一个数组的全部元素添加到另一个数组里 } }
Map:一键值对存在的一种数据结构,创建Map的时候默认长度是不可变的
package com.lyz import scala.collection.{SortedMap, mutable} import scala.collection.mutable.Map /** * 类的注释 * * @Package com.lyz * @ClassName MapAndTuple * @Description ${TODO} * @Author liyuzhi * @Date 2018-06-08 19:08 */ object MapAndTuple { def main(args: Array[String]): Unit = { //immutableMap //mutableMap hashMap } //可变的Map private def hashMap = { /** * 初始化HashMap */ val hashMap = new mutable.HashMap[String, Int]() hashMap.put("zhangsan", 21) hashMap.put("lisi", 22) hashMap.put("wangwu", 23) hashMap.put("zhaoliu", 24) /** * 获取Map值 */ println(hashMap("zhangsan")) //如果键不存在会什么也不返回直接报错 println(hashMap.get("aaaa")) //如果键不存在会返回None,打印结果为:None,如果存在那么返回值类型为Option,然后我们需要调用get方法获取值 println(hashMap.getOrElse("aaaa", 0)) //如果键不存在就返回0,如果存在就会返回键对应的值 /** * 更新Map元素 */ hashMap("zhangsan") = 31 /** * 增加Map元素 */ hashMap += ("abc" -> 20, "bcd" -> 22) /** * 移除元素 */ hashMap -= ("zhangsan", "aaaaa") hashMap.remove("zhangsan") /** * 遍历Map */ for (elem <- hashMap) { println(elem._1, elem._2) } //遍历Key for (elem <- hashMap.keySet) { println(elem) } //遍历value for (elem <- hashMap.values) { println(elem) } } //可变Map private def mutableMap = { /** * 初始化 scala.collection.mutable.Map */ //scala.collection.mutable.Map[String,Int] Map是可变的数据结构,所以我们再次给已存在的键赋值就不会报错 val ageMuttableMap = scala.collection.mutable.Map("zhangsan" -> 21, "lisi" -> 22, "wangwu" -> 23, "zhaoliu" -> 24) ageMuttableMap("zhangsan") = 31 /** * 获取Map值 */ println(ageMuttableMap("zhangsan")) //如果键不存在会什么也不返回直接报错 println(ageMuttableMap.get("zhangsan")) //如果键不存在会返回None,打印结果为:None,如果存在那么返回值类型为Option,然后我们需要调用get方法获取值 println(ageMuttableMap.getOrElse("aaaaa", 0)) //如果键不存在就返回0,如果存在就会返回键对应的值 /** * 更新Map元素 */ ageMuttableMap("zhangsan") = 31 /** * 增加Map元素 */ ageMuttableMap += ("abc" -> 20, "bcd" -> 22) /** * 移除元素 */ ageMuttableMap -= ("zhangsan", "aaaaa") /** * 遍历Map */ for (elem <- ageMuttableMap) { println(elem._1, elem._2) } //遍历Key for (elem <- ageMuttableMap.keySet) { println(elem) } //遍历value for (elem <- ageMuttableMap.values) { println(elem) } } //不可变Map private def immutableMap = { /** * 初始化 scala.collection.immutable.Map[String,Int] */ //scala.collection.immutable.Map[String,Int] Map是不可变的数据结构,所以我们再次给已存在的键赋值就会报错 val age = scala.collection.immutable.Map("zhangsan" -> 21, "lisi" -> 22, "wangwu" -> 23, "zhaoliu" -> 24) //自动对键排序的Map val ageSortedMap = scala.collection.immutable.SortedMap("zhangsan" -> 21, "lisi" -> 22, "wangwu" -> 23, "zhaoliu" -> 24) /** * 获取Map值 */ println(age("zhangsan")) //如果键不存在会什么也不返回直接报错 println(age.get("zhangsan")) //如果键不存在会返回None,打印结果为:None,如果存在那么返回值类型为Option,然后我们需要调用get方法获取值 println(age.getOrElse("aaaaa", 0)) //如果键不存在就返回0,如果存在就会返回键对应的值 /** * 更新Map元素 */ //age("zhangsan") = 31 //报错 age + ("abc" -> 20, "bcd" -> 22) //更新不可变Map的Api /** * 不可变Map移除元素 */ age - ("abc", "zhangsan") /** * 遍历Map */ for (elem <- age) { println(elem._1, elem._2) } //遍历Key for (elem <- age.keySet) { println(elem) } //遍历value for (elem <- age.values) { println(elem) } } }
Tuple:元组
package com.lyz object TupleLearn { def main(args: Array[String]): Unit = { val tuple = ("a1",1) //定义一个元组 println(tuple._1) //得到元组第一个元素 println(tuple._2)//得到元组里的第二个元素 val names = Array("z3","l4","w5") val ages = Array(1,2,3,4,5) /** * 控制台打印的结果为: * z3:1 * l4:2 * w5:3 */ val nameage = names.zip(ages) for ((name,age) <- nameage) { println(name+":"+age) } } }
Scala(一)基础语法、条件控制、函数、数组,Map与Tuple
最新推荐文章于 2021-04-30 13:51:36 发布