Scala的集合操作之可变数组和不可变数组，可变List集合与不可变List集合,可变Set与不可变Set操作，可变和不可变Map集合和元组操作

Scala的集合操作之，可变数组和不可变数组，可变List集合与不可变List集合

不可变数组

/*
traversable/ˈtrævəsəbl/adj.能越过的；可否认的
 */
object Test01_ImmutableArray {
  def main(args: Array[String]): Unit = {
    // 1. 创建数组
    val arr: Array[Int] = new Array[Int](5)
    // 另一种创建方式
  /*
    Array.apply(12, 37, 42, 58, 97)通过Array伴生对象的apply方法获取一个数组对象，
    apply方法可以省略。等价于Array(12, 37, 42, 58, 97)
  */
    val arr2 = Array(12, 37, 42, 58, 97)
    println(arr)

    // 2. 访问元素
    println(arr(0))
    println(arr(1))
    println(arr(4))
//    println(arr(5))

    arr(0) = 12
    arr(4) = 57
    println(arr(0))
    println(arr(1))
    println(arr(4))

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

    // 3. 数组的遍历
    // 1) 普通for循环
//    for (i <- 0 to arr.length-1) println(arr(i))
    for (i <- 0 until arr.length){
      println(arr(i))
    }
  /*
    源码注释：
     Produces the range of all indices of this sequence.
     @return  a `Range` value from `0` to one less than the length of this $coll.
    indices方法实际上还是返回Range伴生对象的until方法
   def indices: Range = 0 until length
   */
    for (i <- arr.indices) println(arr(i))

    println("---------------------")

    // 2) 直接遍历所有元素，增强for循环
    for (elem <- arr2) println(elem)

    println("---------------------")

    // 3) 迭代器
    val iter = arr2.iterator

    while (iter.hasNext)
      println(iter.next())

    println("---------------------")

    // 4) 调用foreach方法
    arr2.foreach( (elem: Int) => println(elem) )
   // 下面这个foreach遍历跟上面的等价
    arr.foreach( println )

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

    println("========================")
    // 4. 添加元素
    val newArr = arr2.:+(73)
    println(arr2.mkString("--"))
    println(newArr.mkString("--"))

    val newArr2 = newArr.+:(30)
    println(newArr2.mkString("--"))

    val newArr3 = newArr2 :+ 15
    val newArr4 = 19 +: 29 +: newArr3 :+ 26 :+ 73
    println(newArr4.mkString(", "))
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

可变数组ArrayBuffer

/**
 * with: 和...在一起，具有，支持的含义
 * 一个类继承一个特质用extends,多个特质用，extends ..with..
 * class 类名 extends 特质 1 with 特质 2 with 特质 3...
 */
object Test02_ArrayBuffer {
  def main(args: Array[String]): Unit = {
    // 1. 创建可变数组
    val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
    val arr2 = ArrayBuffer(23, 57, 92)

    println(arr1)
    println(arr2)

    // 2. 访问元素
//    println(arr1(0))     // error
    println(arr2(1))
    arr2(1) = 39
    println(arr2(1))

    println("======================")
    // 3. 添加元素，:+操作会返回一个新的数组对象，+=操作返回的是原数组自身对象
    val newArr1 = arr1 :+ 15
    println(arr1)
    println(newArr1)
    println(arr1 == newArr1)
    //可变数组推荐使用+=操作
    val newArr2 = arr1 += 19
    println(arr1)
    println(newArr2)
    println(arr1 == newArr2)
    newArr2 += 13
    println(arr1)

    77 +=: arr1
    println(arr1)
    println(newArr2)
    println("==============================")
    /*
       append(元素)向数组末尾添加一个元素
       prepend(元素)向数组头部添加一个元素
       insert(元素1,元素2)向数组插入多个元素
       insertAll(2, newArr)向数组2索引位置开始插入一个新的数组
       prependAll(newArr)向数组头部插入一个新的数组
     */
    arr1.append(36)
    arr1.prepend(11, 76)
    arr1.insert(1, 13, 59)
    println(arr1)

    arr1.insertAll(2, newArr1)
    arr1.prependAll(newArr2)
    println("************************")
    println("arr1: ==> " + arr1)

    /**
     * 删除操作：
     * remove(n: Int, count: Int)方法，从数组n索引位置开始删除count个元素
     * remove(n: Int)删除数组n索引位置的数据
     */
    // 4. 删除元素
    arr1.remove(3)
    println(arr1)

    arr1.remove(0, 10)
    println(arr1)
   //调用 -=方法删除某个元素
    arr1 -= 13
    println(arr1)

    // 5. 可变数组转换为不可变数组
    val arr: ArrayBuffer[Int] = ArrayBuffer(23, 56, 98)
    val newArr: Array[Int] = arr.toArray
    println(newArr.mkString(", "))
    println(arr)

    // 6. 不可变数组转换为可变数组
    val buffer: mutable.Buffer[Int] = newArr.toBuffer
    println(buffer)
    println(newArr)
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

多维数组

object Test03_MulArray {
  def main(args: Array[String]): Unit = {
    // 1. 创建二维数组
    val array: Array[Array[Int]] = Array.ofDim[Int](2, 3)

    // 2. 访问元素
    array(0)(2) = 19
    array(1)(0) = 25

    println(array.mkString(", "))
    for (i <- 0 until array.length; j <- 0 until array(i).length){
      println(array(i)(j))
    }
    for (i <- array.indices; j <- array(i).indices){
      print(array(i)(j) + "\t")
      if (j == array(i).length - 1) println()
    }

    array.foreach(line => line.foreach(println))

    array.foreach(_.foreach(println))
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

不可变List集合

/** List底层源码，Scala在List包对象中对List类型进行了重定义：type List[+A] = scala.collection.immutable.List[A]
 * 我们可以看到，这里的List实际上就是来自不可变集合包下的List.
 *  List是一个抽象类，sealed abstract class List[+A]；无法直接New对象，它继承了AbstractSeq特质，具有LinearSeq[A]等特质
 *  与List抽象类对应的有一个同名的伴生对象List,我们可以调用伴生对象的apply方法创建List[T] 集合
 */
object Test04_List {
  def main(args: Array[String]): Unit = {
    // 1. 创建一个List，不可变的List
    //val list1 = List.apply(23, 65, 87)，因为apply方法调用可以简化，直接写成List(元素1,元素2,...)
    val list1 = List(23, 65, 87)
    println(list1)

    // 2. 访问和遍历元素
    println(list1(1))
//   list没有索引
    list1.foreach(println)

    /*
    3. 添加元素
        +: 向list集合前面头部添加元素
        :+ 向list集合尾部添加元素
    */
    val list2 = 10 +: list1
    val list3 = list1 :+ 23
    println("list1: "+list1)
    println("list2: "+list2)
    println("list3: "+list3)

    println("==================")
    /**
     * 双冒号的功能：
     *  ::是Lits集合自带的方法，用于为集合添加一个元素,直接添加到集合的头部
     *  例如：list2.::(51)，在list2集合前面添加一个51的元素
     *  Nil.::(13)也可以为一个空的list集合添加一个元素
     */
    val list4 = list2.::(51)
    println("list4: "+list4)

    val list5 = Nil.::(13)
    println("list5: "+list5)

    val list6 = 73 :: 32 :: Nil
    // Nil空list集合对象，可以链式调用双冒号方法从右向左依次去添加元素
    val list7 = 17 :: 28 :: 59 :: 16 :: Nil
    println("list7: "+ list7)

    // 4. 合并列表
    val list8 = list6 :: list7
    println("list8: "+list8)
    /**
     * 三冒号和++ 操作：
     * ::: 与++ 都能实现将一个list集合所有元素加入另外一个list集合中
     */
    val list9 = list6 ::: list7
    println("list9: "+ list9)

    val list10 = list6 ++ list7
    println("list10: "+ list10)

  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

可变List集合ListBuffer操作

object Test05_ListBuffer {
  def main(args: Array[String]): Unit = {
    // 1. 创建可变列表
    val list1: ListBuffer[Int] = new ListBuffer[Int]()
    val list2 = ListBuffer(12, 53, 75)

    println("list1 ==> " + list1)
    println("list2 ==> " + list2)

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

    // 2. 添加元素
    list1.append(15, 62)
    list2.prepend(20)

    list1.insert(1, 19, 22)

    println("list1 ==> " + list1 )
    println("list2 ==> " + list2)

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

    /**
     *  +=:带冒号的操作是从右向左，向头部添加元素
     *  += 不带冒号的操作方法是默认加到list集合后边
     *
     */
    31 +=: 96 +=: list1 += 25 += 11
    println("list1 ==> " + list1)

    println("==============")
    // 3. 合并list,++操作方法是克隆原来的集合，在复制的集合上进行操作。合并后返回一个新的集合
    val list3 = list1 ++ list2
    println("list1 ==> " + list1)
    println("list2 ==> " + list2)

    println("==============")
    // ++=会直接覆盖原来的集合
    list1 ++=: list2
    println("list1 ==> " + list1)
    println("list2 ==> " + list2)

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

    // 4. 修改元素，把索引位置为3的元素修改为30
    list2(3) = 30 //它底层调用了update方法
    list2.update(0, 89)
    println("list2 ==> " + list2)

    // 5. 删除元素，指定某个索引位置的元素，也可以使用-=操作方法
    list2.remove(2)
    list2 -= 25
    println("list2 ==> " + list2)
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

不可变Set集合操作

object Test06_ImmutableSet {
  def main(args: Array[String]): Unit = {
    // 1. 创建set,使用Set的伴生对象创建Set集合，set集合无序，因此会去重
    val set1 = Set(13, 23, 53, 12, 13, 23, 78)
    println(set1)

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

    // 2. 添加元素
    //val set2 = set1.+(129)跟下面的等价
    val set2 = set1 + 129
    println(set1)
    println(set2)
    println("==================")

    // 3. 合并两个set集合，使用++操作方法，会返回一个新的set的集合
    val set3 = Set(19, 13, 23, 53, 67, 99)
    val set4 = set2 ++ set3
    println(set2)
    println(set3)
    println(set4)

    // 4. 删除元素，使用-
    val set5 = set3 - 13
    println(set3)
    println(set5)
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

可变Set集合mutable.Set操作

object Test07_MutableSet {
  def main(args: Array[String]): Unit = {
    // 1. 创建set
    val set1: mutable.Set[Int] = mutable.Set(13, 23, 53, 12, 13, 23, 78)
    println("set1 => " +set1)

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

    // 2. 添加元素
    val set2 = set1 + 11
    println("set1 => " + set1)
    println("set2 => " + set2)

    set1 += 11
    println("set1 => " + set1)

    val flag1 = set1.add(10)
    println("flag1 => " + flag1)
    println("set1 => " + set1)
    val flag2 = set1.add(10)
    println("flag2 => " + flag2)
    println("set1 => " + set1)

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

    // 3. 删除元素
    set1 -= 11
    println(set1)

    val flag3 = set1.remove(10)
    println("flag3 => " + flag3)
    println("set1 => " + set1)
    val flag4 = set1.remove(10)
    println("flag4 => " + flag4)
    println("set1 => " + set1)

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

    // 4. 合并两个Set
     val set3 = mutable.Set(11,22,33)
    println("set1: " + set1 )
    println("set3 => " + set3 )
    println("******************")
   // 合并set1集合与set3集合,返回合并后的新的集合
   val set4= set1 ++ set3
   // println("set4: " + set4 )
    //set3 ++= set1就会把set1集合的元素合并到set3里面
    set3 ++= set1 //set3调用 ++=方法, 谁调用谁改变
    println("set1: " + set1)
    println("set3 => "+ set3)

  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

Scala集合操作之可变Map 集合和不可变Map集合,元组数据操作

不可变Map集合

object Test08_ImmutableMap {
  def main(args: Array[String]): Unit = {
    // 1. 创建map
    val map1: Map[String, Int] = Map("a" -> 13, "b" -> 25, "hello" -> 3)
    println(map1)
    println(map1.getClass)

    println("==========================")
    // 2. 遍历元素
    map1.foreach(println)
    map1.foreach( (kv: (String, Int)) => println(kv) )

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

    // 3. 取map中所有的key 或者 value
    // keys是包含所有key的Iterable[K]集合
    // 也可以获取所有map集合的所有key的keySet集合，然后遍历keySet集合获取所有key，在根据key获取value值
    for (key <- map1.keys){
      println(s"$key ---> ${map1.get(key)}")
    }

    // 4. 访问某一个key的value
    println("a: " + map1.get("a").get)

    /**
     *  map1.get("a")获取的是一个Option[+A] 类型,但Option是一个密封的抽象类，
      对应有两个实现：
      一个为None: 如果根据key获取不到值，返回的就是一个空集合对象，对应的就是 None
      case object None extends Option[Nothing] {
         def isEmpty = true
         def get = throw new NoSuchElementException("None.get")
      }
      另外一个为：Some: 如果根据key获得值了，返回的就是 Some
      final case class Some[+A](@deprecatedName('x, "2.12.0") value: A) extends Option[A] {
          def isEmpty = false
          def get = value
      @deprecated("Use .value instead.", "2.12.0") def x: A = value
      }
     * map1集合里面没有key为c的键值对，如果去获取value值就会报空指针异常
       * 为了避免报异常可以调用 getOrElse("c", 0)这个方法，含义是如果对应的键值对存在则返回，不存在默认返回0
     */
    println("c: " + map1.get("c"))
    println("c: " + map1.getOrElse("c", 0))
   //map1.put() 不可变Map是不能往里面添加元素的
    println(map1("a"))
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

可变Map操作

object Test09_MutableMap {
  def main(args: Array[String]): Unit = {
    // 1. 创建map
    val map1: mutable.Map[String, Int] = mutable.Map("a" -> 13, "b" -> 25, "hello" -> 3)
    println(map1)
    println(map1.getClass)

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

    // 2. 添加元素
    map1.put("c", 5)
    map1.put("d", 9)
    println(map1)

    /*
     * 使用符号添加数据，+=方法，底层调用的是update方法，
     *  ` def update(key: K, value: V) { this += ((key, value))     } `
     * += 后面跟了一个k-v键值对的二元组，因此可以使用这种方式添加元素
     */
    map1 += (("e", 7)) //("e", 7)这个一个key-vale的二元组
    println(map1)

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

    // 3. 删除元素
    println(map1("c"))
    map1.remove("c")
    println(map1.getOrElse("c", 0))

    map1 -= "d"
    println(map1)

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

    // 4. 修改元素
    map1.update("c", 5)
    map1.update("e", 10)
    println(map1)

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

    // 5. 合并两个Map
    val map2: Map[String, Int] = Map("aaa" -> 11, "b" -> 29, "hello" -> 5)
     // 符号操作为 ++=
    //   把map2中的所有键值对元素，添加到map1中
    map1 ++= map2
    println(map1)
    println(map2)

    println("---------------------------")
    val map3: Map[String, Int] = map2 ++ map1
    println(map1)
    println(map2)
    println(map3)
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

元组操作

object Test10_Tuple {
  def main(args: Array[String]): Unit = {
    // 1. 创建元组
    val tuple: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)
    println(tuple)

    // 2. 访问数据
    println(tuple._1)
    println(tuple._2)
    println(tuple._3)
    println(tuple._4)

    println(tuple.productElement(1))

    println("=========================")
    // 3. 遍历元组数据
    for (elem <- tuple.productIterator)
      println(elem)

    // 4. 嵌套元组
    val mulTuple = (12, 0.3, "hello", (23, "scala"), 29)
    println(mulTuple._4._2)
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

---

for推导式和yield关键字

for推导式的用法

Scala中的for推导式是一种用于对集合进行迭代和转换的强大工具。它提供了一种简洁的语法来处理集合中的元素，并生成新的集合或执行特定的操作。

for推导式的基本语法如下：

for (pattern <- collection) {
  // 循环体
}
1
2
3

其中，pattern是一个模式，用于解构集合中的元素，collection是要遍历的集合。

以下是几种常见的for推导式的用法：

1. 遍历集合并执行操作：

val numbers = List(1, 2, 3, 4, 5)
for (num <- numbers) {
  println(num)
}
1
2
3
4

上述示例中，for推导式遍历numbers列表中的每个元素，并将其打印出来。

2. 过滤并转换集合元素：

val numbers = List(1, 2, 3, 4, 5)
val evenSquares = for (num <- numbers if num % 2 == 0) yield num * num
println(evenSquares)
1
2
3

上述示例中，for推导式通过添加if条件来过滤出偶数，然后将符合条件的偶数平方存储在evenSquares列表中。

3. 多个集合的交叉操作：

val colors = List("red", "green", "blue")
val sizes = List("small", "medium", "large")
val combinations = for {
  color <- colors
  size <- sizes
} yield (color, size)
println(combinations)
1
2
3
4
5
6
7

上述示例中，for推导式嵌套遍历colors和sizes列表，并生成颜色和尺寸的所有可能组合。

除了基本语法之外，for推导式还可以使用模式匹配、嵌套条件、变量绑定等更高级的特性。您可以根据具体的需求来灵活使用和组合这些特性，以实现更复杂的逻辑。

需要注意的是，for推导式在编译时会被转换为其他高阶函数（如map、filter、flatMap等），因此它具有与使用高阶函数相似的性能特性和灵活性。

yield的使用

在Scala中，yield是一个关键字，用于生成集合或其他类型的值。它通常用于for循环中，以遍历集合元素并执行某些操作。以下是yield关键字的主要用法：

1. 在for循环中生成新的集合

val numbers = List(1, 2, 3, 4, 5)
val squares = for (number <- numbers) yield number * number
println(squares) // 输出: List(1, 4, 9, 16, 25)
1
2
3

上述示例中，yield关键字用于在for循环中生成新的集合squares，这个新的集合的元素是通过对原始集合numbers的每个元素进行平方运算得到的。

2. 与模式匹配一起使用

case class Person(name: String, age: Int)

val people = List(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 35))
val names = for (Person(name, _) <- people) yield name
println(names) // 输出: List(Alice, Bob, Charlie)
1
2
3
4
5

上述示例中，yield关键字用于提取people列表中每个Person对象的name属性，并生成一个新的列表names。

3. 用于表达式求值

val result = (for (i <- 1 to 10) yield i * i).sum
println(result) // 输出: 385
1
2

在上述示例中，yield关键字用于生成一个包含1到10的数值的集合，并对每个元素求平方。随后，调用sum方法对所有元素进行求和，并返回结果。

需要注意的是，在Scala中，yield关键字只会将新的集合或值返回给程序的其他部分，它不会修改原始的集合或任何其他的状态。此外，yield关键字只能用于带有for循环的语句中，且只有仅包含一个表达式的for循环才能使用yield生成结果。