Scala入门到放弃——集合（十一）

十五、集合

Scala提供了一套很好的集合实现，提供了一些集合类型的抽象。

Scala 集合分为可变的和不可变的集合：

• 可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。
• 不可变集合（默认）类永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。

集合中基本结构：

序列

Vector（向量）

Vector是ArrayBuffer的不可变版本：有下标，支持快速的随机访问，树形结构实现

scala> var vector=Vector(1,2,3)
vector: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3)

scala> var vector=for(i<- 0 to 10 by 2) yield i
vector: scala.collection.immutable.IndexedSeq[Int] = Vector(0, 2, 4, 6, 8, 10)

Ranage（区间）

一个整数序列

scala> var range=new Range(1,10,2) // 类似与until
range: scala.collection.immutable.Range = inexact Range 1 until 10 by 2
scala> var range=Range(1,10 ,2)  // 类似与until
range: scala.collection.immutable.Range = inexact Range 1 until 10 by 2
scala> var range=0 to 10 by 2
range: scala.collection.immutable.Range = Range 0 to 10 by 2
scala> var range=0 until 10 by 2
range: scala.collection.immutable.Range = Range 0 until 10 by 2

List （不可变列表）

scala.collection.inmutable.List

Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是。

创建

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

使用

println(list(0))

List与Array的区别

//list(2) = 10 // error: List一旦创建，已有元素的值不能改变，可以使用添加元素或删除元素生成一个新的集合返回                                                                                                                       

空列表（Nil）

val list2 = Nil // Nil 返回一个空集合  List()

元素的追加

Note：向列表中增加元素，会返回新的列表/集合对象

val list5 = List(4,5,6)
val list6 = list5:+7 // 在列表的末尾加入元素7 并返回一个新的列表
val list7 = 3+:list5 // 在列表的开头加入元素3 并返回一个新的列表
println(list5.mkString(",")) //4,5,6
println(list6.mkString(",")) //4,5,6,7
println(list7.mkString(",")) //3,4,5,6

::和:::操作符介绍

:: 表示从给定的头和尾新建集合，添加元素整体

::: 表示新建集合，添加集合中的一个个的元素内容

val list3 = List(1, 2, 3)
val list4 = List("a", "b") :: list3  // 将List("a","b") 作为整体添加到list3的集合头部
val list8 = List("a", "b") ::: list3  // 将List("a","b")内容展开，添加到list3集合的头部
println(list4.mkString(",")) // List(a, b),1,2,3
println(list8.mkString(",")) // a,b,1,2,3

ListBuffer （可变列表）

scala.collection.mutable.ListBuffer是一个可变的列表集合

创建

# 注意，需要导入可变集合的类
import scala.collection.mutable._

val list01 = ListBuffer(4, 5, 6)

使用

list01.append(7) // 追加
println(list01.mkString(","))
list01 += 8 // 另外一种追加
println(list01.mkString(","))
list01 ++= List(9, 10)  // 将集合中的元素追加到ListBuffer中
println(list01.mkString(","))
3 +=: list01 // 将3置于ListBuffer的头部
println(list01.mkString(","))
list01.remove(1) // 删除下标为1的元素
println(list01.mkString(","))  //3,5,6,7,8,9,10
list01 -= 5 // 删除元素为5
println(list01.mkString(",")) //3,6,7,8,9,10
// 删除元素为6
println((list01 - 6).mkString(",")) // 3,7,8,9,10

注意：

​ 集合中的操作符中有 =，表示对集合中元素的操作，不会产生新的集合

​ 集合中的操作符中没有 =，表示操作结束后，会产生返回一个新的结合

Set（不可变）

scala> val s=scala.collection.immutable.Set(1,2,3)
s: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
scala> for(i <- s) print(i+",") 1,2,3,

Set (可变)

val s=scala.collection.mutable.Set(1,2,3) 
s-=1
s+=(4,5,6)
s.remove(5)
for(i <- s) print(i+",") 

Map

创建

# 创建不可变的map集合
scala> val map = Map("bj" -> "北京", "tj" -> "天津", "sh" -> "上海")
map: scala.collection.immutable.Map[String,String] = Map(bj -> 北京, tj -> 天津, sh -> 上海)

# 创建可变的map集合
scala> val map = scala.collection.mutable.Map[String,String]("bj" -> "北京", "tj" -> "天津", "sh" -> "上海")
map: scala.collection.mutable.Map[String,String] = Map(tj -> 天津, bj -> 北京, sh -> 上海)

scala> map("bj")="aa"

scala> map
res9: scala.collection.mutable.Map[String,String] = Map(tj -> 天津, bj -> aa, sh -> 上海)

# 另外一种创建map集合的方式
scala> val map = scala.collection.mutable.Map(("bj","北京"),("tj","天津"))
map: scala.collection.mutable.Map[String,String] = Map(tj -> 天津, bj -> 北京)

使用

# 新增kv
scala> map+=(("zz","郑州"))
res8: map.type = Map(tj -> 天津, zz -> 郑州, bj -> aa, sh -> 上海)

# 新增另一种方法  mp.put(k,v)

# 移除kv
scala> map-=(("zz"))
res10: map.type = Map(tj -> 天津, bj -> aa, sh -> 上海)

// 根据k获取v
scala> map("tj")
res12: String = 天津

# 可排序的map集合
scala> val map = scala.collection.mutable.SortedMap[String,String]("bj" -> "北京", "tj" -> "天津", "sh" -> "上海","aq"->"安庆")
map: scala.collection.mutable.SortedMap[String,String] = TreeMap(aq -> 安庆, bj -> 北京, sh -> 上海, tj -> 天津)

遍历

scala>  for((k,v) <- map) println(k + " " + v)
aq 安庆
bj 北京
sh 上海
tj 天津

Tuple（元组）

在 Scala 中，元组是一个可以容纳不同类型元素的类。 元组是不可变的。

创建

// 创建
val t1 = (1, "zs", false, 10.0)
println(t1.getClass)  //Tuple4

使用

使用下划线语法来访问元组中的元素。 ‘tuple._n’ 取出了第 n 个元素（假设有足够多元素）

// 使用
println(t1._1)
println(t1._2)
println(t1._3)
println(t1._4)

// 或使用
// 通过productElement获取元组内容 
println(t1.productElement(0)) // 下标

元组的遍历

// 元组的遍历
for(item <- t1.productIterator){
    println("item:"+item)
}

scala的解释器窗口，要写入多行代码时，可以使用 :paste , 结束后使用ctrl+d

Java和Scala集合的转换

https://docs.scala-lang.org/zh-cn/overviews/collections/conversions-between-java-and-scala-collections.html

package com.baizhi.array

import scala.collection.mutable._
import scala.collection.JavaConverters._


object ArrayToListDemo01 {
  def main(args: Array[String]): Unit = {
    // scala集合转为java.util.List
    val arr = ArrayBuffer[Integer](1, 2, 3, 4, 5).asJava
    //A.m1(arr)
    //println(arr.getClass)

    // java.util.List转为scala集合
    val arr2 = arr.asScala
    println(arr2.getClass)
  }
}