1. package com.zy
  2. import scala.collection.mutable
  3. import scala.collection.mutable.ArrayBuffer
  4.  
  5. object test3 {
  6. def main(args: Array[String]): Unit = {
  7. //function1()
  8.  
  9. //function2()
  10.  
  11. //function3()
  12.  
  13. //function4()
  14.  
  15. //function5()
  16.  
  17. //function6()
  18.  
  19. //function8()
  20.  
  21. //function9()
  22.  
  23. function10()
  24.  
  25. }
  26.  
  27. //数组
  28. //不变长度数组(真数组)
  29. def function1():Unit={
  30. val ints=new Array[Int](20)
  31. //赋值
  32. ints(3)=999
  33.  
  34. for (i<- ints){
  35. println(i)
  36. }
  37.  
  38. var arr=Array(1,"中国",9.9)
  39. for (s<- arr){
  40. println(s)
  41. }
  42. //取值 (下标)
  43. println(arr(1))
  44.  
  45. }
  46. def function2():Unit={
  47. val arr=Array.fill(3)(math.random)
  48.  
  49. for (s<- arr){
  50. println(s)
  51. }
  52. }
  53.  
  54. //变长数组
  55. def function3():Unit={
  56. val ab1=new ArrayBuffer[String]()
  57. val ab2=ArrayBuffer[Int](100,200)
  58.  
  59. //ab1.insert(4,"中国","日本")//Exception in thread "main" java.lang.IndexOutOfBoundsException: 4
  60. ab1.insert(0,"中国","日本")
  61. /*for (v<- ab1){
  62. println(v)
  63. }*/
  64.  
  65. ab1+=("美国","法国")//追加 符号更加简约
  66. for (v<- ab1){
  67. println(v)
  68. }
  69.  
  70. ab1++=Array("1","3","6")//追加任何集合
  71. println("----------------------")
  72. for (v<- ab1){
  73. println(v)
  74. }
  75.  
  76. ab1.insert(1,"菲律宾")//在第一个元素后面
  77. println("----------------------")
  78. for (v<- ab1){
  79. println(v)
  80. }
  81.  
  82. println("----------------------")
  83. for (v<- ab1 if v!="日本"){
  84. println(v)
  85. }
  86.  
  87. }
  88.  
  89. def function4():Unit={
  90. val arr=ArrayBuffer[Int](1,4,5,6,0)
  91. val res=for (i<- 0 until arr.length) yield arr(i)*2
  92. println(res)
  93.  
  94. // _代表数组中每个元素
  95. //arr.filter(_>0) 判断数组中大于0的元素,返回一个数组
  96. //map(_*2) 每个元素乘于2
  97. arr.filter(_>0).map(_*2).foreach(println(_))
  98.  
  99. }
  100.  
  101. def function5():Unit={
  102.  
  103. var arr=Array(6,1,9,0,7)
  104. println(arr.max)
  105. println(arr.sum)
  106. arr.sorted.foreach(println(_))//升序
  107. println("-----------")
  108.  
  109. // _>_ 两个元素比较,大的放前面 降序
  110. arr.sortWith(_>_).foreach(println(_))
  111. println("---------------")
  112. arr.sortWith(_>_).foreach(println(_))//升序
  113.  
  114. println(arr.mkString("And"))//分隔符
  115. println(arr.mkString("<",",",">"))//<6,1,9,0,7> //指定前缀、分隔符、后缀
  116.  
  117. }
  118.  
  119. //多维数组
  120. def function6():Unit={
  121. var array=new Array[Array[Int]](5)
  122. array(0)=Array(1,4,5)
  123. array(1)=Array(2,4,5)
  124. array(2)=Array(6,4,5)
  125. for (a<-array if a!=null;v<-a){//双层循环
  126. println(v)
  127. }
  128.  
  129. println("-------------------")
  130. var arr2=Array(Array(1,2,3),Array(4,5,6),Array(7,8,9))
  131. for (a<-arr2 ;v<-a){
  132. println(v)
  133. }
  134.  
  135. }
  136.  
  137. def function7():Unit={
  138. val arr=Array(4,5,7)
  139.  
  140. //把定长转变长
  141. val buffer = arr.toBuffer
  142. buffer.foreach(println(_))
  143.  
  144. //变长转定长
  145. val ab2=ArrayBuffer[Int](100,200)
  146. val array=ab2.toArray
  147.  
  148. }
  149.  
  150. //Map
  151. def function8():Unit={
  152. //不可变map(值不能改变)
  153. var p=Map("aa"->12,"bb"->15,"cc"->28)
  154. // ->是用来创建元组("aa",12) ("bb",15) ("cc",28)
  155. //元组:("a",1.99,33,"b") 一组数据【任意类型】
  156.  
  157. println(p.get("aa"))//Some(12)
  158. println(p.get("pppp"))//None
  159.  
  160. //可变map(值可变)
  161. val p2=scala.collection.mutable.Map("xx"->11,"yy"->22)
  162. //空的可变map
  163. val hashMap = new mutable.HashMap[String,Int]
  164.  
  165. //取值
  166. println(p2.get("pp"))
  167. println(p2.getOrElse("xx",999))// 如果映射包含键“xx",返回对应的值;否则,返回999
  168.  
  169. //更新Map中的值
  170. p2("xx")=100
  171. println(p2.get("xx"))
  172. //追加
  173. p2+=("g"->1,"h"->2);
  174. println(p2)
  175. //移除
  176. p2-=("xx")
  177. println(p2)
  178.  
  179. //不可变映射 也可以追加
  180. p+=("zz"->999,"mm"->888)
  181. println(p)
  182. p-=("aa")
  183. println(p)
  184.  
  185. //遍历map
  186. for ((k,v)<-p){
  187. println("k:"+k+"\t"+"v:"+v)
  188. }
  189.  
  190. //遍历键的集合
  191. for (k<- p.keySet) println("k:"+k)
  192.  
  193. //遍历值的集合
  194. for (v<- p.values) println("v:"+v)
  195.  
  196. println("-------------------------")
  197. //键
  198. p.foreach(me=>println(me._1))
  199. //值
  200. p.foreach(me=>println(me._2))
  201. //键值对
  202. p.foreach(println(_))
  203.  
  204. println("--------------------------------")
  205. //反转键值对
  206. for ((k,v)<- p) yield println(v,k)
  207.  
  208. var newMap=for ((k,v)<- p) yield(v,k)
  209. println(newMap)
  210.  
  211. }
  212.  
  213. def function9():Unit={
  214.  
  215. // 会按照key的字典顺序进行排序
  216. val mm= scala.collection.immutable.SortedSet("f"->9,"a"->3,"w"->8)//按照字典顺序排序
  217. println(mm)
  218.  
  219. val months = scala.collection.mutable.LinkedHashMap("January" -> 1,"February" -> 2,"March" -> 3) // 创建一个顺序的Map
  220. months += ("Fourth" -> 4)
  221. println("months=> " + months) // months=> Map(January -> 1, February -> 2, March -> 3, Fourth -> 4)
  222.  
  223. }
  224.  
  225. //元组
  226. def function10():Unit={
  227.  
  228. val tup=(105,"中国")
  229. //空格在拼接多个过程中会引起歧义
  230. println(tup._1+"\t"+tup._2)
  231.  
  232. //元组最大 Tuple22 Tuple3里面有3个元素
  233. val tup2 = new Tuple3[String,Int,Int]("aa",11,44)
  234. val (a,b,c)=tup2
  235. println(a)
  236. println(b)
  237. println(c)
  238.  
  239. //分组 按元素(_)是否是大写区分
  240. println("NewAbcD".partition(_.isUpper))//分组后形成元组
  241.  
  242. //遍历
  243. tup2.productIterator.foreach(println(_))//最简单方式,但是不让拼接"\t"
  244. println()
  245. tup2.productIterator.foreach(x=>println(x+"\t"))
  246.  
  247. }
  248.  
  249. }

