标签：Set String val Scala Int println 集合 Array
目录
一、集合简介
（1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。
（2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包。
不可变集合：scala.collection.immutable
可变集合： scala.collection.mutable
（3）不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象
（4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于java中StringBuilder对象
注：Scala中的List与Java中的List是不同的概念。
二、数组
1.不可变数组
定义：val arr = new Array[Int](10)
（1）new是关键字
（2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any
（3）(10)，表示数组的大小，确定后就不可以变化
scala中的不可变数组array是为了和java的[]数组进行对应，所以具有同样的特性，长度不可变但是内容可以修改。（本质调用伴生对象的apply方法）
def main(args: Array[String]): Unit = {
//静态定义不可变数组
val ints1: Array[Int] = Array(1,2,3,4,5)
//动态定义数组 动态构建里面的元素全部为初始值 例如int就是0
val ints2: Array[Int] = new Array[Int](6)
//修改 使用apply方法
ints2(0) = 1
//使用update方法
ints2.update(1,66)
//循环打印
for (elem <- ints2) {
println(elem)
}
//迭代器打印
val iterator: Iterator[Int] = ints2.iterator
while (iterator.hasNext){
println(iterator.next())
}
//定义函数打印方法
def myPrint(i :Int): Unit = println(i * 2 + 5)
ints2.foreach(myPrint)
ints2.foreach((i :Int) => println(i * 2 + 5))
ints2.foreach(i => println(i * 2 + 5) )
//常规方法
ints2.foreach(println)
//输出
println(ints1.toList)
println(ints2.toList)
// 因为是不可变,不会修改原数组 会在新生成的数组上改变
val ints3: Array[Int] = ints2 :+ 5
println(ints2.toList)
println(ints3.toList)
}2.可变数组
val arr = ArrayBuffer[Any](5, 7, 9,3)
（1）[Any]存放任意数据类型
（2）(5, 7, 9,3)初始化好的四个元素
（3）ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer
def main(args: Array[String]): Unit = {
//填写的数字是底层存储的初始长度 => 默认是16
//数组的长度只和里面存储元素的个数有关
val ints: ArrayBuffer[Int] = new ArrayBuffer[Int]()
//计算数组长度
val length: Int = ints.length
println(length)
//使用apply方法创建
val buffer: ArrayBuffer[Any] = ArrayBuffer(1,2,3,"ls")
buffer.foreach(println)
//添加元素
buffer.append(4)
buffer :+ 5 //:+ 即使是可变集合也加不进去元素
buffer.foreach(println)
buffer += 5 //可以加进去
buffer.foreach(println)
//可以添加多个元素
buffer.append(20, 30, 40)
println(buffer)
//在数组第一个位置添加元素
buffer.prepend(0)
println(buffer)
//数组的合并
buffer.appendAll(Array(3, 4, 5))
println(buffer)
//删除数组
buffer.remove(1, 2)
println(buffer)
// 修改查看，建议使用apply方法
println(buffer(0))
buffer.update(1, 100)
println(buffer)
buffer(1) = 200
println(buffer)
}3.不可变数组与可变数组以及Set的转换
arr1.toBuffer //不可变数组转可变数组
arr2.toArray //可变数组转不可变数组
arr1.toSet //转化为Set集合
（1）arr2.toArray返回结果才是一个不可变数组，arr2本身没有变化
（2）arr1.toBuffer返回结果才是一个可变数组，arr1本身没有变化
// 可变数组和不可变数组的转换
val array: Array[Int] = Array(1, 2, 3, 1, 2, 3)
val arrayBuffer: ArrayBuffer[Int] = ArrayBuffer(4, 5, 6)
// 不可变数组转换为可变数组
val buffer2: mutable.Buffer[Int] = array.toBuffer
// 可变转换为不可变数组
val array1: Array[Int] = arrayBuffer.toArray
println(array.toList) //List(1, 2, 3, 1, 2, 3)
println(arrayBuffer) //ArrayBuffer(4, 5, 6)
println(buffer2) //ArrayBuffer(1, 2, 3, 1, 2, 3)
println(array1.toList) //List(4, 5, 6)
val set1: Set[Int] = array.toSet
val set2: Set[Int] = arrayBuffer.toSet
println(set1) //Set(1, 2, 3)
println(set2) //Set(4, 5, 6)4.多维数组
创建方法：
1.val array: Array[Array[Int]] = new Array[Array[Int]](4)
2.val arrayDim: Array[Array[Int]] = Array.ofDim[Int](3, 4)
def main(args: Array[String]): Unit = {
val array: Array[Array[Int]] = new Array[Array[Int]](4)
array(0) = Array(1, 2, 3, 4)
array(1) = Array(1, 2, 3, 4)
array(2) = Array(1, 2, 3, 4)
array(3) = Array(1, 2, 3, 4)
for (elem <- array) {
for (elem01 <- elem) {
print(elem01 + "\t")
}
println()
}
val array1: Array[Array[Int]] = Array.ofDim(3, 4)
array1(0)(0) = 250
for (elem <- array1) {
for (elem01 <- elem) {
print(elem01 + "\t")
}
println()
}
}三、Seq集合
1.不可变List
（1）List默认为不可变集合
（2）创建一个List（数据有顺序，可重复）
（3）遍历List
（4）List增加数据
（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
（6）取指定数据
（7）空集合Nil
操作举例：
def main(args: Array[String]): Unit = {
// List默认为不可变集合
// 创建一个List（数据有顺序，可重复）
// list无法使用new 来创建 => 因为他是一个不可变list,导致里面的元素值也不能修改
// 所以new创建出来如果都是0,不能修改,因此没法使用
val ints: List[Int] = List(1,2,3,4)
ints.foreach(println)
println(ints)
//增加数据
val ints2 = ints :+ 5
println(ints2)
//头插
val ints3: List[Int] = 6 :: ints
println(ints3)
//扁平化
val ints4: List[Int] = List(7,8,9)
val ints5: List[Any] = ints :: ints4
println(ints5) //List(List(1, 2, 3, 4), 7, 8, 9)
//扁平化类似于sql中的炸裂函数 将一个集合查分为多个单个的元素放入
val ints6: List[Int] = ints ::: ints4
println(ints6) //List(1, 2, 3, 4, 7, 8, 9)
//取元素 不可以修改元素
val i: Int = ints6(0)
println(i)
//Nil空集合
val ints7: List[Int] = 1 :: 2 :: 3 :: Nil
println(ints7)
}2.可变ListBuffer
（1）创建一个可变集合ListBuffer
（2）向集合中添加数据
（3）删除元素
（4）查看元素
（5）修改元素
操作举例：
def main(args: Array[String]): Unit = {
val ints: ListBuffer[Int] = new ListBuffer[Int]()
val ints1: ListBuffer[Int] = ListBuffer(1,2,3,4)
//添加
ints1.append(5)
//删除
ints1.remove(1)
println(ints1)
//查看
val i: Int = ints1(1)
println(i)
//修改
ints1(2) = 250
println(ints1)
}四、Set集合
1.不可变Set
（1）Set默认是不可变集合
（2）数据无序不可重复
（3）默认使用hashset
def main(args: Array[String]): Unit = {
val set: Set[Int] = Set(1,2,3,4,5,6,7)
//set的特性 无序 不可重复
println(set)//Set(5, 1, 6, 2, 7, 3, 4)
// 默认使用hashset,当元素小于等于4个时,会进行特殊的优化(从小到大顺序排序)
println(set.isInstanceOf[HashSet[Int]])
val ints = Set(4,5,6,4,8,9,8,1,2,4,1)
println(ints) //Set(5, 1, 6, 9, 2, 8, 4)
//添加
val ints2: Set[Int] = ints + 20
println(ints2) //Set(5, 20, 1, 6, 9, 2, 8, 4)
}2.可变Set
创建可变集合mutable.Set
val ints = Set(4,5,6,4,8,9,8,1,2,4,1)
println(ints) //Set(5, 1, 6, 9, 2, 8, 4)
//添加
val ints2: Set[Int] = ints + 20
println(ints2) //Set(5, 20, 1, 6, 9, 2, 8, 4)
val ints3: mutable.Set[Int] = mutable.Set(2,5,7,6,2,3,1,1)
println(ints3)
// 可变set能够添加元素,添加的元素一样没有顺序
ints3.add(20)
println(ints3)
val bool: Boolean = ints3.add(30) //true 不存在30 可添加
println(bool)
// 判断set中是否存在元素
val bool1: Boolean = ints3.contains(30)
println(bool1)五、Map集合
Scala中的Map也是一个散列表，存储的内容也是键值对（key-value）映射
1.不可变集合
def main(args: Array[String]): Unit = {
val map1: Map[String, Int] = Map("hi" -> 1,"hello" -> 2)
println(map1)
val map2: Map[String, Int] = Map(("hi",1),("hello",2))
println(map2)
// 不可变map内容不能修改,也不能添加元素,只可以读取
for (elem <- map2) {
val key: String = elem._1
val value: Int = elem._2
println("key:" + key + "\t" + "value:" + value)
}
val keys: Iterable[String] = map2.keys
val values: Iterable[Int] = map2.values
println(keys.toList)
println(values.toList)
// 通过key获取value
// 避免空值异常 如果获取的key不存在 value为任意类型 可以为数值类型
// 数值类型不能使用null值表示 需要使用Option表示
// option用于封装数据 代替null值, 如果数值存在 使用some子类表示 如果不存在使用None表示
val option: Option[Int] = map2.get("hello01")
println(option) //None
if(!option.isEmpty){
val value1 :Int = option.get
println(value1)
}
//使用ption优化的方法
val i: Int = option.getOrElse(10) //如果没有 就返回10
println(i)
val j: Int = map2.get("hello").getOrElse(10)
println(j)
// 如果有值 获取值作为返回结果 如果没有值 使用第二个参数作为默认值
val i1: Int = map2.getOrElse("hello",0)
println(i1)
//使用apply方法读取
val i2: Int = map2("hello")
println(i2)
}2.可变集合
val map3: mutable.HashMap[String, Int] = new mutable.HashMap[String,Int]()
val map4: mutable.Map[String, Int] = mutable.Map(("hi",1),("hello",2))
//添加
//如果存在会修改value值 如果不存在会添加元素
map4.update("nihao",3)
println(map4)
map4.put("nihao",5)
println(map4)
//使用apply
map4("nihao") = 100
println(map4)
//删除
map4.remove("nihao")
println(map4)六、元组
元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。
注意：元组中最大只能有22个元素。
Map中的键值对其实就是元组,只不过元组的元素个数为2，称之为对偶
def main(args: Array[String]): Unit = {
val list: List[Any] = List(1,3.14,"l s")
// 如果list存放的数据类型不一致,那么里面的类型会被标记为共同的父类
// 导致每个元素自身的类型丢失
val unit: Any = list(2)
println(unit)
// 如果需要对string进行操作 需要自己完成类型转换
if(unit.isInstanceOf[String]){
val str: String = unit.asInstanceOf[String]
val strings: Array[String] = str.split(" ")
println(strings.toList)
}
// 引入元组来保存不同类型的数据,能够记录下每个位置元素的类型
val tuple: (String, Int) = new Tuple2[String,Int]("hi",1)
val key: String = tuple._1
val value: Int = tuple._2
// tuple在创建的时候,直接使用()来表示
val tuple01: (String, Int) = ("hi",1)
//创建map时 可以用二元组来表示
val map: Map[String, Int] = Map(("hi",1),("nihao",2))
for (elem <- map) {
val key01: String = elem._1
val value01: Int = elem._2
}
//map与list转换
val list1: List[(String, Int)] = map.toList
println(list1)
//打印
list1.foreach((tuple:(String,Int)) =>println(tuple._1 + "\t" + tuple._2))
}七、队列
Scala也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方法分别为enqueue和dequeue。
def main(args: Array[String]): Unit = {
val queue: Queue[Int] = Queue(1,2,3,4)
// 不可变队列即使调用进队的方法 也没有办法将数据加入到队列中 必须创建新对象
val queue1: Queue[Int] = queue.enqueue(5)
println(queue)
println(queue1)
// 返回值需要保留两个数据 所以设计成了二元组
// (数据,弹出之后剩下的队列)
val dequeue: (Int, Queue[Int]) = queue.dequeue
println(dequeue) //(1,Queue(2, 3, 4))
val queue2: mutable.Queue[Int] = new mutable.Queue[Int]()
queue2.enqueue(1,2,3)
println(queue2)
val i: Int = queue2.dequeue()
println(i) //1
println(queue2) //Queue(2, 3)
}八、并行集合
Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。
def main(args: Array[String]): Unit = {
// 单线程运行
// 常规写的代码都是单线程的 在main线程中 有序
val inclusive: Range.Inclusive = 1 to 100
//inclusive.foreach((i:Int ) => println(i+ Thread.currentThread().getName))
// 使用并行集合
// 会开启多个线程完成任务 造成乱序 只在单个线程中是有序的
inclusive.par.foreach((i:Int ) => println(i+Thread.currentThread().getName))
}标签：Set,String,val,Scala,Int,println,集合,Array 来源： https://blog.csdn.net/lslslslslss/article/details/122627786
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。