Scala基础7——第7章：集合

第7章 集合

7.1 集合介绍

​ （1）Scala的集合有三大类：序列Seq、集Set、映射Map

​ Java的集合也有三大类，List、Set、Map。 List和Set同属于Collection的子类，

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

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

​ 可变集合： scala.collection.mutable

​ （3） Scala不可变集合：该集合对象不可修改，每次修改会返回一个新的对象。类似于java的String

​ （4）Scala可变集合，可以直接对原对象做修改，不会返回新的对象。类似于java中StringBuilder对象

不可变的类的继承关系

（1）Traversable -> Iterable

（2）Iterable->Set、Map、Seq

（3）Set-> HashSet、 ListSet

（3）Map -> hashMap 、SortedMap、 ListMap

（3）Seq -> IndexedSeq 、LinearSeq

（4）IndexedSeq -> Vector 、NumericRange、 Array 、String 、Range （顺序表）

（4）LinearSeq -> List 、Stream 、Queue 、Stack （链表）

可变的类的继承关系

和不可变的结构大同小异，多了StringBuilder, Buffer等。

7.2 数组

7.2.1 不可变数组

val arr1 = new Array[Int](10)
（1）new是关键字
（2）[Int]是泛型，如果存储任意，则写成[Any]
（3）（10）表示数组的大小

object Test01{
   
   
    def main(args:Array[String]):Unit={
   
   
        // 1 创建数组
        val arr:Array[Int] = new Array[Int](5)
        // 1 创建数组的另一种方式
        val arr2 = Array(12,34,52,32,97)
        
        // 2 访问元素
        println(arr(0))
        println(arr(1))
        println(arr(3))
        
        // 数组赋值
        // 数组的内容可以变，但是长度不能变
        arr(0) = 20
        
    }
}

注！为什么Java用的【】，但是Scala用的（）， 主要是因为Scala是完全面向对象的，arr(0)相等于调用一个方法，该方法的参数就是数组下标

用for循环进行数组遍历

object Test01{
   
   
    def main(args:Array[String]):Unit={
   
   
        
        val arr:Array[Int] = Array(12,34,52,32,97)
    	// 1)普通for循环遍历
        for( i <- 0 until arr.length){
   
   
            println(arr(i))
        }
        
        for(i <- arr.indices){
   
   
            // arr.indices等价于0 until arr.length
            println(arr(i))
        }
        
        // 2) 增强for循环
        for( elem <- arr){
   
   
            println(elem)
        }
        
        // 3) 迭代器
        val iter = arr.iterator
        while(iter.hashNext){
   
   
            print(iter.next())
        }
        
        // 4) 调用foreach方法
        arr.foreach( (elem:Int) => println(elem))
        arr.foreach(println)
        
       	println(arr.mkString("--")) // 通过--进行连接
    }
}

数组中添加元素

object Test01{
   
   
    def main(args:Array[String]):Unit={
   
   
   		val arr:Array[Int] = Array(12,34,52,32,97)
        
        // 4 添加元素最后的元素
        // 返回一个新的数组
        val newArr = arr.:+(73)
        newArr.foreach(println)
        
        // 添加到最前面
        val newArr2 = newArr.+:(30)
        newArr2.foreach(println)
        
        // 添加到最后面
        val newArr3 = newArr2 :+ 15
        newArr3.foreach(println)
        // 添加到最前面
        val newArr4 = 29 +: newArr3 
        newArr4.foreach(println)
        
        val newArr5 = 12 +： 29 +: newArr3 :+ 22
  		      
    }
}

7.2.2 可变数组

ArrayBuffer 是可变数组

import scala.collection.mutable.ArrayBuffer

object Test02{
   
   
    def main(args:Array[String]):Unit={
   
   
        // 1 创建可变数组
        val arr1:ArrayBuffer[Int] = new ArrayBuffer[Int]()
        
        val arr2 = ArrayBuffer(23,56,92)
        
        println(arr1.mkString("--"))
        println(arr2)
 
    
    	println(arr2(0)) //访问数组的元素
    	println(arr2(1))
        
        // 修改元素
        arr2(1) = 88
    }
}

给数组添加元素

import scala.collection.mutable.ArrayBuffer

object Test02{
   
   
    def main(args:Array[String]):Unit={
   
   
        val arr1:ArrayBuffer[Int] = new ArrayBuffer[Int]()
        
        val arr2 = ArrayBuffer(23,56,92)
        
       	// 添加元素
        val newArr1 = arr1 :+ 15
        println(newArr1)
        
        // 直接添加到arr1中 最后一个元素
        arr1 += 19
        println(arr1)
        
        // 添加到第一个元素
        77 +=： arr1
        println(arr1)
        
        // 添加元素
        arr1.append(36)
        arr1.prepend(59,11)
        arr1.insert(1, 99,22) //在index为1中添加99和22
        arr1.insertAll(2,newArr1) // 添加整个List
        arr1.appendAll(newArr1)
        arr1.prependAll(newArr1)
        
        // 删除元素
        arr1.remove(3) // 指定下标删除
        println(arr1)
        
        // 删除多个元素
        arr1.remove(0,10)
        
        arr1 -= 13 // 删除特定的元素，如果找不到则不做任何操作
        println(arr1)
    }
}

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

object Test02{
   
   
    def main(args:Array[String]):Unit={
   
   
        // 可变数组 => 不可变数组
        val arr:ArrayBuffer[Int] = ArrayBuffer(23,56,98)
        val newArr:Array[Int] = arr.toArray // 转换为不可变数组
        println(newArr.mkString("--"))
        
        
        // 不可变数组 => 可变数组
        val buffer:mutable.Buffer[Int] = newArr.toBuffer
        println(buffer)
    }
}

多维数组

最高只能到5维

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