Scala数据结构(数组,Map和Tuple)的更多相关文章

  1. Scala编程入门---Map与Tuple

    创建Map //创建一个不可变的Map val ages = Map("Leo" -> 30,"Jen" ->25,"Jack" ...

  2. Scala实战高手****第8课:零基础实战Scala最常用数据结构Map和Tuple及Spark源码鉴赏

    本课内容1.Map和Tuple在Spark源码中的鉴赏2.Map和Tuple代码操作实战 ------------------------------------------------------- ...

  3. Scala学习笔记之:tuple、array、Map

    [TOC] 本文<快学Scala>的笔记 tuple学习笔记 tuple的定义 对偶是元组(tuple)的最简单形态--元组是不同类型的值的聚集. 元组的值是通过将单个值包含在圆括号中构成 ...

  4. [Scala]Scala学习笔记三 Map与Tuple

    1. 构造映射 可以使用如下命令构造一个映射: scala> val scores = Map("Alice" -> 90, "Kim" -> ...

  5. Scala Map与Tuple

    创建Map // 创建一个不可变的Map val ages = Map("Leo" -> 30, "Jen" -> 25, "Jack&q ...

  6. scala 数据结构(六):映射 Map

    1 映射 Map-基本介绍 Scala中的Map介绍 1) Scala中的Map 和Java类似,也是一个散列表,它存储的内容也是键值对(key-value)映射,Scala中不可变的Map是有序的, ...

  7. 10. Scala数据结构(上)-集合操作

    10.1 数据结构特点 10.1.1 Scala集合基本介绍 uml => 统一建模语言 1) Scala同时支持不可变集合和可变集合,不可变集合可以安全的并发访问 两个主要的包 不可变集合:s ...

  8. 《快学Scala》——数组、映射和元组

    数组 定长数组:在Scala中可以用Array,初始化一个定长数组.例如: val nums = new Array[Int](10) //10个整数的数组,所有元素初始化为0 val a = new ...

  9. Scala数据结构

    Scala数据结构 主要的集合特质 Scala同时支持可变集合和不可变集合,优先采用不可变集合.集合主要分为三大类:序列(List),集(set),映射(map).所有的集合都扩展自Iterable特 ...

