Scala基础【集合01】

一 集合

Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本。

可变集合可以在适当的地方被更新或扩展。这意味着可以修改，添加，移除一个集合的元素。而不可变集合类，相比之下，内容永远不会改变。不过，仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变，所以这里的不可变并不是变量本身的值不可变，而是变量指向的那个内存地址不可变

可变集合和不可变集合，一般可以根据集合所在包名进行区分:

• scala.collection.immutable
  

• scala.collection.mutable
  
  

1 数组

不可变数组

严格意义上数组不是集合，是一种组织和管理数据的结构，但scala中给数组一个特定的类型：Array

基本操作：创建，访问，遍历

  def main(args: Array[String]): Unit = {
    
    val array = new Array[String](3)
    array.update(1,"a")
    for(i <- array){
    
      println(i)
    }

反编译后的代码如下，所以构建scala中的数组，其实等同于构造java中的数组

String[] array = new String[]{
    null, "a", null};

赋值

可以根据索引访问数组的元素update(1,"a")，但scala中的中括号表示泛型，所以不能在索引操作中使用，使用小括号即可array(1)="a"，这两种赋值方式完全相同

创建数组的同时进行初始化，使用集合的伴生对象创建对象，同时进行初始化

val array = Array(1,2,3,4)
val array1 = Array.apply(1,2,3,4)

反编译后的代码为

int[] var10000 = new int[]{
    1, 2, 3, 4};

访问

集合分为可变集合和不可变集合，scala默认提供的集合都是不可变的，每一次添加操作都会产生新的集合

  def main(args: Array[String]): Unit = {
    
    val array = Array(1,2,3,4)

    val ints = array.+:(5)
    val ints1 = array.:+(5)

    println(array eq ints)  //false
    println(array eq ints1) //false
    println(ints eq ints)   //false

    for(i <- array){
    
      println(i)            //1,2,3,4
    }

查看ints，ints1，mkString，生成字符串，第一次遍历使用 ,隔开，第二次遍历使用-隔开

	println(ints.mkString(","))   //5,1,2,3,4
    println(ints1.mkString("-"))  //1-2-3-4-5

如果运算符以冒号结尾，则运算规则从后向前计算

    val ints = array.+:(5)	//等同于
    val ints = 5 +: array
    
    val ints1 = array.:+(5)	//等同于
    val ints1 = array :+ 5

    val ints2 = array ++ array1
    println(ints2.mkString(","))  //1,2,3,4,5,6,7,8

遍历

foreach是一个循环的方法，需要传递一个参数，参数的类型是函数类型：Int => U

    def foreachFunction(num:Int): Unit ={
    
      println(num)
    }
    array.foreach(foreachFunction)    //1,2,3,4

array将每个数字传递给函数的num，foreach循环调用foreachFunction

使用匿名函数代替声明的函数

array.foreach((num:Int)=>{
    println(num)})

使用函数至简原则进行化简

array.foreach(println(_))

其他操作

多维数组

var myMatrix = Array.ofDim[Int](3,3)
myMatrix.foreach(list=>println(list.mkString(",")))

输出内容为

0,0,0
0,0,0
0,0,0

合并数组

val arr3: Array[Int] = Array.concat(arr1, arr2)
arr3.foreach(println)

创建指定范围的数组，左闭右开

val arr4: Array[Int] = Array.range(0,2)
arr4.foreach(println)

创建数组并按照特定值（-1）填充指定数量的数组

val arr5:Array[Int] = Array.fill[Int](5)(-1)
arr5.foreach(println)

可变数组

直接在原数组的基础上进行修改，内容可变

  def main(args: Array[String]): Unit = {
    
    val buffer = new ArrayBuffer[Int]()
    println(buffer)          //ArrayBuffer()

    buffer.append(1,2,3,4)			//ArrayBuffer(1, 2, 3, 4)
    buffer.appendAll(Array(1,2,3))    //ArrayBuffer(1, 2, 3, 4, 1, 2, 3)
    buffer.insert(1,5)      //ArrayBuffer(1, 5, 2, 3, 4, 1, 2, 3)
    //buffer.insert(100,1) //IndexOutOfBoundsException
    buffer.update(0,10)     //ArrayBuffer(10, 5, 2, 3, 4, 1, 2, 3)
    buffer(0) = 9           //ArrayBuffer(9, 5, 2, 3, 4, 1, 2, 3)
    buffer.remove(0)        //ArrayBuffer(5, 2, 3, 4, 1, 2, 3)
    buffer.remove(0,3)      //ArrayBuffer(4, 1, 2, 3)
    println(buffer) 
    
    // 使用 ++= 运算符会更新之前的集合，不会产生新的数组
    val buffer5: ArrayBuffer[Int] = buffer1 ++= buffer2
  }

注意以下方法会产生新的数组

val ints = buffer - 4
println(ints eq buffer)   //false
println(ints)             //ArrayBuffer(1, 2, 3)
println(buffer)           //ArrayBuffer(4, 1, 2, 3)

 // 使用 ++ 运算符会产生新的集合数组
val buffer4: ArrayBuffer[Int] = buffer1 ++ buffer2

使用伴生对象，在创建数组的同时进行初始化

val buffer = ArrayBuffer(1,2,3,4)

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

def main(args: Array[String]): Unit = {
    
    val buffer = ArrayBuffer(1,2,3,4)
    val array = Array(4,5,6,7)

    // 将不可变数组转换为可变数组
    val buffer1: mutable.Buffer[Int] = array.toBuffer
    // 将可变数组转换为不可变数组
    val array1: Array[Int] = buffer.toArray
}

java集合和scala集合间的互相转换

//java ==> scala
import scala.collection.JavaConverters._
val list = new java.util.ArrayList()
list.asScala.foreach(println)

//scala ==> java
val java = List(1,2,3,4).asJava

2 集合提供的方法

scala关注的重点在于集合作为一个容器是如何对数据进行操作的，不关心底层是如何存储，管理数据的，是数组，List，Set，Map区别不大，所以重点集中到提供的几个功能

常用的方法

println(array.size)    				    //6
println(array.length)  					//6
println(array.isEmpty)   				//false
array.contains(println(3))  			// 3
println(array.distinct.mkString(","))   //1,2,3,4,5
println(array.reverse.mkString(","))    //5,4,4,3,2,1

遍历相关

println(array.mkString(","))
array.foreach(println)
array.iterator

从集合获取部分元素

val buffer = ArrayBuffer(1,2,3,4)

println(buffer.head)     //1
println(buffer.tail)     //ArrayBuffer(2, 3, 4)
println(buffer.tails)    //<iterator>
println(buffer.last)     //4
println(buffer.init)     //ArrayBuffer(1, 2, 3)
println(buffer.inits)    //<iterator>

//取前几个
println(buffer.take(3))         //ArrayBuffer(1, 2, 3)
println(buffer.takeRight(2))    //ArrayBuffer(3, 4)
println(buffer.drop(1))         //ArrayBuffer(2, 3, 4)
println(buffer.dropRight(1))    //ArrayBuffer(1, 2, 3)

与计算相关的方法

println(array.sum)      //10
println(array.max)      //4
println(array.min)      //1
println(array.product)  //24

如果没有现成提供的方法，需要自定义数据操作的方法，集合的数据无论有多少，最基本的数据操作其实都是两两计算

map ==> reduce ==> 简化，规约，集合

println(array.reduce((x,y) => x - y))	//-8
println(array.reduce(_ - _))			//-8
println(array.reduceLeft(_-_))			//-8
println(array.reduceRight(_-_))			//-2

reduceLeft从左边加括号：（（（1 - 2）- 3）- 4）

reduceRight从右边加括号：（1 -（2 -（3 - 4）））

与集合外部的数据进行操作

val array = ArrayBuffer(1,2,3,4)
val num = 5
println(array.fold(num)(_ - _))      //-5，先执行5 - 1-->5,1,2,3,4，从左边加括号
println(array.foldLeft(num)(_-_))    //-5，将5放在左边，从左边加括号
println(array.foldRight(num)(_-_))   //3，将5放在右边，从右边加括号
//将两两计算的临时结果保留下来（检验）
println(array.scan(num)(_ - _))       //ArrayBuffer(5, 4, 2, -1, -5)
println(array.scanRight(num)(_ - _))  //ArrayBuffer(3, -2, 4, -1, 5)