scala中集合的简单操作

    
    println("====不可变数组=====")

    //不可变数组
    val arr1 = Array(1, 2, 3)
    val arr2 = arr1 :+ "4b" //尾部追加
    val arr3 = "我" +: -1 +: 0 +: arr1 //头部追加
    println(arr2.mkString(", "))
    println(arr3.mkString(", "))
    //    ====不可变数组=====
    //    1, 2, 3, 4b
    //    我, -1, 0, 1, 2, 3


    println("====可变数组=====")
    //可变数组
    val arr4 = ArrayBuffer(10)
    arr4 += 11 += 12 //尾部追加 == arr4.append()
    8 +=: 9 +=: arr4 //头部追加 == arr4.prepend()
    arr4.insert(3, 105) //在索引为3的地方插入
    println(arr4)
    arr4.remove(3) //删除索引为3的元素
    arr4.remove(1, 2) //从索引为1处连续删除2个元素
    println(arr4)
    arr4 -= 111 //删除为11的元素，如果存在，则删除，如果不存在则什么也不做
    println(arr4)
    //    ==== 可变数组 =====
    //    ArrayBuffer(8, 9, 10, 105, 11, 12)
    //    ArrayBuffer(8, 11, 12)
    //    ArrayBuffer(8, 11, 12)

    println("====可变数组与不可变数组之间的转换====")
    //可变数组与不可变数组之间的转换
    val immuarr = arr4.toArray //可变数组转换为不可变数组
    val muarr = immuarr.toBuffer //不可变数组转换为可变数组
    println(muarr)
    println(immuarr)
    //    ==== 可变数组与不可变数组之间的转换 ====
    //    ArrayBuffer(8, 11, 12)
    //      [I@59 a6e353

    println("====不可变列表=====")
    //不可变列表
    val list1 = List(1, 2, "wo")
    val list2 = 0 +: list1 //与不可变数组一样，在列表头部添加
    val list3 = list1 :+ 3 //与不可变数组一样，在列表尾部添加
    val list4 = list1.::(4) //在列表开头位置添加
    val list5 = 10 :: 11 :: 12 :: 13 :: Nil //Nil为空数组，使用::创建新数组
    println(list2)
    println(list3)
    println(list4)
    println(list5)
    //    List(0, 1, 2, wo)
    //    List(1, 2, wo, 3)
    //    List(4, 1, 2, wo)
    //    List(10, 11, 12, 13)

    println("列表合并")
    //列表合并
    println(list1 :: list2) //将list1作为一个元素添加到list2的头部
    println(list1 ::: list2) //将list1中的元素拆分，然后放入list2头部
    println(list1 ++ list2) // == list1:::list2
    //    List(List(1, 2, wo), 0, 1, 2, wo)
    //    List(1, 2, wo, 0, 1, 2, wo)
    //    List(1, 2, wo, 0, 1, 2, wo)

    println("====可变列表===")
    val list6 = ListBuffer(10, 11, 12)
    list6.append(13, 14, 15) //尾部添加
    list6.prepend(8, 9) //头部添加
    list6 += 16 += 17 //尾部添加 == append
    6 +=: 7 +=: list6 //头部添加 ==prepend
    println(list6)
    //    ==== 可变列表 ===
    //    ListBuffer(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)

    //合并
    println("合并")
    val list7 = ListBuffer(100, 101)
    val list8 = list6 ++ list7 // 合并list6和list7的元素并生成新的列表
    list6 ++= list7 //将list7中的元素添加到list6中
    println(list6)
    println(list7)
    println(list8)
    //    合并
    //    ListBuffer(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 100, 101)
    //    ListBuffer(100, 101)
    //    ListBuffer(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 100, 101)

    //修改
    println("修改")
    list7(1) = 102
    println(list7)
    //    修改
    //    ListBuffer(100, 102)


    //删除
    println("删除")
    list6 -= 100
    list6.remove(0, 3)
    println(list6)
    //    删除
    //    ListBuffer(9, 10, 11, 12, 13, 14, 15, 16, 17, 101)

    //不可变集合
    println("====不可变集合===")
    val set1 = Set(10, 11, 10) //重复数据会自动去除
    val set2 = set1 + 12 + 13 //添加元素，因为是无须的，所以不存在首尾添加
    val set3 = set2 - 11 //删除元素
    val set4 = set1 ++ set3 //合并集合
    println(set1)
    println(set2)
    println(set3)
    println(set4)
    //    ====不可变集合===
    //    Set(10, 11)
    //    Set(10, 11, 12, 13)
    //    Set(10, 12, 13)
    //    Set(10, 11, 12, 13)

    println("=======可变集合=====")
    val set5 = mutable.Set(1, 2, 1)
    set5.add(5) //添加元素 ==set5 += 5
    set5 += 6
    set5.remove(2) //删除元素 == set5 -= 2
    val set6 = mutable.Set(10, 11)
    set6 ++= set5 //将set5 添加到set6中
    println(set6)
    println(set5)
//    ======= 可变集合 =====
//    HashSet(1, 10, 11, 5, 6)
//    HashSet(1, 5, 6)

    //不可变map
    println("===不可变map====")
    val map1 = Map("a" -> 10,"b" -> 11)
    map1.foreach(println) //遍历映射
    map1.foreach((kv:(String,Int)) => println(kv)) //与上方结果一样，遍历映射
    println(map1.get("a")) //获取的为Some值
    println(map1.get("a").get) //获取的为value值，即Some中的值
    println(map1.getOrElse("c",0)) //获取不存在的key的value，
//    === 不可变map ====
//    (a, 10)
//    (b, 11)
//    (a, 10)
//    (b, 11)
//    Some(10)
//    10
//    0

    //可变map
    println("===可变map====")
    val map2 = mutable.Map("aa"->100,"bb"->101)
    map2 +=(("cc",102)) //添加元素 == put == update
    map2.put("dd",103) //添加元素，底层为+=实现
    println(map2)
    map2.remove("cc") //删除元素
    map2 -= "bb" //删除元素 == map2.remove
    println(map2)

    map2++=map1
    println(map2)  //将map1中的元素合并到map2中
    val map3 = map1 ++ map2 //将map1与map2中的元素合并赋值给map3
    println(map3)
//    === 可变map ====
//    HashMap(aa -> 100, bb -> 101, cc -> 102, dd -> 103)
//    HashMap(aa -> 100, dd -> 103)
//    HashMap(aa -> 100, dd -> 103, a -> 10, b -> 11)
//    Map(a -> 10, b -> 11, aa -> 100, dd -> 103)