共计 4173 个字符，预计需要花费 11 分钟才能阅读完成。
1.Scala 汇合概述
Scala 有三类汇合：序列 Seq、Set、映射 Map。
Scala 中，简直所有的汇合，都提供可变和不可变两个版本。
个别，咱们依据汇合所在的包来辨别是可变汇合还是不可变汇合。
- scala.collection.immutable 不可变汇合
- scala.collection.mutable 可变汇合
2.Scala 汇合
2.1 数组
2.1.1 不可变数组
object Scala_Coll {def main(args: Array[String]): Unit = {
// Scala 数组 - 不可变
// 1. 创立数组对象
// 形式一
// new Array[String](5) 编译后会生成 java 的数组代码
val array = new Array[String](5)
// 形式二
val array1 = Array(1,2,3,4)
// 2. 打印数组
println(array) // 输入后果 [Ljava.lang.Object;@4cdbe50f
// 3. 数组赋值，Scala 下标索引应用小括号
array(0) = "张三"
array(1) = "李四"
array(2) = "王五"
array(3) = "赵六"
// 4. 采纳 update 形式批改数组的值
array.update(4,"哈哈")
// 5. 查看数组
println(array.mkString(","))
// 6. 遍历数组 - 形式 1
for(i<-array){println(i)
}
// 7. 遍历数组 - 形式 2
// array.foreach(i => println(i)) 精简为
array.foreach(println)
/////// 数组操作 ///////
// 1) 增加数组元素，不可变数组增加数组元素后，返回一个新的数组，自身不会产生扭转
// :+ 增加元素到尾部
val arr1 = array :+ 5
// +: 增加元素到首部
val arr2 = arr1.+:(5)
// ++ 增加数组
val arr3 = arr1 ++ arr2
}
}2.1.2 可变数组
import scala.collection.mutable.ArrayBuffer
object Scala_Coll {def main(args: Array[String]): Unit = {
// 1. 申明可变数组：scala.collection.mutable.ArrayBuffer
// 形式 1
val arr1 = new ArrayBuffer[Int]()
// 形式 2
val arr2 = ArrayBuffer(1,2,3,4)
// 2. 减少数据
arr1.append(4,5,6,7)
println(arr1.mkString(","))
// 3. 批改数据
arr1.update(1,10)
println(arr1.mkString(","))
// 4. 删除数据
arr1.remove(1,2) // 从索引地位 1 开始删除 2 个数据
println(arr1.mkString(","))
// 5. 查问数据
println(arr1(1))
// 6. 遍历汇合
arr1.foreach(println)
// 7. ++ 运算符会产生新的汇合数组
val arr3 = arr1 ++ arr2
println(arr3.mkString(","))
// 8. ++= 运算符则更新之前汇合，并不产生新的数组
arr1 ++= arr2
println(arr1.mkString(","))
}
}2.1.3 可变数组和不可变数组的相互转换
import scala.collection.mutable.ArrayBuffer
object Scala_Coll {def main(args: Array[String]): Unit = {val arr1 = Array(1,2,3,4)
// 将不可变数组 arr1 转换为可变数组
val arr2 = arr1.toBuffer
// 将可变数组 arr2 转换为不可变数组
val arr3 = arr2.toArray
}
}2.2 Seq 汇合
2.2.1 不可变 list
object Scala_Coll {def main(args: Array[String]): Unit = {
// 不可变 list
// 1. 申明对象
val list = List(1, 2, 3, 4)
// 2. 减少元素，返回新的 list
val list1 = list :+ 1
// 3. 遍历 list
list1.foreach(println)
// 4. 空集合 Nil
// 个别用于减少数据
val list2 = 1 :: 2 :: 3 :: 4 :: Nil
println(list2.mkString(","))
// 增加汇合
val list3 = 1 :: 2 :: 3 :: list1 :: Nil
println(list3.mkString(",")) // 输入后果 1,2,3,List(1, 2, 3, 4, 1)
// 咱们须要将 list1 的元素作为一个一个的个体应用，也就是扁平化操作
val list4 = 1 :: 2 :: 3 :: list1 ::: Nil
println(list4.mkString(",")) // 输入后果 1,2,3,1,2,3,4,1
// 5. 连贯汇合
val list5 = List.concat(list3, list4)
list5.foreach(println)
// 6. 创立一个指定反复数量的列表
val list6 = List.fill[String](3)("Hello")
list6.foreach(println)
}
}
2.2.2 可变 list
import scala.collection.mutable.ListBuffer
object Scala_Coll {def main(args: Array[String]): Unit = {
// 1. 可变 list
var list1 = new ListBuffer[Int]
// 2. 减少数据
list1.append(1,2,3,4)
val list2 = list1 :+ 5
list1+=5
println(list1.mkString(","))
println(list2.mkString(","))
val list3 = list1 ++ list2
println(list3.mkString(","))
// 3. 批改数据
list1.update(1,10)
println(list1(1))
// 4. 删除数据
list1.remove(1,2)
println(list1.mkString(","))
// 5. 获取数据
println(list1(1))
}
}
2.2.3 可变 list 和不可变 list 的互相转换
import scala.collection.mutable.ListBuffer
object Scala_Coll {def main(args: Array[String]): Unit = {
// 创立一个不可变汇合
var list = List(1,2,3,4)
// 将不可变汇合转变为可变汇合
val buffer = list.toBuffer
// 将可变汇合 buffer 转变为不可变汇合
val list1 = buffer.toList
}
}2.3 Map 映射
2.3.1 不可变 Map
import scala.collection.mutable.ListBuffer
object Scala_Coll {def main(args: Array[String]): Unit = {
// 1. 创立 Map 两种形式
val map1 = Map("a"->"张三","b"->"李四","c"->"王五")
val map2 = Map(("a","张三"),("b","李四"),("c","王五"))
println(map1)
println(map2)
// 2. 增加数据
val map3 = map1 + ("d" -> "张三丰")
println(map3)
// 3. 删除数据
val map4 = map3 - "d"
println(map4)
// 4. 批改数据
val map5 = map4.updated("b", "黄蓉")
println(map5)
// 5. 遍历
map5.foreach(println)
// 6. 获取指定 key 的值
val str = map5.apply("a")
println(str)
// 7. 获取可能存在的 key 值
val maybeString:Option[String] = map5.get("a")
println(maybeString.get) // 如果是从 None 值获取会产生异样
println(maybeString.getOrElse(-1)) // 如果获取到返回值，获取不到返回默认值
// 更加简洁的用法
val value = map5.getOrElse("d", -1)
println(value)
}
}2.3.2 可变 Map
import scala.collection.mutable
object Scala_Coll {def main(args: Array[String]): Unit = {
// 申明可变 Map
val map1 = mutable.Map("a" -> "郭靖", "b" -> "黄蓉")
val map2 = mutable.Map(("a","杨过"),("b","小龙女"))
// 增加数据
map1.put("c","郭襄")
val map3 = map1 + ("d" -> "郭芙")
map1 += ("d"->"郭芙")
// 批改数据
map1.update("d","郭破虏")
map1("d") = "郭芙"
// 删除数据
map1.remove("d")
}
}
2.4 元组
object Scala_Coll {def main(args: Array[String]): Unit = {
// 元组能够看成是包容元素的容器，最多能够包容 22 个元素
// 申明一个元组
val tuple = (1, "a", "张三丰", 18)
// 元组中的数据能够通过数据的程序来拜访
println(tuple._1)
println(tuple._2)
println(tuple._3)
println(tuple._4)
// 元组遍历
val iterator = tuple.productIterator
while (iterator.hasNext){println(iterator.next())
}
// 对偶元组: 只有两个元素, 也能够叫键值对
val map = Map(("a", "张三丰"), ("b", "张翠山")) // 这种申明形式，外面就是对偶元组
}
}
正文完
