集合介绍

 

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

 

集合可变，不可变的区别

• Scala默认提供的集合都是不可变。

不可变：增删改 都会返回有个新数组
可变：可增删改　

• 可变：
  • scala.collection.mutable

hashmap,hashset AraryBuffer

• 不可变
  • scala.collection.immutable

Hashset Hashmap Array List String

不可变数组Array:不可变是指长度不可变

 

    //定义数组，格意义上，数组不是集合，是一种数据结构
    val array = new Array[String](3)
    // 使用集合的伴生对象构建集合，并同时初始化
    val array1 = Array(1,2,3,4)
    val array2 = Array(5,6,7,8)
    //val array2 = Array.apply(1,2,3,4)


    //插值
    array.update(0,"bb")
    //插值，或者修改
    array(0)="aa"
    //循环打印
    for (elem <- array) {println(elem)}

 

• 访问（冒号紧邻数组）

    val array1 = Array(1,2,3,4)
    val array2 = Array(5,6,7,8)

    // 访问
    //val ints: Array[Int] = array1.+:(5)
    // scala中如果运算符是以冒号结尾，那么运算规则为从后向前计算
    val ints = 5 +: array1

    //val ints1: Array[Int] = array1.:+(5)
    val ints1 = array1 :+ 5

    val ints2 = array1 ++ array2

       println(array1 eq ints)
       println(array1 eq ints1)
       println(ints eq ints1)

        // TODO 遍历
        println(ints.mkString(","))
        println(ints1.mkString(","))
        println(ints2.mkString(","))
结果
false
false
false
5,1,2,3,4
1,2,3,4,5
1,2,3,4,5,6,7,8　

• 数组循环

        // foreach方法是一个循环的方法，需要传递一个参数，这个从参数的类型是函数类型
        //  函数类型 ： Int => U
        def foreachFunction(num:Int): Unit = {
            println(num)
        }

        //array1.foreach(foreachFunction)
        //array1.foreach((num:Int)=>{println(num)})
        //array1.foreach((num:Int)=>println(num))
        //array1.foreach((num)=>println(num))
        //array1.foreach(num=>println(num))

最终一个结果
array1.foreach(println(_))

• 2维数组的创建；数组拼接，填充

// 多维数组
var myMatrix = Array.ofDim[Int](3,3)
//myMatrix.foreach(list=>println(list.mkString(",")))

val arr1 = Array(1,2,3,4)
val arr2 = Array(5,6,7,8)
// 合并数组
val arr6: Array[Int] = Array.concat(arr1, arr2)
//arr6.foreach(println(_))

// 创建指定范围的数组
val arr7: Array[Int] = Array.range(0,2)
arr7.foreach(println)
//创建并填充指定数量的数组
val arr8:Array[Int] = Array.fill[Int](5)(-1)
arr8.foreach(println)　

可变数组

    //val buffer = new ArrayBuffer[String]()
    val buffer = ArrayBuffer("a", "b", "c")

    buffer.append("a", "b", "c", "d")
    //ArrayBuffer(a, b, c, a, b, c, d)
    buffer.appendAll(Array("a", "b", "c"))
    //ArrayBuffer(a, b, c, a, b, c, d, a, b, c)

//    buffer.insert(100, "f")  IndexOutOfBoundsException

    //更改
    //buffer.update(0, "e")
    buffer(0) = "e"
    println(buffer,"**")

    //删除
    //buffer.remove(2)
    //buffer.remove(2,4)
    //println(buffer,"@@")

    val strings: ArrayBuffer[String] = buffer - "e"
    println(strings,"$$")

    println(buffer eq strings)

可变<---->不可变转换

        val array = Array(1,2,3,4)

        // 不可变 => 可变
        val buffer: mutable.Buffer[Int] = array.toBuffer

        val buff = ArrayBuffer(1,2,3,4)
        // 可变 => 不可变
        val array1: Array[Int] = buff.toArray

        // Java集合 <=> Scala集合
        array1.foreach(println)

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

        val java: util.List[Int] = List(1, 2, 3, 4).asJava　

 基本操作

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

    // 从集合中获取部分数据
    println(array.head)
    println(array.tail)
    println(array.tails)
    println(array.last)
    println(array.init.foreach(println(_))) // 初始
    println(array.inits.foreach(println(_)))

    // 取前几个
    println(array.take(3))
    //println(array.reverse.take(2).reverse)
    println(array.takeRight(2))
    println(array.drop(1))
    println(array.dropRight(1))