Scala集合介绍

集合简介

1)Scala 的集合有三大类:序列 Seq、集 Set、映射 Map,所有的集合都扩展自 Iterable
特质。
2)对于几乎所有的集合类,Scala 都同时提供了可变和不可变的版本,分别位于以下两
个包

  • 不可变集合:scala.collection.immutable
  • 可变集合: scala.collection.mutable

3)Scala 不可变集合,就是指该集合对象不可修改,每次修改就会返回一个新对象,而
不会对原对象进行修改。类似于 java 中的 String 对象。
4)可变集合,就是这个集合可以直接对原对象进行修改,而不会返回新的对象。类似
于 java 中 StringBuilder 对象。
建议:在操作集合的时候,不可变用符号,可变用方法

不可变集合继承图

在这里插入图片描述
1)Set、Map 是 Java 中也有的集合
2)Seq 是 Java 没有的,我们发现 List 归属到 Seq 了,因此这里的 List 就和 Java 不是同一个概念。
3)我们前面的 for 循环有一个 1 to 3,就是 IndexedSeq 下的 Range
4)String 也是属于 IndexedSeq
5)我们发现经典的数据结构比如 Queue 和 Stack 被归属到 LinearSeq(线性序列)
6)大家注意 Scala 中的 Map 体系有一个 SortedMap,说明 Scala 的 Map 可以支持排序
7)IndexedSeq 和 LinearSeq 的区别:

  • IndexedSeq 是通过索引来查找和定位,因此速度快,比如 String 就是一个索引集合,通过索引即可定位
  • LinearSeq 是线型的,即有头尾的概念,这种数据结构一般是通过遍历来查找

可变集合继承图

在这里插入图片描述

数组

不可变数组

基本介绍

1)第一种方式定义数组

val arr1 = new Array[Int](10) 

其中:
(1)new 是关键字
(2)[Int]是指定可以存放的数据类型,如果希望存放任意数据类型,则指定 Any
(3)(10),表示数组的大小,确定后就不可以变化
2)第二种方式定义数组

val arr1 = Array(1, 2) 

其中
(1)在定义数组时,直接赋初始值
(2)使用 apply 方法创建数组对象

案例实操

(1)创建数组
(2)访问数组
(3)赋值
(4)数组遍历
(5)添加数组元素

package chapter07

object Test01_ImmutableArray {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //创建数组
    val arr = new Array[Int](5)

    //另一种创建的方式
    val arr2 = Array(12,24,25)  //apply方法省略

    //访问数组的方法
    println(arr(0))
    println(arr(1))
    println(arr(2))
    println(arr(3))  // 等于arr.apply(3)

    //赋值
    arr(0) = 1  //等于arr.update(0) = 1
    arr(1) = 3

    println(arr(0))

    //数组遍历
    //for循环
    for (i <- 0 until( arr.length)){
    
    

      println(arr(i))
    }

    for (i <- arr.indices)
      println(arr(i))


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

    //迭代器使用
    val iter = arr2.iterator

    while (iter.hasNext){
    
     //元素是否有下一个
      println(iter.next())
    }

    //调用foreach方法
    arr2.foreach((elem: Int) => println(elem))

    //上面的至简原则
    arr2.foreach(println)


    //底层实现的连接遍历
    println(arr2.mkString("-"))

    //添加数组元素(在最后面)
    arr2.:+(73)


    println(arr2.mkString("-"))

    val arr3 = arr2.:+ (73) // 相当于创建一个新的数组
    //简化
    val arr5 = arr2 :+ 73

    println(arr3.mkString("-"))
    println(arr5.mkString("-"))

    //添加数组元素(在最前面)
    val arr4 = arr2.+:(73)

    //简化
    val arr6 = 73 +: arr2
    println(arr6.mkString("-"))


    //结合上面的两种方法
    val arr7 = 72 +: 73 +: arr2 :+ 74 :+ 75
    println(arr7.mkString("-"))
  }

}

可变数组

基本介绍