随机推荐

  1. Akka Typed 官方文档之随手记

    ️ 引言 近两年,一直在折腾用FP与OO共存的编程语言Scala,采取以函数式编程为主的方式,结合TDD和BDD的手段,采用Domain Driven Design的方法学,去构造DDDD应用(Dom ...

  2. day119:MoFang:宠物的状态改动&宠物粮道具的使用&宠物死亡处理

    目录 1.宠物的状态改动 2.宠物粮道具的使用 3.宠物死亡处理 1.宠物的状态改动 1.在setting表中为每个宠物配置生命周期时间 因为宠物有多个,每个宠物会有不同的初始生命的饥饿时间,所以我们 ...

  3. 【Java基础】集合

    集合 集合概述 一方面, 面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象 的操作,就要对对象进行存储.另一方面,使用 Array 存储对象方面具有一些弊端,而 Java 集合就像一种容器 ...

  4. Linux性能相关命令

    Linux性能相关命令 目录 Linux性能相关命令 1. 查看硬盘相关信息 2. 查看CPU相关信息 3. 查看内存相关信息 4. 查看进程运行的信息 1. 查看硬盘相关信息 cat /proc/s ...

  5. SAP 修改表和表中数据

    平时修改表中数据的方式有一下几种: 1.一般就是通过SE11或者是SE16进去,找到那条记录,然后将模式变成EDIT,然后修改保存. 2.通过SQL语句在程序中实现数据库表的修改操作 3.通过SE16 ...

  6. 24V降压3.3V芯片,低压降线性稳压器

    PW6206系列是一款高精度,高输入电压,低静态电流,高速,低压降线性稳压器具有高纹波抑制.在VOUT=5V&VIN=7V时,输入电压高达40V,负载电流高达300mA,采用BCD工艺制造.P ...

  7. Python赋值、浅复制和深复制

    Python赋值.浅复制和深复制 ​ 首先我们需要知道赋值和浅复制的区别: 赋值和浅复制的区别 赋值,当一个对象赋值给另一个新的变量时,赋的其实是该对象在栈中的地址,该地址指向堆中的数据.即赋值后,两 ...

  8. 图解ARP协议

    前置知识:MAC地址 在说到ARP协议之前,需要了解MAC地址,在OSI七层模型中,第三层是网络层,要解决的是下一跳机制确定的设备位置,具体来说就是网卡地址,MAC地址用于在网络中唯一标示一个网卡,一 ...

  9. Web自动化测试python环境中安装 --selenium安装、火狐和火狐驱动版本、谷歌和谷歌驱动版本、测试

    一.安装selenium Windows命令行(cmd)输入pip install selenium(无须指定版本默认最新)或 pip install selenium==3.141.0(可指定版本) ...

  10. 跨度实际上是用来计算排位(rank) 目标节点在跳跃表中的排位 有序集 排序计算

    跳跃表的实现 - Redis 设计与实现 http://redisbook.com/preview/skiplist/datastruct.html 有序集合 /* ZSETs use a speci ...