您现在的位置是：首页 >技术杂谈 >Scala之集合（1）网站首页技术杂谈

Scala之集合（1）

小唐同学(๑>؂<๑） 2023-05-23 04:00:02
简介Scala之集合（1）

目录

​​​​​​​集合介绍：

不可变集合继承图：​编辑

 可变集合继承图

数组：

不可变数组：

样例代码：

遍历集合的方法：

1.for循环

2.迭代器

3.转换成List列表：

4.使用foreach()函数：

可变数组：

ArrayBuffer:

二维数组：

 List集合：

Set 集合：

不可变 Set：

可变Set:

Map集合：

创建map：

map集合的遍历：

可变map：

元组：

tuple的定义：

元组与map的关系：

特点：

集合介绍：

1） Scala 的集合有三大类：序列 Seq 、集 Set 、映射 Map ，所有的集合都扩展自 Iterable  
特质
2 ）对于几乎所有的集合类， Scala 都同时提供了 可变 和 不可变 的版本，分别位于以下两
个包
不可变集合： scala.collection. immutable
可变集合： scala.collection. mutable
3 ） Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而
不会对原对象进行修改。类似于 java 中的 String 对象
4 ）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似
于 java 中 StringBuilder 对象

不可变集合：

不可变集合继承图：

set集合特点:无序，不重复

对set集合无序的理解：set集合的无序是指在使用append等方法给集合添加元素的时候所添加的元素的顺序是不可预测的，并且不能按照添加顺序进行遍历（存储位置是不一定的）

Set集合的无序性是由它的实现方式所决定的。通常，Set集合的实现方式采用了哈希表这种数据结构，其中元素被散列到桶中，不同的元素可能被散列到同一个桶中，因此添加的顺序不能保证元素的顺序。

set集合提供了SortedSet集合是有序的（放入2，3，1，4会按照1，2，3，4进行存储）SortedSet写了一个TreeSet集合是树状存储

Seq 是 Java 没有的，我们发现 List 归属到 Seq 了，因此这里的 List 就和 Java 不是同一个
概念了
我们前面的 for 循环有一个 1 to 3 ，就是 IndexedSeq 下的 Range
我们发现经典的数据结构比如 Queue（队列）  和 Stack （栈） 被归属到 LinearSeq( 线性序列 )
IndexedSeq 和 LinearSeq 的区别：
（ 1 ） IndexedSeq 是通过索引来查找和定位（相当于数组，通过下标查找），因此速度快，比如 String 就是一个索引集
合，通过索引即可定位
（ 2 ） LinearSeq 是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找

 可变集合继承图

数组：

不可变数组：

不可变集合是长度不可变

Scala中的array 是与 Java中的[]对应

样例代码：

package chapter05
object Test01_Array {
  def main(args: Array[String]): Unit = {
    val array = new Array[Int](4)
    array(3)=100
    //遍历
    for (elem <- array) {
      println(elem)
    }
  }
}

在Scala中没有写方法名的都是调用了apply方法

遍历集合的方法：

1.for循环

        上边样例代码已经使用

2.迭代器

        迭代器相当于是指针的跳转（指针在内存中的跳转）

样例代码：

package chapter05
object Test01_Array {
  def main(args: Array[String]): Unit = {
    val array = new Array[Int](4)
    array(3)=100
val iterator: Iterator[Int] = array.iterator
    while (iterator.hasNext)
      {
        val i: Int = iterator.next()
        println(i)
      }
  }
}

3.转换成List列表：

        array集合可以通过to方法转换成List列表

4.使用foreach()函数：

在Scala中给所有的集合都提供了一个foreach()方法 进行函数式打印

foreach()源码：

def foreach[U](f: A => U): Unit = {
    var i = 0
    val len = length
    while (i < len) { f(this(i)); i += 1 }
  }

源码分析：

foreach()传入的参数实际是传入的函数

A：是代表你传入集合的类型

U：是泛型，代表你的输出类型

这个函数的返回值是Unit类型

让后通过while进行向下运行

对foreach()函数的调用使用匿名函数进行调用

  array.foreach(i=>println(i*2))

可变数组：

数组是默认的不可变的，如果需要可变是需要自己导包的

ArrayBuffer:

填入的初始化大小（数组的大小） 只决定了创建底层结构的长度（不填的话默认是16）

ArrayBuffer是可以进行添加元素的append（）

可以进行增删改查

可变数组与不可变数组元素的增加区别：

可变的用方法不可变的用符号

代码样例：

可变数组的增删改查：

package chapter05
import scala.collection.mutable.ArrayBuffer
object Test_02_ArrayBuffer {
  def main(args: Array[String]): Unit = {
    //可变---导包
    val arrayBuffer = new ArrayBuffer[Int](4)
    arrayBuffer.append(1,2,3)
    arrayBuffer.remove(1)
    arrayBuffer.update(0,100)
    println(arrayBuffer(0))
    println(arrayBuffer)
  }
}

不可变数组是不可变的，如果使用符号做出改变会生成一个新的对象

val array = new Array[Int](10)
    val array1: Array[Int]= array :+ 8
    println(array1.toList)

使用to方法可以让可变与不可变数组进行相互转换

二维数组：

二维数组的定义与遍历：

   val array2: Array[ Array[Int]] = Array(Array(1, 2, 3),Array(1, 2, 3),Array(1, 2, 3))
    for (array3 <- array2) {
      for (elem <- array3) {
        print(elem+ "	")
      }
      println()
    }

在Scala中创建多维数组的方法：

    val array3: Array[Array[Int]] = Array.ofDim[Int](3, 4)

 List集合：

List是一个抽象类 在不继承的情况下是无法new的，所以需要使用伴生对象的apply方法

直接使用即可

（ 1 ） List 默认为不可变集合
（ 2 ）创建一个 List （数据有顺序，可重复） 
    val list = List(1, 2, 3, 4)
（ 3 ）遍历 List 
list.foreach(println)
（ 4 ） List 增加数据
由继承图可知 List集合为链表下边的类  链表添加数据有头插法和尾插法之分 
        （不可变集合用符号） 
尾插： 
 val ints: List[Int] = list :+ 10
 ints.foreach(println)
头插： 
    val list1: List[Int] = 10 :: list
    list1.foreach(println)
（ 5 ）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
扁平化是把两个集合的数据进行打散，然后进行连接合并 
  val list2 = List(5, 6, 7, 8)
    val ints1: List[Int] = list ::: list2
    println(ints1)
                                   
（ 6 ）取指定数据 
    println(ints1(5))
（ 7 ）空集合 Nil
      Nil是一个空集合，相当于创建一个空的List，他是一个单独的对象 
val ints2: List[Int] = 1 :: 2 :: 4 :: 5 :: Nil
val ints3: List[Int] = 3 :: 6 :: 7 :: 9 :: List()

上述两行代码代表的是一个意思

ListBuffer：
ListBuffer是一个可变的集合
可变集合是可变的，调用使用函数，需要导包

Set 集合：

        默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用
scala.collection.mutable.Set 包
set集合其实是一个特质，需要直接调用apply方法创建对象（省略函数名）

不可变 Set：

 
（ 1 ） Set 默认是不可变集合，数据无序
（ 2 ）数据不可重复（set集合的使用场景---->去重） 
 val value: Any = Set(1, 1, 2,2,3, 4, 5, 6, 7, 8, 9)
    println(value)

运行结果：

判断set的类型：

 val bool: Boolean = value.isInstanceOf[HashSet[Int]]
    println(bool)
set集合默认时使用HashSet集合的，只有在数据元素的个数小于等于4个的时候才会使用特殊的set集合

可变Set:

在写可变set的时候，添加mutable.set
创建语句： 
    val ints: mutable.Set[Int] = mutable.Set(1, 2, 2, 3, 1, 4, 5, 6, 8, 7, 9)

可变Set的增加是add方法，不是append方法

可变Set的集合也是符合不可重复，不可修改的特点

 只可增删查

Map集合：

map集合也是一个特质，可以通过apply方法创建对象

map是一个（k,v）集合

创建map：

（1）这是一种采用元组的方式创建的

    val map = Map(("hello", 10), ("world", 20))

（2）这是采用的箭头的方式创建的

    val map1 = Map("hello" -> 10, "world" -> 12)

常用第一种方式创建

map集合的遍历：

（采用第一种方式创建的）

for循环得到的对象是元组

    for (elem <- map) {
      //elem是元组
      val key: String = elem._1
      val value: Int = elem._2
      println(s"${key}:${value}")
    }

在Scala中value的类型为Int类型  在Java中是Int的包装类（防止在get方法找value不存在的时候为Null的情况）

上述情况也会在Scala中出现，Scala是对get方法使用Option（是一个抽象类，被两个子类实现（None,Some））封装

如果get的key存在 就调用上述的some类 再对结果进行调用get  转换成int类型 （方法很长，而且在没有值的情况下是会报错的）

因为太长引入了新的写法：

对map集合直接调用getOrElse(1)方法   设置1  有值输出值  无值输出1

    val i: Int = map.getOrElse("hello", 1)
    println(i)

不存在就会返回None

可变map：

可变map也是采用mutable.map进行创建

增删改查：

增加：

put方法  这个方法可以增加也可以进行修改   当key值存在的时候  如果value不同会覆盖前值

  val maybeInt: Option[Int] = map.put("helloi2", 23)

删除：

    val maybeInt1: Option[Int] = map.remove("hello")

查找：

查找与不可变一样使用getOrElse方法进行查找

元组：

本身为不可变 ，可以存放不同数据类型的元素

list具有上述的性质    但是使用list存放不同类型的数据 在调用的时候无法得到相应的类型（统一为Any）而tuple(元组可以)

tuple的定义：

    val tuple: (String, Int) = ("hihihi", 23)

元组与map的关系：

map中的（key  value ）元素被默认当作二元组

特点：

这样我们可以实现list集合与map集合的转换

    val toList: List[(String, Int)] = map1.toList
    println(toList)

 运行结果：

 

风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

站长推荐