1)定义变长数组

val arr01 = ArrayBuffer[Any](3, 2, 5) 

其中
(1)[Any]存放任意数据类型
(2)(3, 2, 5)初始化好的三个元素
(3)ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer

案例实操

(1)创建数组
(2)ArrayBuffer 是有序的集合
(3)访问以元素
(4)增加元素使用的是 append 方法(),支持可变参数
(5)删除元素

package chapter07

import scala.collection.mutable.ArrayBuffer

object Test02_ArrayBuffer {
    
    
  def main(args: Array[String]): Unit = {
    
    


    //创建一个可变数组
    val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()

    val arr2 = ArrayBuffer(23,24,25)

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

    //访问元素
//    println(arr1(0)) //java.lang.IndexOutOfBoundsException: 0 数组越界
    println(arr2(0))
    arr2(0) = 2121

    println(arr2(0))

    //添加元素
    arr1 :+ 15
    val newarr1 = arr1 :+ 15
    println(arr1 == newarr1)
    println(newarr1.mkString("-"))


    val newarr2 = arr1 += 19
    arr1 += 19  //可变数组采用这种方式在后面添加元素
    println(arr1)
    println(arr1 == newarr2)

    20 +=: arr1  //可变数组采用这种方式在前面添加元素
    println(arr1)


    //可变数组推荐下面的方法
    arr1.append(12,13) //在后面添加
    println(arr1)

    arr1.prepend(11,12) //在前面添加
    println(arr1)

    arr1.insert(1,121,211) //任意位置添加
    println(arr1)

    arr1.appendAll(newarr1) //在后面添加一个数组
    println(arr1)

    arr1.prependAll(newarr1) //在前面面添加一个数组
    println(arr1)

    arr1.insertAll(1, newarr1) //任意位置添加一个数组
    println(arr1)

    //删除元素
    arr1.remove(4)
    println(arr1)

    arr1.remove(2,3)  //第二个开始,删除3个
    println(arr1)

    arr1 -= 19 //删除19,多个的话,就删除一个
    println(arr1)

  }

}

不可变数组与可变数组的转换

基本介绍

arr1.toBuffer //不可变数组转可变数组 
arr2.toArray //可变数组转不可变数组 

其中
(1)arr2.toArray 返回结果才是一个不可变数组,arr2 本身没有变化
(2)arr1.toBuffer 返回结果才是一个可变数组,arr1 本身没有变化

案例实操

package chapter07

import scala.collection.mutable.ArrayBuffer

object Test02_ArrayBuffer {
    
    
  def main(args: Array[String]): Unit = {
    
    


    //创建一个可变数组
    val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()

    val arr2 = ArrayBuffer(23,24,25)

    //可变数组在转换为不可变数组
    val arr = ArrayBuffer(1,2,3)

    val newarr = arr.toArray

    println(newarr.mkString("-"))
    println(arr)

    //不可变数组转换为不可变数组
    val buffer = newarr.toBuffer
    println(buffer)
  }
}

多维数组

多维数组定义

val arr = Array.ofDim[Double](3,4) 

说明:二维数组中有三个一维数组,每个一维数组中有四个元素

案例实操

package chapter07

object Test03_MulArray {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //创建多维数组
    val array = Array.ofDim[Int](2, 3) //2行3列


    //访问元素
    array(0)(2) = 12 //赋值
    array(1)(0) = 13

    //输出
    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))
  }

}

列表 List

不可变 List

基本介绍

1)说明
(1)List 默认为不可变集合
(2)创建一个 List(数据有顺序,可重复)
(3)遍历 List
(4)List 增加数据
(5)集合间合并:将一个整体拆成一个一个的个体,称为扁平化
(6)取指定数据
(7)空集合 Nil

案例实操

package chapter07

object Test04_List {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //创建一个list
    val list1 = List(1,2,3,4)
//    println(list1.indices)
    println(list1.mkString("-"))


    //访问list元素
    println(list1(1))

//    list1(1) = 12  //error不能赋值

