Scala集合及其相关操作

Scala集合及其相关操作

1，简介

1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。

2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包

​ 不可变集合：scala.collection.immutable

​ 可变集合： scala.collection.mutable

3）Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象

4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于java中StringBuilder对象

建议：在操作集合的时候，不可变用符号，可变用方法

2、数组

2.1 不可变数组

1. 创建数组

//1.new的方式
val arr1: Array[Int] = new Array[Int](5)
//2.使用伴生对象
val arr2: Array[Int] = Array(1,2,3,4,5)

2. 访问数组

println(s"${arr1(0)} ${arr1.apply(1)} ${arr1(2)} ${arr1(3)} ${arr1(4)}" )
//Array数组的读写（仅支持更新操作）
arr1(3) = 13
arr1.update(0, 48) //arr1(0)=48 
println(arr1.mkString(" "))

3） 遍历所有元素

//1	for循环遍历
for( i <- 0 until arr2.length ) print(arr2(i) + "\t")
//简化
for( i <- arr2.indices ) print(arr2(i) + "\t")
//2	for循环直接遍历元素
for( elem <- arr2 ) print(elem + "\t")
//3 迭代器
val iter: Iterator[Int] = arr2.iterator
while(iter.hasNext) print(iter.next() + "\t")
//4 foreach方法
arr2.foreach( elem => print(elem + "\t") )
arr2.foreach( println )

4） 向数组中添加元素

//生成一个新的数组，原数组不变
//末尾添加元素
val newArr1: Array[Int] = arr2.:+(20)
val newArr2: Array[Int] = arr2 :+ 30
//开头添加元素
val newArr3: Array[Int] = 40 +: arr2

2.2 可变数组

1） 创建一个可变数组

//
val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
val arr2: ArrayBuffer[Int] = ArryaBuffer(1,2,3,4,5)

2） 访问数组元素进行读写操作

//
println(arr2(1))
arr2(0) = 12 //== arr2.update(0,2)

3） 向数组中添加元素

//
arr1.append(23)
//一次添加多个，默认添加到末尾
arr1.append(35, 71)
arr2 += 23 += 25
//向数组前面添加元素
arr1.prepend(8, 13)
37 +=: arr2
//在第X下标开始插入，一个或者多个元素
arr1.insert(1, 46, 92)

4） 删除元素

//按照索引位置删除，返回所删除的元素
val a = arr2.remove(2)
// 按元素值删除
arr2 -= 23

5） 增加另一个数组的所有元素

//
arr2.appendAll( ArrayBuffer(27,47,80) )
arr2 ++=: arr1

6） 可变数组和不可变数组的转换

//转不可变数组
val arr: ArrayBuffer[Int] = ArrayBuffer(2,4,7)
val newArr: Array[Int] = arr.toArray
//转为可变数组s
val buffer = newArr.toBuffer

2.3多维数组

1） 创建一个数组

//
val arr: Array[Array[Int]] = Array.ofDim[Int](2, 3)

2） 访问数组中元素，进行读写

//
println(arr(1)(0))
arr(1)(0) = 27

3） 遍历数组

//
for( i <- 0 until arr.length; j <- 0 until arr(i).length ) println(arr(i)(j))
//
for( i <- arr.indices; j <- arr(i).indices ) {
      print(arr(i)(j) + "\t")
      if( j == arr(i).length - 1 ) println()
    }
//
arr.foreach( line => line.foreach( elem => println(elem) ) )
arr.foreach( _.foreach( println ) )

3、Seq集合（List）

3.1 不可变List

1） List默认为不可变集合

2） 创建一个List（数据有顺序，可重复）

//
val list1: List[Int] = List(23, 45, 67, 91)

3） 遍历List

//
list8.foreach( println )
for( elem <- list1 ) println(elem)

4） List增加数据

//updated方法使用后得到一个新数组
list1.updated(1,2)
//添加元素，得到一个新的list
val list2 = 12 +: list1
val list3 = list2 :+ 39
//添加到头部
val list5 = list1.::(50)

5） 集合间合并：将一个整体拆成一个一个的个体，称为扁平化

//
val list6 = list4 :: list5
//List(List(70, 28, 17), 50, 23, 45, 67, 91)
val list7 = list4 ::: list5
//List(70, 28, 17, 50, 23, 45, 67, 91)

6） 取指定数据

println(list1(0))

7） 空集合Nil

//空列表以及创建列表的另一种方法
val list4 = 70 :: 28 :: 17 :: Nil

