前言
此系列为scala学习文章，适用于为学spark而学习scala
视频参考地址：Scala快速入门（适合为学Spark学习Scala的同学）
系列文章如下：
6. Scala学习06——trait特性、模式匹配、偏函数、样例类
资料下载地址：Scala课件资料.docx
目录
一、String
1. 创建
创建可变字符串与不可变字符串
//不可变字符串
val s = "bjsxt"
val s1 = "BJSXT"
//可变字符串
val strBuilder = new StringBuilder
strBuilder.append("abc")
2. 方法
println(s.equals(s1))
println(s.equalsIgnoreCase(s1))
println(s.indexOf(98))
println(s.indexOf("b"))
println(s==s1)
/* compareToIgnoreCase
* 如果参数字符串等于此字符串，则返回值 0；
* 如果此字符串小于字符串参数，则返回一个小于 0 的值；
* 如果此字符串大于字符串参数，则返回一个大于 0 的值。
*/
println(s.compareToIgnoreCase(s1))
输出：false true 0 0 false 0二、Array
1. 不可变数组
（1）创建
/**
* 创建数组两种方式：
* 1.new Array[String](3)
* 2.直接Array
*/
//创建类型为Int 长度为3的数组 //默认为 0 0 0
val arr1 = new Array[Int](3)
//创建String 类型的数组，直接赋值
val arr2 = Array[String]("s100","s200","s300")
//赋值
arr1(0) = 100
arr1(1) = 200
arr1(2) = 300
（2）遍历
/**
* 遍历两种方式
*/
for(i <- arr1) {println(i)}
arr1.foreach(i => {println(i)})
arr1.foreach(println)
二维数组
//创建方式1
val arr2 = new Array[Array[Int]](3)
arr2(0) = Array[Int](1,2)
arr2(1) = Array[Int](3,4)
arr2(2) = Array[Int](5,6)
//创建方式2
val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
//遍历方式1
for(ar <- arr2; elem<-ar){
println(elem)
}
//遍历方式2
arr2.foreach(arr=>{arr.foreach(println)})
}
（3）方法
- Array.concate：合并数组
- Array.fill(5)(“baway”)：创建初始值的定长数组
val ar1 = Array[String]("a","b","c")
val ar2 = Array[String]("g","c","c")
//a b c g c c
val a1: Array[String] = Array.concat(ar1, ar2)
a1.foreach(println)
//hello hello hello hello hello
val a2: Array[String] = Array.fill(5)("hello")
a2.foreach(println)2. 可变数组
//创建可变数组
import scala.collection.mutable.ArrayBuffer
val arrM = ArrayBuffer[Int](1,2,3)
//在末尾加数据
arrM.+=(5)
//在末尾加数据
arrM.append(7,8,9)
//在开头加数据
arrM.+=:(100)
// 100 1 2 3 5 7 8 9
arrM.foreach(println)三、List
1. 不可变List
（1）创建与遍历
//创建初始化List
val list = List[Int](1, 2, 3)
val list1 = List[String]("hello scala","scala hahah","world")
//List(hello, scala, world)hhhh
list1.+("hhhh")
//遍历
list.foreach { x => println(x)}
list.foreach { println}（2）方法
- filter:过滤元素
- count:计算符合条件的元素个数
- map：对元素操作；一个对象输出一个对象
- flatmap ：压扁扁平,先map再flatten；一个对象输出多个对象
val list = List(1,2,3,4,5)
//filter 4,5,6
val list1 = list.filter { x => x>3 }
list1.foreach { println}
//count 2
val value = list1.count { x => x>3 }
println(value)
//map
val stringses: List[Array[String]] = list1.map(s => {
s.split(" ")
})
stringses.foreach(arr=>arr.foreach(println))
//flatmap
val stringFlat: List[String] = list1.flatMap(s => {
s.split(" ")
})
stringFlat.foreach(println)2. 可变List
/**
* 可变长list
*/
import scala.collection.mutable.ListBuffer
val listBuffer: ListBuffer[Int] = ListBuffer[Int](1,2,3,4,5)
listBuffer.append(6,7,8,9)//追加元素
listBuffer.+=(10)//在后面追加元素
listBuffer.+=:(100)//在开头加入元素
listBuffer.foreach(println)
四、Set
1. 不可变Set
set集合会自动去重
（1）创建与遍历
//创建
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)
//遍历
//注意：set会自动去重
set1.foreach { println}
for(s <- set1){
println(s)
}（2）方法
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)
//交集 1,2
val set3 = set1.intersect(set2)
val set4 = set1.&(set2)
//差集 3,4
set1.diff(set2).foreach { println }
set1.&~(set2).foreach { println }
//子集 false
set1.subsetOf(set2)
//最大值
println(set1.max)
//最小值
println(set1.min)
//转成数组，list
set1.toArray.foreach{println}
set1.toList.foreach{println}
//mkString 1234 1 2 3 4
println(set1.mkString)
println(set1.mkString("\t"))
2. 可变长Set
import scala.collection.mutable.Set
val set = Set[Int](1,2,3,4,5)
set.add(100)
set.+=(200)
set.+=(1,210,300)
set.foreach(println)
五、Map
1. 不可变Map
（1）创建及遍历
- 创建map时，相同的key被后面的相同的key顶替掉，只保留一个
//创建不可变map
//方式1
Map[String, Int]( ("c", 300), ("d", 400) )
//方式2
Map[String, Int]("a" -> 100, "b" -> 200)
val map: Map[String, Int] = Map[String, Int]("a" -> 100, "b" -> 200, ("c", 300), ("c", 400))
// Map(a -> 100, b -> 200, c -> 400)
println(map)（2）方法
- 获取map指定key的value值
//获取值
println(map.get("1").get)
//若没有指定键，则返回 默认 no value
val result = map.get(8).getOrElse("no value")
println(result)
- 遍历map
// ._1 代表 key值，._2代表value值
for(x <- map){
println("====key:"+x._1+",value:"+x._2)
}
map.foreach(f => {
println("key:"+ f._1+" ,value:"+f._2)
})
- 遍历key以及遍历value
//遍历key,返回的是 Iterable类型
val keyIterable = map.keys
keyIterable.foreach { key => {
println("key:"+key+", value:"+map.get(key).get)
} }
//遍历value,返回的是 Iterable类型
val valueIterable = map.values
valueIterable.foreach { value => {
println("value: "+ value)
} }
- 合并map：合并map会将map中的相同key的value替换
- ++ 例：map1.++(map2) --map1中加入map2
- ++: 例：map1.++:(map2) –map2中加入map1
//合并map
val map1 = Map(
(1,"a"),
(2,"b"),
(3,"c")
)
val map2 = Map(
(1,"aa"),
(2,"bb"),
(2,90),
(4,22),
(4,"dd")
)
//(1,a) (2,b) (4,dd) (3,c)
map1.++:(map2).foreach(println)
- filter:过滤，留下符合条件的记录
- count:统计符合条件的记录数
- contains：map中是否包含某个key
- exist：符合条件的记录存在不存在
//count 返回数量
val countResult = map.count(p => { p._2.equals("shsxt")})
//filter 返回key/value值 符合条件的
map.filter(_._2.equals("shsxt")).foreach(println)
//contains 返回boolean 检查key值
println(map.contains(2))
//exist
println(map.exists(f =>{ f._2.equals("xasxt")}))
2. 可变Map
- put方法往map中填数
import scala.collection.mutable.Map
val map = Map[String,Int]()
map.put("hello",100)
map.put("world",200)
map.foreach(println)
六、元组
与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。
（1）创建
- val tuple = new Tuple（1） 可以使用new
- val tuple2 = Tuple（1,2） 可以不使用new，也可以直接写成val tuple3 =（1,2,3）
- 取值用”._XX” 可以获取元组中的值
-
tuple最多支持22个参数
//创建，最多支持22个
val tuple = new Tuple1(1)
val tuple2 = Tuple2("zhangsan",2)
val tuple3 = Tuple3(1,2,3)
val tuple4 = (1,2,3,4)
val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)
//使用
println(tuple2._1 + "\t"+tuple2._2)
val t = Tuple2((1,2),("zhangsan","lisi"))
//获取元组第一个元素的value——2
println(t._1._2)
（2）遍历
- tuple.productIterator得到迭代器，进而遍历
val tupleIterator = tuple22.productIterator
while(tupleIterator.hasNext){
println(tupleIterator.next())
}（3）方法
//翻转，只针对二元组 ("a",1)——————>(1,"a")
println(tuple2.swap)
//toString (1,2,3)
val tuple3 = Tuple3(1,2,3)
println(tuple3.toString())
扫一扫
8501
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