    list1.foreach(println)

    //添加元素
    val list2 = list1 :+ 10
    val list3 = 10 +: list1

    println(list1)
    println(list2)
    println(list3)


    // ::方法, 常用来创建一个新的list
    val list4 = list1.::(521)
    println(list4)

    val list5 = Nil.::(12)
    println(list5)

    val list6 = 32 :: Nil
    println(list6)

    val list7 = 12 :: 13 :: 14 :: Nil
    println(list7)

    //合并list
    val list8 = list7 :: list6 //不可以
    println(list8)

    val list9 = list7 ::: list6
    println(list9)

    val list10 = list7 ++ list6
    println(list10)

  }

}

可变 ListBuffer

基本介绍

1)说明
(1)创建一个可变集合 ListBuffer
(2)向集合中添加数据
(3)删除元素
(4)合并元素
(5)修改元素
(6)打印集合数据

案例实操

package chapter07

import scala.collection.mutable.ListBuffer

object Test05_ListBuffer {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //创建可变列表
    val list1  = new ListBuffer[Int]()
    val list2 = ListBuffer(1,2,3) //伴生对象创建

    println(list1)
    println(list2)

    //添加元素
    list1.append(1,2)
    println(list1)

    list2.prepend(0)
    println(list2)

    list1 += 4 += 5
    -1 +=: list1
    println(list1)

    //合并list
    val list3 = list1 ++ list2

    println(list1)
    println(list2)
    println(list3) //合并后

    list1 ++= list2
    println(list1) //合并后
    println(list2)

    //修改元素

    list2(3) = 30
    println(list2)

    //删除元素
    list2.remove(2)
    println(list2)

    //指定元素删除
    list2 -= 30
    println(list2)

    //打印集合数据 
    buffer.foreach(println) 
  }

}

Set 集合

默认情况下,Scala 使用的是不可变集合,如果你想使用可变集合,需要引用
scala.collection.mutable.Set 包

不可变 Set

基本介绍

1)说明
(1)Set默认是不可变集合,数据无序
(2)数据不可重复
(3)遍历集合
(4)添加元素
(5)删除元素
(6)合并Set

案例实操

package chapter07

object Test06_ImmutableSet {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //创建set
    val set1 = Set(1,2,3,5,7,8,7,7,7)

    println(set1) //自动去除重复的
    
    //遍历集合 
    for(x<-set1){
    
     
       println(x) 
    } 

    //添加元素

    val set2 = set1.+(19)
    val set3 = set1 + 20 //等于上面
    println(set1)
    println(set2)
    println(set3)


    //合并set
    val set4 = Set(11,12,13,14)
    var set5 = Set(15, 16, 17, 18)

    set5 ++= set4
    val set6 = set4 ++ set5
    println(set6)
    println(set5)

    //删除元素
    val set7 = set6 -13

    println(set6)
    println(set7)

  }

}

可变集合

基本介绍

1)说明
(1)创建可变集合 mutable.Set
(2)打印集合
(3)集合添加元素
(4)向集合中添加元素,返回一个新的 Set
(5)删除数据

案例实操

package chapter07

import scala.collection.mutable

object Test07_MutableSet {
    
    

  def main(args: Array[String]): Unit = {
    
    

      //创建set
    val set1 = mutable.Set(1,2,3,4,5)
    println(set1)

    //添加元素

    set1 + 11
    println(set1)  //set1不改

    val set2 = set1 + 1
    println(set2)

    set1 += 11
    println(set1) //set1改了

    set1.add(12)
    println(set1) //推荐这种添加元素的方法(原集合有的话,不添加)

    //删除元素
    set1 -= 11

    println(set1)

    //合并两个set
    val set3 = mutable.Set(12,22,32,42,52)
    println(set1)

    set1 ++ set3

    println(set1)
    println(set3)

    val set4 = set1 ++ set3
    println(set4)



  }

}

Map 集合