3.2 可变ListBuffer

1） 创建可变列表

//
val list1: ListBuffer[Int] = new ListBuffer[Int]()
val list2 = ListBuffer(34, 53, 68, 91)

2） 添加元素

list1.append(10, 25)
list1 += 18 += 49
list1.prepend(36)
12 +=: list1 
list1.insert(1, 20)

3） 合并两个列表

//++:创建一个新的缓冲区。使用“ ++ =”从此缓冲区添加元素并返回该缓冲区本身
val list3 = list1 ++ list2
//使用++=添加合并两个列表
list1 ++= list2
list1 ++=: list2

4） 删除元素

//引用要删除的第一个元素的索引,要删除的元素数
list3.remove(1, 3)
//要删除的元素
list2 -= 34

5） 访问和修改元素

//修改元素
list3(2) = 100
list3.update(5, 168)

4、set

不可变Set

    // 1.  创建Set
    val set1: Set[Int] = Set(4, 5, 7, 9, 21, 36, 5, 22, 21)

    // 2. 添加元素，得到一个新的set
    val set2 = set1 + 29 + 17 + 40

    // 3. 合并set，得到一个新的set
    val set3 = Set(13, 17, 129)
    val set4 = set2 ++ set3

    // 4. 删除元素
    val set5 = set4 - 21

可变set

    // 1. 创建set
    val set6: mutable.Set[Int] = mutable.Set(4, 5, 7, 9, 21, 36, 5, 22, 21)

    // 2. 添加元素
//    val set7 = set6 + 45

    set6 += 45 += 123
    val flag1 = set6.add(45)

    // 3. 删除元素
    set6 -= 7
    val flag2 = set6.remove(4)
    val flag3 = set6.remove(1)

    // 4. 合并两个set
    val set7 = mutable.Set(2, 3, 56, 78)
    set6 ++= set7
	//求并集
    val set8 = set6.union(set7)

    // 5. 遍历
    for( elem <- set6 ) println(elem)
    set6.foreach( println )

5、Map

不可变map

// 1. 创建一个map
    val map1 = Map("a" -> 1, "b" -> 12, "c" ->32, "d" -> 25)

    // 2. 访问数据
//    println(map1.get("b"))
    println(map1("b"))
    println(map1.getOrElse("e", 0))

    // 3. 遍历所有元素
    map1.foreach( println )
    map1.foreach( (elem: (String, Int)) => println(elem) )
	//返回kv
    for( kv <- map1 ) println(kv)
	//返回key
    for( key <- map1.keys ) print(key + "\t")
	//返回value
    for( value <- map1.values ) print(value + "\t")

可变map

 // 1. 创建
    val map2 = mutable.Map("a" -> 1, "b" -> 12, "c" ->32, "d" -> 25)

    println("=====================")

    // 2. 添加元素
    map2.put("e", 219)

    map2 += ("f" -> 123)
    map2 += (("g", 27))
    println(map2)

    // 3. 删除元素
    map2.remove("d")
    map2 -= "a"

    // 4. 修改map中value值
    map2.update("a", 29)
    map2("a") = 30
    map2("b") = 15

    // 5. 合并两个map
	//++ 返回一个新的map
    val map3 = map1 ++ map2
    val map4 = map2 ++ map1
	//加到map2zhong 
    map2 ++= map1

6、Tuple

 // 1. 创建元组
    val tuple1 = Tuple3[Int, String, Boolean](129, "hello", true)
    val tuple2: (Int, String, Boolean) = (129, "hello", true)

    // 2. 元组和map
    val map = Map(("a", 1), ("b", 12), "c" ->32, "d" -> 25)

    // 3. 访问元组中元素
    println(tuple1._1)
    println(tuple2.productElement(0))
    println(tuple1._3)

    // 4. 遍历访问元素
    for( elem <- tuple2.productIterator ) println(elem)

    // 5. 嵌套元组
    val tuple3: (Int, Double, (String, Boolean), Char) =
      (12, 0.5, ("hello", true), 'c')

    println(tuple3._3._1)

val map = Map(("a", 1), ("b", 12), "c" ->32, "d" -> 25)

// 3. 访问元组中元素
println(tuple1._1)
println(tuple2.productElement(0))
println(tuple1._3)

// 4. 遍历访问元素
for( elem <- tuple2.productIterator ) println(elem)

// 5. 嵌套元组
val tuple3: (Int, Double, (String, Boolean), Char) =
  (12, 0.5, ("hello", true), 'c')

println(tuple3._3._1)