Scala Turtuial-容器(集合)类型

集合

scala的集合分为可变集合和不可变集合,其中可变集合的增删改查都是作用于它本身;而不可变集合的增删改操作返回的是一个新的集合,原不可变集合保持不变。函数式编程常使用不可变集合,scala默认使用的也是不可变集合。他们对应的包分别为:scala.collection.immutable(不可变)和scala.collection.mutable(可变)

常见的可变集合: ArrayBuffer,ListBuffer,LinkedList,DoubleLinkedList,MutableList,Queue,Stack,HashMap,HashSet,ArrayStack等等。

常见的不可变集合: Array,list,Stack,Queue,HashMap,HashSet等等

数组

Array分为定长数组和变长数组,分别对应的不可变集合的Array和可变集合的ArrayBuffer。其中定长数组在定义时被确定,在运行时时数组实例本身不会改变,数组的内容是可以改变的;变长数组在运行时可以根据需要改变内容。

scala> val str = new Array[String](2)
str: Array[String] = Array(null, null)
scala> val nums = new Array[Int](5)
nums: Array[Int] = Array(0, 0, 0, 0, 0)
scala> str(0)="hello"
scala> nums(0)=23
#通过伴生对象的applay方法进行赋值
scala> val strA = Array("brian","lv")
strA: Array[String] = Array(brian, lv)

在定义定长数组时可以通过两种方式定义:1.通过new 创建。2.通过伴生对象的apply方法可直接进行赋值。 下面我们来看一下变长数组:

#导入mutable下的变长数组
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> val nums = new ArrayBuffer[String]()
nums: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer()
#向尾部添加元素,可以为单值也可以为多值。
scala> nums+=("brian","lv")
res32: nums.type = ArrayBuffer(brian, lv)
#++=向集合追加内容,++=右侧可以为任何集合
scala> nums++=Array("eric")
res33: nums.type = ArrayBuffer(brian, lv, eric)
scala> nums++=List("huhu")
res34: nums.type = ArrayBuffer(brian, lv, eric, huhu)
#trimEnd从尾部删除n个元素,trimStart从头部删除n个元素。
scala> nums.trimEnd(1)
scala> nums
res37: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(brian, lv, eric)
#insert(index,(value1,[value...])),在index处插入值元素
scala> nums.insert(0,"12","23")
scala> nums
res39: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(12, 23, brian, lv, eric)
#remove从index删除两个元素
scala> nums.remove(0,2)
scala> nums
res42: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(brian, lv, eric)
#将mutable的ArrayBuffer转为定长数组Array
scala> nums.toArray
res43: Array[String] = Array(brian, lv, eric)

具体的API可以参考Scala的官方文档,下面我们来看一下它的遍历:

#推荐使用第一种方式,直接取数据
scala> for(i<-nums) println("element is =="+i)
element is ==brian
element is ==lv
element is ==eric
#通过索引取数据
scala> for(i<-0 to nums.length-1) println("element index is "+i+",the value is "+nums(i))
element index is 0,the value is brian
element index is 1,the value is lv
element index is 2,the value is eric
#t通过until的上线界定索引来取数据
scala> for(i<-(0 until nums.length).reverse) println("element index is "+i+",the value is "+nums(i))
element index is 2,the value is eric
element index is 1,the value is lv
element index is 0,the value is brian
#遍历生成新的数组
scala> var num = for(i<-nums) yield i
num: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(brian, lv, eric)
scala> var num = for(i<-nums if i!="lv") yield i
num: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(brian, eric)
scala> val nums = Array(1,2,3,10,7,8)
nums: Array[Int] = Array(1, 2, 3, 10, 7, 8)
scala> nums.mkString(",")
res52: String = 1,2,3,10,7,8

对于多维数组的定义,直接嵌套即可。

列表

