Scala数组| 集合
arrays :+ 5尾部 头部5 +: arrays
TODO 声明不可变数组,不能删; 默认情况下,scala中集合的声明全都是不可变的
val arrays: Array[Int] = Array(1, 2, 3, 4)
//增加 不可变使用伴生对象添加数
val newArrays1: Array[Int] = arrays :+5 //1,2,3,4,5 // 增加数据到集合的尾部,产生新的集合
val newArrays2: Array[Int] = 6+:arrays //6,1,2,3,4 // 增加数据到集合的头部,产生新的集合
//println(newArrays.length)
//println(arrays == newArrays1) //false ; ==是否是同一块内存
//println(arrays.length) // 修改数据:数组(索引) = 修改的值; 修改,不变的是内存地址,里边内容可以变
arrays(1)=1
println(arrays.mkString(",")) //1,1,3,4 // 获取数组中的数据
//println(arrays(3))
//循环遍历
for (elem <- arrays) {
println(elem)
}
//println(arrays.mkString(",")) // 生成字符串 // 将不可变数组变成可变数组
arrays.toBuffer
TODO 声明可变数组 可变数组的数据操作其实都是对同一个数组做操作
arrayBuffer+=5,跟之前数组是同一个内存地址,即一个数组
var arrayBuffer: ArrayBuffer[Int] = ArrayBuffer(1,2,3,4,5)
// 增加数据
var newArrayBuffer: ArrayBuffer[Int] = arrayBuffer:+6
var newArrayBuffer1: ArrayBuffer[Int] = 7+:arrayBuffer
println(arrayBuffer == newArrayBuffer) //false +=6就是true // 修改数据
arrayBuffer.insert(2, 9)
arrayBuffer.update(1, 3) arrayBuffer(0) = 6
println(arrayBuffer.mkString(",")) //1,2,9,3,4,5
//println(newArrayBuffer1.mkString(",")) //7,1,2,3,4,5 // 删除数据
//arrayBuffer.remove(2) //按索引删 // 如果删除的个数超过数组的容量,会发生错误
//arrayBuffer.remove(2, 2) //删索引后的后两位
//arrayBuffer-=5 //arrayBuffer-5它是针对新集合的,arrayBuffer-=5是操作完之后重新赋值给arrayBuffer,删除的是元素 //查询
println(arrayBuffer(2))
for (elem <- arrayBuffer) {
print(elem)
} def test(i: Int): Unit = {
print(i)
}
// foreach方法会传递一个函数作为参数; foreach方法会将集合的每一个元素都调用这个函数
arrayBuffer.foreach(test)
//arrayBuffer.foreach((i: Int) => {print(i)})
//arrayBuffer.foreach(i => {print(i)})
//arrayBuffer.foreach({print(_)})
//arrayBuffer.foreach(print(_)) arrayBuffer.foreach(print) //只有一个参数时(_)也可以省略 // 将可变数组变成不可变数组
arrayBuffer.toArray
list -- seq序列
TODO immutable : 不可变// java:list ==> scala:Seq :紧挨着集合表增加
val list: List[Int] = List(1,2,3,4)
// 增加数据
list:+5
val newList: List[Int] = 5+:list //5,1,2,3,4 // 特殊的List集合对象, Nil => List()
val nil: List[Nothing] = List()
val nils: List[Int] = nil:+3 //3 // 给空集合增加数据,不是空集合也可以, 元素可以重复
// 双冒号的运算规则是从右向左
val list1: List[Int] = 1:: 2:: 3:: 4:: nils //1,2,3,4,3
println(list1.mkString(","))
val list2: List[Int] = 5:: list //5,1,2,3,4 加在头部
println(list2.mkString(",")) val list3: List[Any] = 5:: list:: nils //5,List(1, 2, 3, 4),3 list作为整体
val list3: List[Any] = 5:: list::: nils //5,1,2,3,4,3 整体拆开--扁平化
println(list3.mkString(","))
// 修改数据:list无法通过索引的方式对象数据进行修改 //list(1) = 7
// 可以通过updated方法修改数据,但是会产生新集合
val newUpdateList: List[Int] = list.updated(1, 8) //1,8,3,4
println(newUpdateList.mkString(",")) // 删除数据,产生新的集合
val dropList: List[Int] = list.drop(2) //删除前两个
println("删除="+ dropList.mkString(",")) //删除=3,4 // 查询数据
println(list(1)) //2
// 获取指定个数的数据,产生新的集合
println(list.take(3)) //List(1, 2, 3)
for (elem <- list) {}
list.foreach(println)
mutable : 可变,易变 ListBuffer
val listBuffer: ListBuffer[Int] = ListBuffer(1,2,3,4)
//listBuffer.insert(1, 6)
//listBuffer.remove(1)
//listBuffer.updated(1, 9) val listBuffer1: ListBuffer[Int] = listBuffer+=5 //内存指向同一块
val listBuffer2: ListBuffer[Int] = listBuffer-=4
println(listBuffer.mkString(",")) //1,2,3,5
println(listBuffer1.mkString(","))//1,2,3,5
println(listBuffer2.mkString(","))//1,2,3,5 listBuffer(1)=9
println(listBuffer.mkString(",")) println(listBuffer.to) //Vector(1, 9, 3, 5)
println(listBuffer(0)) //1
for (elem <- listBuffer) {}
//listBuffer.foreach(println)
队列特殊集合:mutable.Queue 队列, 必须为可变的 先进先出
// TODO 队列, 必须为可变的 先进先出
val mqueue: mutable.Queue[Int] = new mutable.Queue
// 增加数据
/* mqueue += 1
mqueue += 2*/
mqueue.enqueue(1,2,3,4,5,6)
println("Before=" + mqueue) //Before=Queue(1, 2, 3, 4, 5, 6)
println(mqueue.dequeue()) //
println(mqueue.dequeue()) //2 按增加数据去取
println("after = " + mqueue) //after = Queue(3, 4, 5, 6)
Set:immutable 无序 不可变-- java:set ==> scala:Set
val set: Set[Int] = Set(1,2,3,4)
// 增加数据
//set:+1 //报错
println(set + 5) //Set(5, 1, 2, 3, 4) 形成新的集合
// 删除数据
println(set.drop(2)) //Set(3, 4),删除前两个
//修改,没有update; 无序,没有索引;
println(set - 2) //Set(1, 3, 4) // 获取数据
println(set(1)) //set集合中有这个元素就返回true,没有返回false
println(set) //Set(1, 2, 3, 4)
println(set.mkString(",")) //1,2,3,4
for (elem <- set) {}
//set.foreach(println)
mutable.set可变
val mset = mutable.Set(1,2,3,4)
// 加号运算一定会产生新的集合
mset+=5 //产生新的集合又赋值给它
mset+6 ///产生新的集合
println(mset.add(7)) //true 添加元素 val list = List(11,22,33,44)
mset++=(list) //添加集合
println(mset.mkString(",")) //33,1,5,2,3,7,4,22,11,44 // 修改数据,等同于增加或删除。
//mset.update(9, false) ////true就是添加元素到mset集合; false是不添加 // 删除数据
//mset.remove(1) //删除元素1
//mset-=44 //删除元素44 // 查询数据
println(mset.head) //
println(mset.tail) // tail :集合中除了头以外的元素 Set(1, 5, 2, 3, 7, 4, 22, 11, 44)
println(mset.last) //最后一个元素
println(mset.init) // init : 集合中除了最后一个以外的元素
println(mset) // java:map ==> scala:Map
println(mset.mkString(","))
Map
scala中的map也是存储k v对 ,转换结构,把a 转换为另外一个结构的 a
不可变的Map集合 没有专门类,就是包
val map: Map[String, Int] = Map("a" -> 1, "b" -> 2)
println(map + ("c" -> 3)) //Map(a -> 1, b -> 2, c -> 3) 产生新集合
println(map.updated("b", 5)) //Map(a -> 1, b -> 5)
println(map - "b") //Map(a -> 1) 新的集合 // Option : Some就是有值或者 None是无值, java中可能空指针;scala中用Option 为了代替空指针判断
println(map.get("a"))//Some(1)
println(map.get("k")) //None
println(map.get("k").getOrElse(10)) //10如果为空,则取默认值10 println(map.keys) //Set(a, b)
println(map.values)//MapLike(1, 2)
println(map) //Map(a -> 1, b -> 2)
mutable.Map可变
// TODO 可变的Map集合
val mMap = mutable.Map("a" -> 1, "b" -> 2) mMap += ("c" -> 3, "d" -> 4, "E"->5) //=是把原来的值给覆盖掉
mMap -= ("b", "E")
mMap.update("a", 8) //, // mmap.get("").getOrElse(0)
println(mMap) //Map(d -> 4, a -> 8, c -> 3)
Tuple元组,22个元素;函数中有22个参数数据
(, , , )
tuple._1 ._2
// TODO Tuple 元组:将多个无关联的数据当成一个整体来使用。
// 声明元组 : 使用小括号
val tuple= ("abc", 123, "c")
// 使用特殊方式(下划线+顺序号)访问元组数据
println(tuple._2) //
val iterator: Iterator[Any] = tuple.productIterator //迭代器
while (iterator.hasNext){
print(iterator.next())// abc 123 c }
// 如果元组中的元素只有两个,我们称之为“对偶”,Map集合中的K,V其实就是“对偶”
val map1 = Map(("a", 1), ("b", 2))
map1.foreach(println) //(a,1) (b,2)
map1.foreach(t=>{println(t._1 + "," + t._2)}) //a,1 b,2 // 模式匹配
map1.foreach{
case(k, v)=>{
println(k + "," + v) //a,1 b,2
}
}
Java集合和Scala集合的互相转换
scala的集合转换为java的集合
// Scala集合和Java集合互相转换
val arr = ArrayBuffer("", "", "") import scala.collection.JavaConversions.bufferAsJavaList
val javaArr = new ProcessBuilder(arr)
val arrList = javaArr.command() println(arrList) //[1, 2, 3]
Java的List转Scala数组(mutable.Buffer)
隐式转换(即自动转换,二次编译,第一次编译没通过就尝试在指定范围内看看类参数等是否可以再次编译),隐藏的把它转换为想要的类型;
// Scala集合和Java集合互相转换
//Scala ==> Java
val arr = ArrayBuffer("", "", "")
import scala.collection.JavaConversions.bufferAsJavaList
val javaArr = new ProcessBuilder(arr)
val arrList = javaArr.command()
println(arrList) //[1, 2, 3] //Java ==> Scala
import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable
// java.util.List ==> Buffer
//val scalaArr: mutable.Buffer[String] = arrList
val javaList: util.List[String] = new util.ArrayList[String]() //java中的
val scalaArr: mutable.Buffer[String] = javaList //scala中的 ;如果没有上边的import隐式转换,就会报错,两个不同的类型无法转换 scalaArr.append("jack") //ArrayBuffer(1, 2, 3, jack) Buffer(jack)
println(scalaArr)
Scala数组| 集合的更多相关文章
- Scala数组和集合
一.scala数组 数组定义1: var arr = new Array[String](3) String:存储的元素类型 3:存储3个元素 添加元素: arr(1) = "hello&q ...
- [转] Scala 的集合类型与数组操作
[From] https://blog.csdn.net/gongxifacai_believe/article/details/81916659 版权声明:本文为博主原创文章,转载请注明出处. ht ...
- Scala:集合类型Collection和迭代器
http://blog.csdn.net/pipisorry/article/details/52902549 Scala Collection Scala 集合分为可变的和不可变的集合. 可变集合可 ...
- Scala-Unit4-Scala数组/集合
一.Scala数组 1.数组的定义: 方法一:val arr = new Array[String](3) String代表数据的元素类型.3表示数组的长度 方法二:val arr = Array[I ...
- scala 可变集合与内存清理的关系
留坑待填 使用scala.collection.mutable._期间,发现了当程序运行内存开销较多时,使用系统工具进行内存清理,然后程序报出了变量找不到.内存无法访问.数组访问越界,堆栈溢出等多种错 ...
- Spark记录-Scala数组
Scala提供了一种数据结构叫作数组,数组是一种存储了相同类型元素的固定大小顺序集合.数组用于存储数据集合,但将数组视为相同类型变量的集合通常更为有用. 可以声明一个数组变量,例如:numbers,使 ...
- 3、scala数组
一.Array .Array Buffer 1.Array 在Scala中,Array代表的含义与Java中类似,也是长度不可改变的数组. 此外,由于Scala与Java都是运行在JVM中,双方可以互 ...
- 4、scala数组
1.Array 2.ArrayBuffer 3.遍历Array和ArrayBuffer 4.数组常见操作 1. Array Scala中,array代表的含义与java类似,也是长度不可改变的数组. ...
- Scala 数组和List
Scala 数组和List: import scala.collection.mutable.ArrayBuffer import scala.collection.mutable.Buffer ob ...
随机推荐
- Eclipse maven hadoop -- java.io.IOException: No FileSystem for scheme: hdfs
2019-01-10 概述 今天在Windows系统下新安装了Eclipse和maven的环境,想利用Maven构建一个Hadoop程序的,结果却发现程序运行时一直报 “No FileSystem f ...
- Dubbo2.6.5+Nacos注册中心(代替Zookeeper)
在上一节的小栗子的基础上,只需要更改两个地方 第一个:父工程的pom依赖增加 <!-- Dubbo Nacos registry dependency --> <dependency ...
- 深入理解pthread_cond_wait、pthread_cond_signal
===============================man pthread_cond_wait的解释========================== LINUX环境下多线程编程肯定会遇到 ...
- C++回顾day03---<模板>
一:函数模板 建立一个通用函数,其函数类型和形参类型不具体指定,用一个虚拟的类型来代表.这个通用函数就称为函数模板.凡是函数体相同的函数都可以用这个模板来代替,不必定义多个函数,只需要在模板中定义一次 ...
- swiper常见问题
swiper是一个比较不错的一个轮播插件,但是呢,有时候在使用的时候也会出现很多的问题,我将我遇到的一些问题解决办法写在下面. 第一个问题:swiper分页器不显示 一般swiper使用分页器都是这样 ...
- 解决 IIS 反向代理ARR URLREWRITE 设置后,不能跨域跳转 return Redirect 问题
1.选择iis根节点,点击ARR 2.选择代理设置 3.去掉reverse rewrite host in response headers的勾选,点击应用即可
- [物理学与PDEs]第5章第4节 本构方程 - 应力与变形之间的关系
5. 4 本构方程 - 应力与变形之间的关系 5.4.1. 本构关系的一般形式 1. 若 Cauchy 应力张量 ${\bf T}$ 满足 $$\bex {\bf T}({\bf y})=\hat{\ ...
- 《11招玩转网络安全》之第一招:Docker For Docker
玩转黑客那些工具,缺少了虚拟机怎么行,除了用虚拟机虚拟整个系统,Docker也不能缺少,读者只需要知道,Docker只虚拟Linux系统中的某个程序就可以了.本节就来介绍Linux下安装设置Docke ...
- MySQL学习1 - 基本mysql语句
一 操作文件夹(数据库) 增 查 改 删 二 操作文件(数据表) 增 查 改 删 三 操作文件内容(数据记录) 增 查 改 删 一 操作文件夹(数据库) 增 create database db1 c ...
- 2019最新迅为-i.MX6Q开发板资料目录
迅为IMX6开发板: Android4.4系统 Linux + Qt5.7系统 Ubuntu12.04系统 部分案例:HMI:3D打印机:医疗设备:工控机:触控一体机:车载终端 核 ...