1、字符串
// 创建一个字符串
var str1 = "hello bjsxt"
var str2 = "hello sxsxt"
var str3 = "HELLO bjsxt"
println(str1.indexOf('o'))
println(str1.equalsIgnoreCase(str3))
val strBuilder = new StringBuilder
// 字符串拼接
strBuilder.+('f')
strBuilder.++=(" i love")
strBuilder ++= "liushishi"
println(strBuilder)
strBuilder.append("very much")
strBuilder += ('p')
println(strBuilder)
2、数组
2.1、一维数组
// 数组
val arr = new Array[Int](10)
arr(0) = 100
arr(1) = 99
for(elem <- arr) {
println(elem)
}
// 赋值
for(index <- 0 until arr.length) {
arr(index) = index * index
}
// for循环打印
for(index <- 0 until arr.length) {
println(arr(index))
}
// 用数组的foreach方法打印
println("-----------------------")
arr.foreach((x:Int) => {
println(x)
})
// 简化1，方法在函数体中只出现一次，可以用_代替
arr.foreach(
println(_)
)
// 简化2
arr.foreach(println)
2.2、二维数组
// 创建
val arr2 = new Array[Array[Int]](3)
for(i <- 0 until arr2.length) {
arr2(i) = new Array[Int](3)
}
// 赋值
for(i <- 0 until arr2.length; j <- 0 until arr2(i).length) {
arr2(i)(j) = i*j
}
// 打印
println("-----------")
for(i <- 0 until arr2.length; j <- 0 until arr2(i).length) {
print(arr2(i)(j) + "\t")
if(j == arr2(i).length-1) {
println()
}
}
2.3、Array的一些方法
// 创建时赋值
val arr3 = Array(1, 2, 3, 4)
val arr4 = Array(2, 3, 4, 5)
val allArr = Array.concat(arr3, arr4)
// 合并两个数组
allArr.foreach(println)
// 调用Array的fill方法创建数组
val arr5 = Array.fill(5)(1)
arr5.foreach(println)
3、List集合
3.1、filter 过滤元素
//list创建
val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
list.foreach(println)
// filter 过滤元素，完整版
var result = list.filter((x:Int) => {
x > 3
})
//过滤元素，简化版
var result2 = list.filter(_ > 3)
result.foreach(println)
result2.foreach(println)
3.2、count：计算符合条件的元素个数
// count 计算符合条件的元素个数
var count = list.count((x:Int) => {
x > 3
})
println(count)
3.3、map：对元素操作
map函数传入的匿名函数的参数类型一定是与集合中元素的类型一致
map函数传入的匿名函数的返回值的类型就是这个新集合的泛型，所以mapResultd是一个集合，集合元素类型是数组
val list2 = List("hello xinxin", "hello lili", "hello shishi")
// mapResultd是一个集合，集合元素类型是数组
var mapResult = list2.map((x:String) => {
x.split(" ")
})
mapResult.foreach((x:Array[String]) => {
x.foreach((y:String) => {
println(y)
})
})
3.4、flatmap：压扁扁平，先map再flat
flatmap返回值flatMapResult 是一个集合，集合中元素是String类型
// flatmap
var flatMapResult = list2.flatMap((x:String) => {
x.split(" ")
})
flatMapResult.foreach(println)
map flatMap区别示意图：
map flatMap区别.png
4、Set集合
// set集合
val set1 = Set(1, 2, 3, 4, 4)
val set2 = Set(1, 2, 5)
// 交集 scala中字符有可能也是方法名
var set3 = set1.intersect(set2)
var set4 = set1.&(set2)
set3.foreach(println)
set4.foreach(println)
// 差集
set1.diff(set2)
set1.&~(set2).foreach(println)
// 字符串之间用~连接
val set5 = set1.mkString("~")
println(set5)
5、Map集合
// 初始化map
val map = Map("1" -> "test1", "2" -> "test2", ("3", "test3"))
// 遍历
var keyIterator = map.keys.iterator
while(keyIterator.hasNext) {
var key = keyIterator.next()
// map.get(key)返回值类型是Option，有两种类型：None，Some
// 如果key对应的元素没有值返回None，有值返回Some
println(key + ":" + map.get(key).get)
}
// 如果能get出来值就是那个值，如果没有那个值就打印 no result
println(map.get("100").getOrElse("no result"))
// foreach方法遍历，参数是一个参数是元组类型的函数
map.foreach((x:(String, String)) => {
var key = x._1
var value = x._2
println(key + ":" + value)
})
println(map.contains("1"))
6、元组
与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。
swap方法只有二元组才有
// 元组两种定义方式
val t2 = (1, 2)
println(t2._2)
val t3 = Tuple3(1, 2, 3)
val t4 = Tuple4("test1", 2, true, 1.0)
// 遍历
var iterator = t3.productIterator
while(iterator.hasNext) {
println(iterator.next())
}
// swap，只有二元组才有
val t5 = t2.swap
println(t5)
7、trait：类似java中接口，但是比java中的接口更高级
trait中可以生命一个函数，也可以实现函数
trait中既可以定义变量也可以定义常量
trait Read {
def read(name:String) {
println(name + " is reading")
}
}
trait Listen {
def listen(name:String) {
println(name + " is listening")
}
def sayName(name : String):String
}
class Person2 extends Read with Listen {
override def sayName(name: String): String = {
println(name + " see you!")
name
}
}
测试
val p = new Person2
p.read("xinxin")
p.listen("hahaha")
p.sayName("lili")
8、模式匹配 match
8.1、概念理解：
一个模式匹配包含了一系列备选项，每个都开始语关键字case
一个模式匹配包含了一个模式及一道多个表达式，箭头符号 => 隔开了模式和表达式
8.2、代码及注意点
模式匹配不仅可以匹配值还可以匹配类型
从上到下顺序匹配，如果匹配到则不再往下匹配
都匹配不上的，会匹配到case_， 相当于default
match的最外面的 "{}" 可以去掉看成一个语句
def main(args: Array[String]): Unit = {
for(i <- 1 to 10) {
matchTest(i)
}
}
def matchTest(x:Int) = {
x match {
case 1 => println("one")
// 不仅可以匹配值，还可以匹配类型
// 从上往下匹配，当匹配上一个模式后，就不再往下匹配了
case i:Int => println("Int")
case 2 => println("two")
case 3 => println("three")
// 当传入的的参数无法匹配上面的内容，就会匹配上_，相当于default
case _ => println("default")
}
}
9、样例类
使用case关键字定义的类，样例类是特殊的类，实现了类构造参数的getter方法（构造参数默认被声明为val），当构造参数是声明为val类型是，它帮你实现getter和setter方法
样例类默认实现了 toString，equals，copy和hashCode方法
样例类可以new，也可以不用new
// 样例类
case class Person10(name:String, age:Int)
// 普通类
class Person11(name:String) {
}
object Lesson05 {
def main(args: Array[String]): Unit = {
var p = Person10("xinxin", 23)
p.name
var p2 = new Person11("lala")
// 编译报错
p2.name
}
}
模式匹配和样例类结合使用
case class Person10(name:String, age:Int)
object Lesson05 {
def main(args: Array[String]): Unit = {
var p3 = Person10("xinxin", 22)
var p4 = Person10("lili", 21)
var p5 = Person10("lili", 26)
var list = List(p3, p4, p5)
list.foreach(x => {
matchPerson(x)
})
}
def matchPerson(p:Person10) = {
p match {
case Person10("xinxin", 22) => println(p.toString)
case Person10("lili", 21) => println(p.toString)
case o:Person10 => println("-------------" + p.toString)
case _ => println("default")
}
}
}
网友评论