List也是Scala非常重要的集合型的数据结构,同样也是分为可变的List和不可变的List. 可变List:LinkedList,DoubleLinkedList,ListBuffer等。 不可变List:List. 值得注意的是:List的子类::[B]和继承List的对象的Nil,用::表示头尾相接的非空列表,Nil表示的是空列表。

scala> val listStr = List("spark","hadoop","scala")
listStr: List[String] = List(spark, hadoop, scala)
#通过调用伴生对象方法直接赋值
scala> val test = List.apply("spark","hadoop","scala")
test: List[String] = List(spark, hadoop, scala)
scala> val listStr = List(1,2,3.0)
listStr: List[Double] = List(1.0, 2.0, 3.0)
#判断List是否为空
scala> listStr.isEmpty
res1: Boolean = false
#::通过拼接来构造List
scala> val test = 1::2::3::Nil
test: List[Int] = List(1, 2, 3)
#List的第一个元素
scala> test.head or last
res3: String = spark
#List除去第一个元素外,剩余的元素.
scala> test.tail
res4: List[String] = List(hadoop, scala)
#获取第二个元素
scala> test.tail.head
res7: String = hadoop
scala> test(1)
res8: String = hadoop
#:::拼接两个列表
scala> List(1,2,3):::List(4,5,6)
res9: List[Int] = List(1, 2, 3, 4, 5, 6)
#去除最后一个元素外
scala> test.init
res11: List[String] = List(spark, hadoop)
scala> test.reverse
res13: List[String] = List(scala, hadoop, spark)
#丢弃前n个元素
scala> test drop 1
res17: List[String] = List(hadoop, scala)
#取前n个元素
scala> test.take(2)
res18: List[String] = List(spark, hadoop)
#将List分割为两个List
scala> test.splitAt(2)
res19: (List[String], List[String]) = (List(spark, hadoop),List(scala))
scala> test
res20: List[String] = List(spark, hadoop, scala)
scala> listStr
res21: List[Double] = List(1.0, 2.0, 3.0)
# zip生成元组列表,元素为元组类型。
scala> test zip listStr
res22: List[(String, Double)] = List((spark,1.0), (hadoop,2.0), (scala,3.0))
# 生成字符串
scala> test.mkString
res24: String = sparkhadoopscala
# 转换为数组
scala> test.toArray
res25: Array[String] = Array(spark, hadoop, scala)

更多详细的方法请查看Scala的API,我们下面介绍几个比较特殊的方法:appaly,range和concat

#通过调用List的伴生对象方法apply直接赋值,至于伴生对象是什么?我们在后面的章节介绍
scala> val test = List.apply(1,2,3,4,5)
test: List[Int] = List(1, 2, 3, 4, 5)
#构建某值的List,也是通过伴生对象方法调用生成的,还可以指定step。
scala> List.range(1,4)
res26: List[Int] = List(1, 2, 3)
scala> List.concat(List(1,2,3),List(4,5,6))
res34: List[Int] = List(1, 2, 3, 4, 5, 6)

集合

默认情况下的Set实现方式HashSet,Set在增加和删除时并保证元素的顺序。我们这俩暂且知道如何定义一个集合和有序的集合。

scala> val num1 = LinkedHashSet(1,23,4)
num1: scala.collection.mutable.LinkedHashSet[Int] = Set(1, 23, 4)
scala> val nums = Set(2,3,4)
nums: scala.collection.immutable.Set[Int] = Set(2, 3, 4)
scala> import scala.collection.mutable.LinkedHashSet
import scala.collection.mutable.LinkedHashSet
scala> val num1 = LinkedHashSet(1,23,4)
num1: scala.collection.mutable.LinkedHashSet[Int] = Set(1, 23, 4)

字典

在scala中的键值对的集合,叫做Map或者映射;而在Python中叫做字典。格式为:key->value.

