1) Scala 同时支持不可变集合和可变集合,不可变集合可以安全的并发访问
两个主要的包:
不可变集合:scala.collection.immutable
可变集合: scala.collection.mutable
2) Scala 默认采用不可变集合,对于几乎所有的集合类,Scala 都同时提供了可变(mutable)和不可
变(immutable)的版本
3) Scala 的集合有三大类:序列 Seq(有序的,Linear Seq)、集 Set、映射 Map【key->value】,所有的
集合都扩展自 Iterable 特质,在 Scala 中集合有可变(mutable)和不可变(immutable)两种类型。
4) 不可变集合:scala 不可变集合,就是这个 集合本身不能动态变化。(类似 java 的数组,是不可
以动态增长的)
5) 可变集合:可变集合,就是这个 集合本身可以动态变化的。(比如:ArrayList , 是可以动态增长的)
不可变数组使用方式
def main(args: Array[String]): Unit = {
//声明数组第一种方式
//说明
//1. 创建了一个 Array 对象,
//2. [Int] 表示泛型,即该数组中,只能存放 Int
//3. [Any] 表示 该数组可以存放任意类型
//4. 在没有赋值情况下,各个元素的值 0
//5. arr01(3) = 10 表示修改 第 4 个元素的值
val arr01 = new Array[Int](4) //底层 int[] arr01 = new int[4]
println(arr01.length) // 4
println("arr01(0)=" + arr01(0)) // 0
//数据的遍历
for (i <- arr01) {
println(i)
}
println("--------------------")
arr01(3) = 10 //
for (i <- arr01) {
println(i)
}
//声明数组第二种方式
//说明
//1. 使用的是 object Array 的 apply
//2. 直接初始化数组,这时因为你给了 整数和 "", 这个数组的泛型就 Any
//3. 遍历方式一样
var arr02 =Array(1, 3, "xx")
arr02(1) = "xx"
for (i <- arr02) {
println(i)
}
//可以使用我们传统的方式遍历,使用下标的方式遍历
for (index <- 0 until arr02.length) {
printf("arr02[%d]=%s", index , arr02(index) + "\t")
}
}
可变数组使用方式
def main(args: Array[String]): Unit = {
import scala.collection.mutable.ArrayBuffer
//创建 ArrayBuffer
val arr01 =ArrayBuffer[Any](3, 2, 5)
//访问,查询
//通过下标访问元素
println("arr01(1)=" + arr01(1)) // arr01(1) = 2
//遍历
for (i <- arr01) {
println(i)
}
println(arr01.length) //3
println("arr01.hash=" + arr01.hashCode())
//修改 [修改值,动态增加]
//使用 append 追加数据 ,append 支持可变参数
//可以理解成 java 的数组的扩容
arr01.append(90.0,13) // (3,2,5,90.0,13)
println("arr01.hash=" + arr01.hashCode())
println("===================")
arr01(1) = 89 //修改 (3,89,5,90.0,13)
println("--------------------------")
for (i <- arr01) {
println(i)
}
//删除...
//删除,是根据下标来说
arr01.remove(0) // (89,5,90.0,13)
println("--------删除后的元素遍历---------------")
for (i <- arr01) {
println(i)
}
println("最新的长度=" + arr01.length) // 4
}
变长数组分析小结
1) ArrayBuffer 是变长数组,类似 java 的 ArrayList
2) val arr2 =ArrayBuffer[Int]() 也是使用的 apply 方法构建对象
3) def append(elems: A*) { appendAll(elems) } 接收的是可变参数.
4) 每 append 一次,arr 在底层会重新分配空间,进行扩容,arr2 的内存地址会发生变化,也就成
为新的 ArrayBuffer
定长数组与变长数组的转换
说明
在开发中,我们可能使用对定长数组和变长数组,进行转换
arr1.toBuffer //定长数组转可变数组
arr2.toArray //可变数组转定长数组
注意事项:
arr2.toArray 返回结果才是一个定长数组, arr2 本身没有变化
arr1.toBuffer 返回结果才是一个可变数组, arr1 本身没有变化
def main(args: Array[String]): Unit = {
import scala.collection.mutable.ArrayBuffer
val arr2 =ArrayBuffer[Int]()
// 追加值
arr2.append(1, 2, 3)
println(arr2)
//说明
//1. arr2.toArray 调用 arr2 的方法 toArray
//2. 将 ArrayBuffer ---> Array
//3. arr2 本身没有任何变化
val newArr = arr2.toArray
println(newArr)
//说明
//1. newArr.toBuffer 是把 Array->ArrayBuffer
//2. 底层的实现
/*
override def toBuffer[A1 >:A]: mutable.Buffer[A1] = {
val result = new mutable.ArrayBuffer[A1](size)
copyToBuffer(result)
result
}
*/
//3. newArr 本身没变化
val newArr2 = newArr.toBuffer
newArr2.append(123)
println(newArr2)
// //案例演示+说明
}
多维数组的定义和使用
def main(args: Array[String]): Unit = {
//创建
val arr =Array.ofDim[Int](3, 4)
//遍历
for (item <- arr) { //取出二维数组的各个元素(一维数组)
for (item2 <- item) { // 元素(一维数组) 遍历
print(item2 + "\t")
}
println()
}
//指定取出
println(arr(1)(1)) // 0
//修改值
arr(1)(1) = 100
//遍历
println("=====================")
for (item <- arr) { //取出二维数组的各个元素(一维数组)
for (item2 <- item) { // 元素(一维数组) 遍历
print(item2 + "\t")
}
println()
}
//使用传统的下标的方式来进行遍历
println("===================")
for (i <- 0 to arr.length - 1) { //先对
for (j <- 0 to arr(i).length - 1) {
printf("arr[%d][%d]=%d\t", i, j, arr(i)(j))
}
println()
}
}
数组-Scala 数组与 Java 的 List 的互转
def main(args: Array[String]): Unit = {
import scala.collection.mutable.ArrayBuffer
// Scala 集合和 Java 集合互相转换
val arr = ArrayBuffer("1", "2", "3")
/*
implicit def bufferAsJavaList[A](b : scala.collection.mutable.Buffer[A]) : java.util.List[A] = { /*
compiled code */ }
*/
import scala.collection.JavaConversions.bufferAsJavaList
//对象 ProcessBuilder , 因为 这里使用到上面的 bufferAsJavaList
val javaArr = new ProcessBuilder(arr) //为什么可以这样使用?
// 这里 arrList 就是 java 中的 List
val arrList = javaArr.command()
println(arrList) //输出 [1, 2, 3]
//java 的 List 转成 scala 的 ArrayBuffer
//说明
//1. asScalaBuffer 是一个隐式函数
/*
implicit def asScalaBuffer[A](l : java.util.List[A]) : scala.collection.mutable.Buffer[A] = { /* compiled
code */ }
*/
import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable
// java.util.List ==> Buffer
val scalaArr: mutable.Buffer[String] = arrList
scalaArr.append("jack")
scalaArr.append("tom")
scalaArr.remove(0)
println(scalaArr) // (2,3,jack,tom)
}
元组 Tuple-元组的基本使用
基本介绍
元组也是可以理解为一个容器,可以存放各种相同或不同类型的数据。
说的简单点,就是将多个无关的数据封装为一个整体,称为元组, 最多的特点灵活,对数据没有过
多的约束。
注意:元组中最大只能有 22 个元素
访问元组中的数据,可以采用顺序号(_顺序号),也可以通过索引(productElement)访问。
def main(args: Array[String]): Unit = {
println("==================访问元组=========================")
//访问元组
val t1 = (1, "a", "b", true, 2)
println(t1._1) // 1 //访问元组的第一个元素 ,从 1 开始
/*
override def productElement(n: Int) = n match {
case 0 => _1
case 1 => _2
case 2 => _3
case 3 => _4
case 4 => _5
case _ => throw new IndexOutOfBoundsException(n.toString())
}
*/
println(t1.productElement(0)) // 0 // 访问元组的第一个元素,从 0 开始
println("==================遍历元组=========================")
//遍历元组, 元组的遍历需要使用到迭代器
for (item <- t1.productIterator) {
println("item=" + item)
}
}
列表 List的使用,不可变的
Scala 中的 List 和 Java List 不一样,在 Java 中 List 是一个接口,真正存放数据是 ArrayList,而 Scala
的 List 可以直接存放数据,就是一个 object,默认情况下 Scala 的 List 是不可变的,List 属于序列 Seq。
val List = scala.collection.immutable.List
object List extends SeqFactory[List]
1) List 默认为不可变的集合
2) List 在 scala 包对象声明的,因此不需要引入其它包也可以使用
val List = scala.collection.immutable.List
3) List 中可以放任何数据类型,比如 arr1 的类型为 List[Any]
4) 如果希望得到一个空列表,可以使用 Nil 对象, 在 scala 包对象声明的,因此不需要引入其它包也
可以使用
val Nil = scala.collection.immutable.Nil
def main(args: Array[String]): Unit = {
//说明
//1. 在默认情况下 List 是 scala.collection.immutable.List,即不可变
//2. 在 scala 中,List 就是不可变的,如需要使用可变的 List,则使用 ListBuffer
//3. List 在 package object scala 做了 val List = scala.collection.immutable.List
//4. val Nil = scala.collection.immutable.Nil // List()
val list01 = List(1, 2, 3) //创建时,直接分配元素
println(list01)
val list02 = Nil //空集合
println(list02)
//访问 List 的元素
val value1 = list01(1) // 1 是索引,表示取出第 2 个元素.
println("value1=" + value1) // 2
println("-------------list 追加元素后的效果-----------------")
//通过 :+ 和 +: 给 list 追加元素(本身的集合并没有变化)
var list1 = List(1, 2, 3, "abc")
// :+运算符表示在列表的最后增加数据
val list2 = list1 :+ 4 // (1,2,3,"abc", 4)
println(list1) //list1 没有变化 (1, 2, 3, "abc"),说明 list1 还是不可变
println(list2) //新的列表结果是 [1, 2, 3, "abc", 4]
val list3 = 10 +: list1 // (10,1, 2, 3, "abc")
println("list3=" + list3)
/*
1) 符号::表示向集合中 新建集合添加元素。
2) 运算时, 集合对象一定要放置在最右边,
3) 运算规则,从右向左。
4) ::: 运算符是将集合中的每一个元素加入到集合中去
*/
//:: 符号的使用
val list4 = List(1, 2, 3, "abc")
//说明 val list5 = 4 :: 5 :: 6 :: list4 :: Nil 步骤
//1. List()
//2. List(List(1, 2, 3, "abc"))
//3. List(6,List(1, 2, 3, "abc"))
//4. List(5,6,List(1, 2, 3, "abc"))
//5. List(4,5,6,List(1, 2, 3, "abc"))
val list5 = 4 :: 5 :: 6 :: list4 :: Nil
println("list5=" + list5)
//说明 val list6 = 4 :: 5 :: 6 :: list4 ::: Nil 步骤
//1. List()
//2. List(1, 2, 3, "abc")
//3. List(6,1, 2, 3, "abc")
//4. List(5,6,1, 2, 3, "abc")
//5. List(4,5,6,1, 2, 3, "abc")
val list6 = 4 :: 5 :: 6 :: list4 ::: Nil
println("list6=" + list6)
}
ListBuffer的基本使用,可变的
def main(args: Array[String]): Unit = {
import scala.collection.mutable.ListBuffer
//创建 ListBuffer
val lst0 = ListBuffer[Int](1, 2, 3)
//如何访问
println("lst0(2)=" + lst0(2)) // 输出 lst0(2)= 3
for (item <- lst0) { // 遍历,是有序
println("item=" + item)
}
// 动态的增加元素,lst1 就会变化, 增加一个一个的元素
val lst1 = new ListBuffer[Int] // 空的 ListBuffer
lst1 += 4 // lst1 (4)
lst1.append(5) // list1(4,5)
//
lst0 ++= lst1 // lst0 (1, 2, 3,4,5)
println("lst0=" + lst0)
val lst2 = lst0 ++ lst1 // lst2(1, 2, 3,4,5,4,5)
println("lst2=" + lst2)
val lst3 = lst0 :+ 5 // lst0 不变 lst3(1, 2, 3,4,5,5)
println("lst3=" + lst3)
println("=====删除=======")
println("lst1=" + lst1)
lst1.remove(1) // 表示将下标为 1 的元素删除
for (item <- lst1) {
println("item=" + item) //4
}
}
队列 Queue的使用
1) 队列是一个 有序列表,在底层可以用 数组或是 链表来实现。
2) 其输入和输出要遵循 先入先出的原则。即:先存入队列的数据,要先取出。后存入的要后取
3) 在 Scala 中,由设计者直接给我们提供队列类型 Queue 使用。
4) 在 scala 中, 有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue , 一般来说,我们在开发中通常使用可变集合中的队列。
def main(args: Array[String]): Unit = {
import scala.collection.mutable
//创建队列
val q1 = new mutable.Queue[Int]
println(q1)
//给队列增加元素
q1 += 9 // (9)
println("q1=" + q1) // (9)
q1 ++= List(4, 5, 7) // 默认值直接加在队列后面
println("q1=" + q1) //(9,4,5,7)
//q1 += List(10,0) // 表示将 List(10,0) 作为一个元素加入到队列中,
//dequeue 从队列的头部取出元素 q1 本身会变
val queueElement = q1.dequeue()
println("queueElement=" + queueElement + "q1=" + q1)
//enQueue 入队列,默认是从队列的尾部加入. Redis
q1.enqueue(100, 10, 100, 888)
println("q1=" + q1) // Queue(4, 5, 7, 100,10,100,888)
println("============Queue-返回队列的元素=================")
//队列 Queue-返回队列的元素
//1. 获取队列的第一个元素
println(q1.head) // 4, 对 q1 没有任何影响
//2. 获取队列的最后一个元素
println(q1.last) // 888, 对 q1 没有任何影响
//3. 取出队尾的数据 ,即:返回除了第一个以外剩余的元素,可以级联使用
println(q1.tail) // (5, 7, 100,10,100,888)
println(q1.tail.tail.tail.tail) // (10,100,888)
}
映射 Map的使用
Scala 中的不可变 Map 是有序,构建 Map 中的元素底层是 Tuple2 类型
def main(args: Array[String]): Unit = {
import scala.collection.mutable
//方式 1-构造不可变映射
//1.默认 Map 是 immutable.Map
//2.key-value 类型支持 Any
//3.在 Map 的底层,每对 key-value 是 Tuple2
//4.从输出的结果看到,输出顺序和声明顺序一致
val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
println(map1)
//方式 2-构造可变映射
//1.从输出的结果看到,可变的 map 输出顺序和声明顺序不一致
val map2 = mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
println(map2)
//方式 3-创建空的映射
val map3 = new scala.collection.mutable.HashMap[String, Int]
println(map3)
//方式 4-对偶元组
//说明
//即创建包含键值对的二元组, 和第一种方式等价,只是形式上不同而已。
//对偶元组 就是只含有两个数据的元组。
val map4 = mutable.Map(("Alice" , 10), ("Bob" , 20), ("Kotlin" , "北京"))
println("map4=" + map4)
//映射 Map-取值
//方式 1-使用 map(key)
//说明:
//1) 如果 key 存在,则返回对应的值
//2) 如果 key 不存在,则抛出异常[java.util.NoSuchElementException]
//3) 在 Java 中,如果 key 不存在则返回 null
val value1 = map2("Alice")
println(value1)
//抛出异常(java.util.NoSuchElementException: key not found:)
//println(map4("Alice~"))
//方式 2-使用 contains 方法检查是否存在 key
// 返回 Boolean
// 1.如果 key 存在,则返回 true
// 2.如果 key 不存在,则返回 false
//使用 containts 先判断在取值,可以防止异常,并加入相应的处理逻辑
if (map4.contains("Alice")) {
println("key 存在,值=" + map4("Alice"))
} else {
println("key 不存在:)")
}
//方式 3-使用 map.get(key).get 取值
//通过 映射.get(键) 这样的调用返回一个 Option 对象,要么是 Some,要么是 None
//1) map.get 方法会将数据进行包装
//2) 如果 map.get(key) key 存在返回 some,如果 key 不存在,则返回 None
//3) 如 果 map.get(key).get key 存 在 , 返 回 key 对 应 的 值 , 否 则 , 抛 出 异 常
//java.util.NoSuchElementException: None.get
//1. 如果 key 存在 map.get(key) 就会返回 Some(值) ,然后 Some(值).get 就可以取出
//2. 如果 key 不存在 map.get(key) 就会返回 None
println(map4.get("Alice").get)
//println(map4.get("Alice~").get) // 抛出异常
//方式 4-使用 map4.getOrElse()取值
// getOrElse 方法 : def getOrElse[V1 >: V](key: K, default: => V1)
// 说明:
//1) 如果 key 存在,返回 key 对应的值。
//2) 如果 key 不存在,返回默认值。也就是"默认的值 鱼 <・)))><<"这句话,第二个参数
println(map4.getOrElse("Alice~~~","默认的值 鱼 <・)))><<"))
//如何选择取值的方式,加判断的肯定效率没直接获取效率来的快
//1) 如果我们确定 map 有这个 key ,则应当使用 map(key), 速度快
//2) 如果我们不能确定 map 是否有 key ,而且有不同的业务逻辑,使用 map.contains() 先判断在加入逻辑
//3) 如果只是简单的希望得到一个值,使用 map4.getOrElse("ip","127.0.0.1")
//Map-对 map 修改、添加和删除
//更新 map 的元素
//1) map 是可变的,才能修改,否则报错
//2) 如果 key 存在:则修改对应的值,key 不存在, 等价于添加一个 key-val
val map5 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map5("A") = 20 //增加
map5 += ("D" -> 4)
map5 += ("B" -> 5)
//添加多个元素
map5 += ("E" -> 6,"F" -> 7)
val map6 = map5 + ("g" -> 9,"z" -> 8)
println(map6)
//删除元素
//1) "A","B" 就是要删除的 key, 可以写多个.
//2) 如果 key 存在,就删除,如果 key 不存在,也不会报错.
map5 -= ("A","B","AAA") //直接填key就行了
println("map5=" + map5)
//映射 Map-对 map 遍历
//对 map 的元素(元组 Tuple2 对象 )进行遍历的方式很多,具体如下
//val map1 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
//for ((k, v) <- map1) println(k + " is mapped to " + v)
//for (v <- map1.keys) println(v)
//for (v <- map1.values) println(v)
//for(v <- map1) println(v) //v 是 Tuple?
//说明
//1.每遍历一次,返回的元素是 Tuple2
//2.取出的时候,可以按照元组的方式来取
val map7 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
println("----(k, v) <- map6--------")
for ((k, v) <- map7) println(k + " is mapped to " + v)
println("----v <- map6.keys--------")
for (v <- map7.keys) println(v)
println("----v <- map6.values--------")
for (v <- map7.values) println(v)
//这样取出方式 v 类型是 Tuple2
println("----v <- map7--------")
for (v <- map7) println(v + " key =" + v._1 + " val=" + v._2) //v 是 Tuple?
}
集 Set-基本使用
集是 不重复元素的结合。集 不保留顺序,默认是以 哈希集实现
def main(args: Array[String]): Unit = {
import scala.collection.mutable
val set = Set(1, 2, 3) //不可变
println(set)
val mutableSet = mutable.Set(1,2,"hello") //可以变
println("mutableSet" + mutableSet)
//可变集合的元素添加
//说明:如果添加的对象已经存在,则不会重复添加,也不会报错
mutableSet.add(4) //方式 1
mutableSet += 6 //方式 2
mutableSet.+=(5) //方式 3
//删除
//说明:说明:如果删除的对象不存在,则不生效,也不会报错
val set02 = mutable.Set(1,2,4,"abc")
set02 -= 2 // 操作符形式
set02.remove("abc") // 方法的形式,scala 的 Set 可以直接删除值
//set 集合的遍历操作
val set03 = mutable.Set(1, 2, 4, "abc")
for(x <- set03) {
println(x)
}
}