scala快速上手(五) Scala 集合

Scala 集合

数组

1. 创建数组

• new Array[Int](10)

赋值：arr(0) = xxx

• Array[String](“s1”,”s2”,”s3”)

2. 数组遍历

•  for
•  foreach

3. 创建一维数组和二维数组

4. 数组中方法举例

•  Array.concate：合并数组
•  Array.fill(5)(“zhangsan”)：创建初始值的定长数组

创建两种方式:

/**
* 创建数组两种方式：
* 1.new Array[String](3)
* 2.直接 Array
*/

//创建类型为 Int 长度为 3 的数组
val arr1 = new Array[Int](3)
//创建 String 类型的数组，直接赋值
val arr2 = Array[String]("s100","s200","s300")
//赋值
arr1(0) = 100
arr1(1) = 200
arr1(2) = 300

遍历两种方式：

/**
* 遍历两种方式
*/
for(i <- arr1){
	println(i)
}
arr1.foreach(i => {
	println(i)
})

for(s <- arr2){
	println(s)
}
arr2.foreach {
	x => println(x)
}

创建二维数组:

/**
* 创建二维数组和遍历
*/
val arr3 = new Array[Array[String]](3)
arr3(0)=Array("1","2","3")
arr3(1)=Array("4","5","6")
arr3(2)=Array("7","8","9")
for(i <- 0 until arr3.length){
	for(j <- 0 until arr3(i).length){
		print(arr3(i)(j)+" ")
	}
	println()
}

var count = 0
for(arr <- arr3 ;i <- arr){
	if(count%3 == 0){
		println()
	}
	print(i+" ")
	count +=1
}

arr3.foreach { arr => {
	arr.foreach { println }
}}


val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
arr4.foreach { arr => {
	arr.foreach(i => {
		println(i)
	})
}}
println("-------")
for(arr <- arr4;i <- arr){
	println(i)
}

数组中的方法:

5. 可变长数组

/**
* 可变长度数组的定义
*/

val arr = ArrayBuffer[String]("a","b","c")
arr.append("hello","scala")//添加多个元素
arr.+=("end")//在最后追加元素
arr.+=:("start")//在开头添加元素
arr.foreach(println)

list

1. 创建 list

val list = List(1,2,3,4)

• Nil 长度为 0 的 list

2. list 遍历

foreach ，for

3. list 方法举例

•  filter:过滤元素
•  count:计算符合条件的元素个数
•  map：对元素操作
•  flatmap ：压扁扁平,先 map 再 flat

//创建
val list = List(1,2,3,4,5)

//遍历
list.foreach { x => println(x)}
// list.foreach { println}
//filter
val list1 = list.filter { x => x>3 }
list1.foreach { println}

//count
val value = list1.count { x => x>3 }
println(value)

//map
val nameList = List(
"hello zhangsan",
"hello xasxt",
"hello shsxt"
)
val mapResult:List[Array[String]] = nameList.map{ x => x.split("") }
mapResult.foreach{println}

//flatmap
val flatMapResult : List[String] = nameList.flatMap{ x =>x.split(" ") }
flatMapResult.foreach { println }

4. list 方法总结

5. 可变长 List

/**
* 可变长 list
*/
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 集合会自动去重

2. set 遍历

foreach，for

3. set 方法举例

•  交集：intersect ,&
•  差集: diff ,&~
•  子集:subsetOf
•  最大:max
•  最小:min
•  转成数组，toList
•  转成字符串：mkString(“~”)

4. set 方法总结

//创建
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)
//遍历
//注意：set 会自动去重
set1.foreach { println}
for(s <- set1){
	println(s)
}
println("*******")
/**
* 方法举例
*/

//交集
val set3 = set1.intersect(set2)
set3.foreach{println}
val set4 = set1.&(set2)
set4.foreach{println}
println("*******")
//差集
set1.diff(set2).foreach { println }
set1.&~(set2).foreach { println }
//子集
set1.subsetOf(set2)

//最大值
println(set1.max)
//最小值
println(set1.min)
println("****")

//转成数组，list
set1.toArray.foreach{println}
println("****")
set1.toList.foreach{println}

//mkString
println(set1.mkString)
println(set1.mkString("\t"))

set 方法总结

5. 可变长 set

/**
* 可变长 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 创建

•  Map（1 –>”zhangsan’）
•  Map((1,”zhangsan”))

注意：创建 map 时，相同的 key 被后面的相同的 key 顶替掉，只保留一个。

val map = Map(
	"1" -> "zhangsan",
	 2 -> "shsxt",
	(3,"xasxt")
)

2. 获取 map 的值

• map.get(“1”).get
• map.get(100).getOrElse(“no value”)：如果 map 中没有对应项，赋值为getOrElse 传的值。

//获取值
println(map.get("1").get)
val result = map.get(8).getOrElse("no value")
println(result)

3. 遍历 map

•  for,foreach

//map 遍历
for(x <- map){
	println("====key:"+x._1+",value:"+x._2)
}
map.foreach(f => {
	println("key:"+ f._1+" ,value:"+f._2)
})

4. 遍历 key

•  map.keys

//遍历 key
val keyIterable = map.keys
keyIterable.foreach { key => {
	println("key:"+key+", value:"+map.get(key).get)
}}
println("---------")

5. 遍历 value

• map.values

//遍历 value
val valueIterable = map.values
valueIterable.foreach { value => {
	println("value: "+ value)
} }

6. 合并 map

•  ++ 例：map1.++(map2) --map1 中加入 map2
•  ++: 例：map1.++:(map2) –map2 中加入 map1

注意：合并 map 会将 map 中的相同 key 的 value 替换

//合并 map
val map1 = Map(
	(1,"a"),
	(2,"b"),
	(3,"c")
)
val map2 = Map(
	(1,"aa"),
	(2,"bb"),
	(2,90),
	(4,22),
	(4,"dd")
)
map1.++:(map2).foreach(println)

7. map 中的方法举例

•  filter:过滤，留下符合条件的记录
•  count:统计符合条件的记录数
•  contains：map 中是否包含某个 key
•  exist：符合条件的记录存在不存在

/**
* map 方法
*/
//count
val countResult = map.count(p => {
	p._2.equals("shsxt")
})
println(countResult)

//filter
map.filter(_._2.equals("shsxt")).foreach(println)

//contains
println(map.contains(2))

//exist
println(map.exists(f =>{
	f._2.equals("xasxt")
}))

Map 方法总结

8. 可变长 map

/**
* 可变长 Map
*/
import scala.collection.mutable.Map
val map = Map[String,Int]()
map.put("hello",100)
map.put("world",200)
map.foreach(println)

元组

1. 元组定义

与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。

2. 创建元组与取值

•  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"))
println(t._1._2)

3. 元组的遍历

tuple.productIterator 得到迭代器，进而遍历

//遍历
val tupleIterator = tuple22.productIterator
while(tupleIterator.hasNext){
	println(tupleIterator.next())
}

4. swap,toString 方法

注意：swap 元素翻转，只针对二元组

/**
* 方法
*/
//翻转，只针对二元组
println(tuple2.swap)

//toString
println(tuple3.toString())