scala> val personInfo = Map("name"->"brian","age"->12,"sex"->true)
personInfo: scala.collection.immutable.Map[String,Any] = Map(name -> brian, age -> 12, sex -> true)
scala> val persons = scala.collection.mutable.Map("brian"->12,"eric"->23,"lv"->24)
persons: scala.collection.mutable.Map[String,Int] = Map(brian -> 12, eric -> 23, lv -> 24)
#清空数据元素
scala> persons.clear()
scala> persons
res13: scala.collection.mutable.Map[String,Int] = Map()
scala> for(person<-persons) println(person)
(brian,12)
(eric,23)
(lv,24)
scala> persons.foreach(e=>println(e._1,e._2))
(brian,12)
(eric,23)
(lv,24)
#map类型的常用操作
scala> val maps = scala.collection.mutable.HashMap[String,Int]()
maps: scala.collection.mutable.HashMap[String,Int] = Map()
scala> maps.put("spark",12)
res21: Option[Int] = None
scala> maps.put("hadoop",23)
res22: Option[Int] = None
scala> maps.contains("hadoop")
res23: Boolean = true
scala> maps.get("hadoop")
res24: Option[Int] = Some(23)

队列和栈

队列和栈都是常见的数据结构,这里简单的介绍了队列的入队和出队以及栈的出栈和入栈操作。

scala> val q = scala.collection.mutable.Queue(1,2,3)
q: scala.collection.mutable.Queue[Int] = Queue(1, 2, 3)
#入队操作
scala> q.enqueue(4)
scala> q
res30: scala.collection.mutable.Queue[Int] = Queue(1, 2, 3, 4)
#出队操作
scala> q.dequeue()
res32: Int = 1
scala> q
res33: scala.collection.mutable.Queue[Int] = Queue(2, 3, 4)

scala> val stack = scala.collection.mutable.Stack(1,2,3)
stack: scala.collection.mutable.Stack[Int] = Stack(1, 2, 3)
#入栈
scala> stack.push(4)
res36: stack.type = Stack(4, 1, 2, 3)
#出栈
scala> stack.top
res38: Int = 4

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏软件开发 -- 分享 互助 成长

字符串处理技巧

1、快速统计字符串中每个字符出现的个数 hash表 2、求两个字符串公共的最长子串长度和子串 双重循环遍历找到长度,同时用二重指针保留住最长长度时候的指针位置 ...

1936
来自专栏张俊红

数据结构—字符串

关于字符串还有一个重要的知识点是KMP模式匹配算法,关于这个算法会单独拿一篇来写。

982
来自专栏我是攻城师

Scala中的Map使用例子

2967
来自专栏LeetCode

<dp>求最长的公共子串

Given an unsorted array of integers, find the length of longest increasing subse...

1850
来自专栏郭耀华‘s Blog

Java String 类

字符串广泛应用 在Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串。 ---- 创建字符串 创建字符串最简...

38012
来自专栏锦小年的博客

python学习笔记3.3-高级函数技巧

在使用函数的时候,如果能合理的使用一些技巧,对于代码的阅读性以及程序的结构都是很有帮助的。常用的技巧有递归函数、高阶函数等。 1 递归函数 递归函数的定义就是在...

1939
来自专栏Ryan Miao

javascript中遇到的字符串对象处理

在javascript中对参数处理: 1 <script> 2 function getParam() 3 { 4 urlInfo=window.loc...

36311
来自专栏Jack的Android之旅

kotlin基础语法

最近在学kotlin,这是本人看菜鸟教程后所做的笔记,很多会内容和菜鸟教程重复,仅供参考

1132
来自专栏深度学习之tensorflow实战篇

递归与伪递归区别,Python 实现递归与尾递归

      递归函数在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函 数。(1) 递归就是在过程或函数里调用自身。(2) 在使...

3727
来自专栏用户2442861的专栏

C++的函数隐藏、覆盖和重载

http://blog.csdn.net/lin49940/article/details/5553664

1921

扫码关注云+社区

领取腾讯云代金券