Scala 中的 Map 和 Java 类似,也是一个散列表,它存储的内容也是键值对(key-value)映射。

不可变 Map

基本介绍

1)说明
(1)创建不可变集合 Map
(2)遍历元素
(3)访问数据
(4)如果 key不存在,返回 0

案例实操

package chapter07

object Test08_ImmutableMap {
    
    

  def main(args: Array[String]): Unit = {
    
    

      //创建map
    val map1 : Map[String, Int]= Map("a" -> 12, "b"-> 13,"hello" -> 14)

    println(map1)
    println(map1.getClass)

    //遍历元素
    map1.foreach(println)

    //等同于下面
    map1.foreach((kv:(String,Int)) => println(kv))

    //去map中所有的key或者value

    for (key <- map1.keys){
    
    
      println(s"$key ---> ${map1.get(key)}")
    }

    //访问某一个key的value
    println(map1.get("a").get)
//    println(map1.get("").get)  //异常java.util.NoSuchElementException: None.get
    println(map1.get("c"))  //没有c 输出none

    //上面方法容易抛异常,用下面的即使没有也不会抛异常
    println("a: " + map1.getOrElse("a",0))
    println("c: " + map1.getOrElse("c",0)) //后面的0是没有对应的数时的返回值

    //或者直接下面可以获取value,没有的话,还是会抛异常
    println(map1("a"))
//    println(map1("c"))  java.util.NoSuchElementException: key not found: c
  }

}

可变 Map

基本结束

1)说明
(1)创建可变集合map
(2)打印集合
(3)增加数据
(4)删除数据
(5)修改数据

案例实操

package chapter07

import scala.collection.mutable

object Test09_MutableMap {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //创建map

    val map1 : mutable.Map[String, Int]= mutable.Map("a" -> 12, "b"-> 13,"hello" -> 14)
    println(map1)
    println(map1.getClass)

    //添加元素
    map1.put("c", 5)
    map1.put("d", 6)

    println(map1)

    //用符号添加元素
    map1 +=(("e",7))

    println(map1)

    //删除元素
    map1.remove("e")
    println(map1)

    map1 -= ("d")
    println(map1)

    //修改元素
    map1.put("c",8)

    println(map1)

    //合并两个map
    val map2 : mutable.Map[String, Int]= mutable.Map("a2" -> 112, "b3"-> 113,"hello" -> 114)

    map1 ++= map2
    val map3 = map2 ++ map1

    println(map1)
    println(map3)
  }
}

元组

基本介绍

1)说明
元组也是可以理解为一个容器,可以存放各种相同或不同类型的数据。说的简单点,就是将多个无关的数据封装为一个整体,称为元组。
注意:元组中最大只能有 22 个元素。

案例实操

(1)声明元组的方式:(元素 1,元素 2,元素 3)
(2)访问元组
(3)遍历元组
(4)嵌套元组

package chapter07

object Test10_Tuple {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //创建元组
    val tuple = ("hell0", 1 , 2.1 , true)
    println(tuple)

    //访问元组中的数据

    println(tuple._1)
    println(tuple._4)
    //等同于下面的
    println(tuple.productElement(1))

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

    //嵌套元组
    val mulTuple = ("alice",2,3,(23,"scala"))

    println(mulTuple._4._1)

  }

}

并行集合

基本介绍

1)说明
Scala 为了充分使用多核 CPU,提供了并行集合(有别于前面的串行集合),用于多核
环境的并行计算。

案例实操

package chapter07

object Test20_Parallel {
    
    

  def main(args: Array[String]): Unit = {
    
    

    val range = 1 to 100

    val result = range.map(
      x => Thread.currentThread().getName

    )

    println(result)

    val result1 = range.map(
      y => Thread.currentThread().getId
    )

    println(result1)

    println(result)


    //并行执行
    val result2 = range.par.map(
      z => Thread.currentThread().getId
    )

    println(result2)
  }


}

猜你喜欢

转载自blog.csdn.net/weixin_44480968/article/details/119480304

相关文章