Scala-集合篇
2020-08-05 本文已影响0人
flood_d
0.Scala数据结构关系图
scala数据结构关系图.jpg
Scala中的集合类可以分为三大类：
- Seq，是一组有序的元素。
- Set，是一组没有重复元素的集合。
- Map，是一组k-v对。
1.List-有序的对象集合
1.1定义
Scala 列表类似于数组，它们所有元素的类型都相同，但是列表是不可变的，值一旦被定义了就不能改变。
Nil代表空List。
列表的元素类型 T 可以写成 List[T]。
例如，以下列出了多种类型的列表：
// 字符串列表
val site: List[String] = List("FangDD", "Google", "Baidu")
// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)
// 空列表
val empty: List[Nothing] = List()
// 二维列表
val dim: List[List[Int]] =
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1)
)
1.2常用操作
- 创建List
//------------------创建List------------------
val feeds1 = List("blog.toolshed.com", "pragdave.me", "blog.agiledeveloper.com")
val feeds2 = "blog.toolshed.com"::("pragdave.me"::( "blog.agiledeveloper.com"::Nil))
val feeds3 = Nil
print("feeds1:")
feeds1.foreach(x=>print(x+" "))
println("")
print("feeds2:")
feeds2.foreach(x=>print(x+" "))
- 元素操作
head 返回列表第一个元素。
tail 返回一个列表，包含除了第一元素之外的其他元素。
isEmpty 在列表为空时返回true。
ListName(index)可取列表的指定元素，实际调用的是ListName的apply方法。
//------------------元素操作------------------
val site = "FangDD" :: ("Google" :: ("Baidu" :: Nil))
val nums = Nil
println( "第一元素 : " + site.head )
println( "第一元素 : " + site(0) )
println( "另外一种方式取第一元素 : " + site.apply(0) )
println( "尾部元素 : " + site.tail )
println( "查看列表 site 是否为空 : " + site.isEmpty )
println( "查看 nums 是否为空 : " + nums.isEmpty )
- List操作
::: 运算符、 List.:::() 方法、 List.concat() 方法 来连接两个或多个列表。
List常用for循环遍历、foreach循环遍历。
//------------------List连接------------------
val list1 = "FangDD" :: ("Google" :: ("Baidu" :: Nil))
val list2 = "Facebook" :: ("Taobao" :: Nil)
// 使用 ::: 运算符
var myList = list1 ::: list2
println( "list1 ::: list2 : " + myList )
// 使用 List.:::() 方法
myList = list1.:::(list2)
println( "list1.:::(list2) : " + myList )
// 使用 concat 方法
myList = List.concat(list1, list2)
println( "List.concat(list1, list2) : " + myList )
//------------------List遍历------------------
val list4 = "FangDD" :: ("Google" :: ("Baidu" :: Nil))
print("\nfor循环:")
for(e <- list4)print(e+" ")
print("\nforeach循环:")
list4.foreach(e => print(e+" "))
1.3其他操作
def +:(elem: A): List[A]
为列表预添加元素
def ::(x: A): List[A]
在列表开头添加元素
def :::(prefix: List[A]): List[A]
在列表开头添加指定列表的元素
def :+(elem: A): List[A]
复制添加元素后列表。
def addString(b: StringBuilder): StringBuilder
将列表的所有元素添加到 StringBuilder
def addString(b: StringBuilder, sep: String): StringBuilder
将列表的所有元素添加到 StringBuilder，并指定分隔符
def apply(n: Int): A
通过列表索引获取元素
def contains(elem: Any): Boolean
检测列表中是否包含指定的元素
def distinct: List[A]
去除列表的重复元素，并返回新列表
def drop(n: Int): List[A]
丢弃前n个元素，并返回新列表
......
2.Set-无序的集合
2.1定义
Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。
Scala 集合分为可变的和不可变的集合，分别在scala.collection.mutable.Set 包和scala.collection.immutable.Set包下面，默认引用 scala.collection.immutable.Set。
2.2常用操作
- 创建Set
//------------------创建Set------------------
val set = Set(1,2,3)
println(set.getClass.getName) // scala.collection.immutable.HashSet
import scala.collection.mutable.Set // 可以在任何地方引入 可变集合
val mutableSet = Set(1,2,3)
println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet
mutableSet.add(4)
mutableSet.remove(1)
mutableSet += 5
mutableSet -= 2
println(mutableSet) // Set(5, 3, 4)
val another = mutableSet.toSet
println(another.getClass.getName) // scala.collection.immutable.Set
- 元素操作
head 返回集合第一个元素。
tail 返回一个集合，包含除了第一元素之外的其他元素。
isEmpty 在集合为空时返回true。
//------------------元素操作------------------
val site = Set("FangDD", "Google", "Baidu")
val nums: Set[Int] = Set()
println( "第一元素是 : " + site.head )
println( "尾部元素 : " + site.tail )
println( "查看列表 site 是否为空 : " + site.isEmpty )
println( "查看 nums 是否为空 : " + nums.isEmpty )
- Set操作
++ 运算符、 Set.++() 方法来连接两个集合，如果元素有重复的就会移除重复的元素。
Set遍历，for循环遍历、foreach循环遍历。
//------------------Set连接------------------
val site1 = Set("FangDD", "Google", "Baidu")
val site2 = Set("Faceboook", "Taobao")
// ++ 作为运算符使用
var site3 = site1 ++ site2
println( "site1 ++ site2 : " + site3 )
// ++ 作为方法使用
site3 = site1.++(site2)
println( "site1.++(site2) : " + site3 )
//------------------Set遍历------------------
val site4 = Set("FangDD", "Google", "Baidu")
print("\nforeach循环:")
site4.foreach(e => print(e+" "))
print("\nfor循环:")
for(e <- site4)print(e+" ")
2.3其他操作
def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
def &(that: Set[A]): Set[A]
返回两个集合的交集
def &~(that: Set[A]): Set[A]
返回两个集合的差集
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
def ++(elems: A): Set[A]
合并两个集合
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
def apply(elem: A)
检测集合中是否包含指定元素
......
3.Map-键值对字典
3.1定义
Map(映射)是一种可迭代的键值对（key/value）结构，其中键都是唯一的。
Map 有可变与不可变两种类型，分别在scala.collection.mutable.Map包和scala.collection.immutable.Map包下面，默认引用scala.collection.immutable.Map包。
3.2常用操作
- 创建Map
//------------------创建Map------------------
var A1:Map[Char,Int] = Map()
println(A1.getClass.getName) //scala.collection.immutable.Map$EmptyMap$
import scala.collection.mutable.Map
val A2 = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
println(A2.getClass.getName) //scala.collection.mutable.HashMap
- 元素操作
keys ,返回 Map 所有的键(key)。
values,返回 Map 所有的值(value)。
isEmpty,判断 Map 是否为空。
//------------------元素操作------------------
val map = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val nums: Map[Int, Int] = Map()
println( "map 中的键为 : " + map.keys )
println( "map 中的值为 : " + map.values )
println( "检测 map 是否为空 : " + map.isEmpty )
println( "检测 nums 是否为空 : " + nums.isEmpty )
- Map操作
++ 运算符、 Map.++() 方法来连接两个 Map，Map 合并时会移除重复的 key。
Map常用key值遍历、foreach遍历。
//------------------Map连接------------------
val map1 = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val map2 = Map("blue" -> "#0033FF",
"yellow" -> "#FFFF00",
"red" -> "#FF0000")
// ++ 作为运算符
var map3 = map1 ++ map2
println( "map1 ++ map2 : " + map3 )
// ++ 作为方法
map3 = map1.++(map2)
println( "map1.++(map2) : " + map3 )
//------------------Map遍历------------------
val map4 = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
println("\nkey循环:")
map4.keys.foreach(key => {
val v = map4(key)
val kv = s"key: $key, value: $v"
println(kv)
})
println("\nforeach循环:")
map4.foreach(println)
3.3其他操作
def ++(xs: Map[(A, B)]): Map[A, B]
返回一个新的 Map，新的 Map xs 组成
def -(elem1: A, elem2: A, elems: A*): Map[A, B]
返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems。
def --(xs: GTO[A]): Map[A, B]
返回一个新的 Map, 移除 xs 对象中对应的 key
def get(key: A): Option[B]
返回指定 key 的值
def iterator: Iterator[(A, B)]
创建新的迭代器，并输出 key/value 对
def addString(b: StringBuilder): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
def addString(b: StringBuilder, sep: String): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
def apply(key: A): B
返回指定键的值，如果不存在返回 Map 的默认方法
def clear(): Unit
清空 Map
def clone(): Map[A, B]
从一个 Map 复制到另一个 Map
def contains(key: A): Boolean
如果 Map 中存在指定 key，返回 true，否则返回 false。
......
4.元组Tuple
4.1定义
与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。
元组的值是通过将单个的值包含在圆括号()中构成的，目前Scala 支持的元组最大长度为 22。
4.2常用操作
- 创建Tuple
//------------------创建Tuple------------------
println("\n------------------创建Tuple------------------")
val t1 = (1, 3.14, "Fred")
val t2 = new Tuple3(1, 3.14, "Fred")
val funTuple = createTuple
println("funTuple:"+funTuple._1+":"+funTuple._2+":"+funTuple._3)
- 元素操作
//------------------元素操作------------------
println("\n------------------元素操作------------------")
val t3 = (4,3,2,1)
val sum = t3._1 + t3._2 + t3._3 + t3._4
println( "元素之和为: " + sum )
val t4 = new Tuple3(1, "hello", "FANGDD")
println("连接后的字符串为: " + t4.toString() )
- Tuple操作
//------------------Tuple连接------------------
println("\n------------------Tuple连接------------------")
val t5 = (4,3,2,"6")
val t6 = (7,8,9,"10")
//待定
//------------------Tuple遍历------------------
println("\n------------------Tuple遍历------------------")
val t8 = (4,3,2,1,"FANGDD")
t8.productIterator.foreach{ i =>println("Value = " + i )}
5.Array
5.1定义
Scala中的数组是用来存储固定大小的同类型元素，数组中某个指定的元素是通过索引来访问的，数组的第一个元素索引为0，最后一个元素的索引为元素总数减1。
5.2常用操作
- 创建Array
//------------------创建Array------------------
println("\n------------------创建Array------------------")
//创建类型为String长度为3的数组
val arr2 = Array[String]("s100","s200","s300")
// 创建类型为Int 长度为3的数组
val arr1 = new Array[Int](3)
- 元素操作
//------------------元素操作------------------
println("\n------------------元素操作------------------")
val arr4 = new Array[Int](3)
// 赋值
arr4(0) = 100
arr4(1) = 200
arr4(2) = 300
- Array操作
//------------------Array遍历------------------
println("\n------------------Iterator遍历------------------")
// 遍历两种方式
val arr3 = Array[String]("s100","s200","s300")
for(i <- arr3){
print(i+" ")
}
println("")
arr3.foreach(i => {
print(i+" ")
})
文本资源来自于互联网和书本整理，仅供学习，有侵权联系删除。
