scala不同集合的常用方法

最新推荐文章于 2023-07-13 11:15:19 发布

猛肝自然强

最新推荐文章于 2023-07-13 11:15:19 发布

阅读量146

点赞数 2

分类专栏： scala

本文链接：https://blog.csdn.net/LastYHM/article/details/108670559

版权

scala 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

在操作集合的时候，不可变用符号，可变用方法
不可变集合继承图:
在这里插入图片描述
可变集合继承图:

不可变数组

// 1. 创建一个不可变数组
    // 1) new
    val arr1: Array[Int] = new Array[Int](5)
    // 2) 用伴生对象的apply方法
    val arr2: Array[Int] = Array(1,2,3,4,5)

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

    // 2. 访问数组中元素，做读写操作
    println(s"${arr1(0)} ${arr1.apply(1)} ${arr1(2)} ${arr1(3)} ${arr1(4)}" )
//    println(s"${arr1(5)}")
    arr1(3) = 13
    arr1.update(0, 48)    // arr1(0) = 48
    arr2(2) = 27

    println(arr1.mkString(" "))
    println(arr2.mkString("-"))

    // 3. 遍历所有元素
    // 1) for循环，遍历索引
    for( i <- 0 until arr2.length )
      print(arr2(i) + "\t")

    println()

    for( i <- arr2.indices ) print(arr2(i) + "\t")
    println()

    // 2) for循环直接遍历元素
    for( elem <- arr2 ) print(elem + "\t")

    println()

    // 3) 迭代器
    val iter: Iterator[Int] = arr2.iterator
    while(iter.hasNext)
      print(iter.next() + "\t")

    println()

    // 4) foreach方法
    arr2.foreach( elem => print(elem + "\t") )
    println()
    arr2.foreach( println )

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

    // 4. 向数组中添加元素
    // 生成一个新的数组，原数组不变
    val newArr1: Array[Int] = arr2.:+(20)
    println(arr2.mkString(" "))
    println(newArr1.mkString(" "))

    val newArr2: Array[Int] = newArr1.+:(63)
    println(newArr2.mkString(" "))

    val newArr3 = 15 +: arr1 :+ 39 :+ 9
    val newArr4 = 29 +: 15 +: newArr3
    println(newArr4.mkString(" "))

可变数组

// 1. 创建一个可变数组
    val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
    val arr2 = ArrayBuffer(3, 56, 29)

    println(arr1)
    println(arr2)

    // 2. 访问数组元素进行读写操作
    println(arr2(1))
    arr2(0) = 12
    println(arr2)

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

    // 3. 向数组中添加元素
//    val newArr1 = arr1 :+ 59
//    println(newArr1)

    arr1.append(23)
    println(arr1)
    arr1.append(35, 71)
    println(arr1)

    arr1.prepend(8, 13)
    println(arr1)

    arr1.insert(1, 46, 92)
    println(arr1)

    // 符号方法的调用
    println(arr2)
    arr2 += 23 += 25
    println(arr2)
    37 +=: arr2
    println(arr2)

    // 4. 删除元素
    val a = arr2.remove(2)    // 按索引位置删除
    println(arr2)
    println(a)

    arr2 -= 23    // 按元素值删除
    println(arr2)

    // 5. 增加另一个数组的所有元素
    arr2.appendAll( ArrayBuffer(27,47,80) )
    println(arr2)
    arr2 ++=: arr1
    println(arr1)
    println(arr2)

    // 6. 可变数组和不可变数组的转换
    val arr: ArrayBuffer[Int] = ArrayBuffer(2,4,7)
    val newArr: Array[Int] = arr.toArray
    println(newArr.mkString("-"))
    println(arr)

    val buffer = newArr.toBuffer
    println(buffer)
    println(newArr)

多维数组

// 1. 创建一个二维数组
    val arr: Array[Array[Int]] = Array.ofDim[Int](2, 3)

    // 2. 访问数组中元素，进行读写
    println(arr(1)(0))
    arr(1)(0) = 27
    println(arr(1)(0))
    arr(0)(2) = 59

    // 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 ) )

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

    // 创建一个五维数组，2*3*4*5*6，（0，2，1，3，4）元素值为100，遍历数组
    val arr2: Array[Array[Array[Array[Array[Int]]]]] = Array.ofDim[Int](2,3,4,5,6)
    arr2(0)(2)(1)(3)(4) = 100

    arr2.foreach( _.foreach( _.foreach( _.foreach( _.foreach( println ) ) ) ) )

不可变列表

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

    println(list1)

    println(list1(2))

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

    // 2. 添加元素，得到一个新的list
    val list2 = 12 +: list1
    val list3 = list2 :+ 39
    println(list1)
    println(list2)
    println(list3)

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

    // 3. 空列表以及创建列表的另一种方法
    val list4 = 70 :: 28 :: 17 :: Nil
    val list5 = list1.::(50)
    println(list4)
    println(list5)


    // 4. 合并两个列表，扁平化
    val list6 = list4 :: list5
    println(list6)
    val list7 = list4 ::: list5
    println(list7)

    val list8 = list4 ++ list5
    println(list8)

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

可变列表

// 1. 创建一个可变列表
    val list1: ListBuffer[Int] = new ListBuffer[Int]()
    val list2 = ListBuffer(34, 53, 68, 91)

    println(list1)
    println(list2)

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

    // 2. 添加元素
//    val list = 23 :: list1.toList
    list1.append(10, 25)
    list1.prepend(36)
    list1.insert(1, 20)

    12 +=: list1 += 18 += 49
    println(list1)

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

    // 3. 合并两个列表
    val list3 = list1 ++ list2
    println(list1)
    println(list2)
    println(list3)

    list1 ++= list2
    list1 ++=: list2
    println(list1)
    println(list2)

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

    // 4. 删除元素
    list3.remove(1, 3)

    list2 -= 34

    println(list2)
    println(list3)

//    val list4 = list2 - 23

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

不重复集合

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

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

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

    // 3. 合并set
    val set3 = Set(13, 17, 129)
    val set4 = set2 ++ set3
    println(set2)
    println(set3)
    println(set4)

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

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

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

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

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

    println(set6)
    println(flag1)

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

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

    val set8 = set6.union(set7)

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

映射map

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

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

    // 3. 遍历所有元素
    map1.foreach( println )
    map1.foreach( (elem: (String, Int)) => println(elem) )

    for( kv <- map1 ) println(kv)

    for( key <- map1.keys ) print(key + "\t")

    println()

    for( value <- map1.values ) print(value + "\t")

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

    // 二、可变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"
    println(map2)

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

    println("=====================")
    // 5. 合并两个map
    println(map1)
    println(map2)

    val map3 = map1 ++ map2
    val map4 = map2 ++ map1
    println(map1)
    println(map2)
    println(map3)
    println(map4)

    println("=====================")
    map2 ++= map1
    println(map1)
    println(map2)

元组

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

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

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

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

    // 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)