scala集合与数据结构
Posted starzy
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了scala集合与数据结构相关的知识,希望对你有一定的参考价值。
1、数据结构特点
Scala同时支持可变集合和不可变集合,不可变集合从不可变,可以安全的并发访问。
两个主要的包:
不可变集合:scala.collection.immutable
可变集合: scala.collection.mutable
Scala优先采用不可变集合,对于几乎所有的集合类,Scala都同时提供了可变和不可变的版本。
不可变集合继承层次:
可变集合继承层次:
2、数组
2.1、定义定长数组
我们可以定义一个固定长度大小和类型的定长数组
//定义一个数组长度为10,类型为Int的固定大小数组 val array = new Array[Int](10) array(1) = 10 array(2) = 20 //访问数组当中的某一个下标元素值 println(array(1)) //直接使用apply方法进行生成一个数组 val array2 = Array(1,2,3) //访问数组的元素 println(array2(2)) |
|
2.2、变长数组
我们也可以通过ArrayBuffer来定义一个变长数组
val array3 = new ArrayBuffer[Int]() array3.append(20) val array4 = ArrayBuffer[String]() array4.append("helloworld") |
2.3、定长数组与变长数组的相互转换
//定长数组转换成变长数组 val toBuffer = array.toBuffer toBuffer.append(50) //变长数组准换成定长数组 val toArray = array3.toArray |
2.4、多维数组
我们可以通过Array的ofDim方法来定义一个多维的数组,多少行,多少列,都是我们自己定义说了算
val dim = Array.ofDim[Double](3,4) dim(1)(1) = 11.11 println(dim.mkString(",")) |
2.5、scala当中数组的遍历
val array5 = ArrayBuffer(1,2,3,4,5,6) for(x <- array5){ println(x ) } |
2.6、数组的常见算法
val array6 = Array(1,2,3,4,5,6) //求和 array6.sum //求最大值 array6.max //排序 array6.sorted |
3、元组tuple
在scala当中提供元组tuple的数据类型,可以理解tuple为一个容器,可以存放各种不同的数据类型的数据,例如一个Tuple当中既可以存放String类型数据,同时也可以存放Int类型的数据
注意:注意元组一旦创建之后,就是不可变的,也就是说元组当中没有添加和删除元素这一说
3.1、创建元组
创建元组,直接使用小括号,小括号当中存放我们元组当中各种类型的元素即可
val tuple1 = ("hello",1,5.0f) println(tuple1) |
3.2、元组数据的访问
访问元组当中的数据直接使用_加角标即可,但是要注意,元组当中的数据角标是从1开始的
val tuple1 = ("hello",1,5.0f) println(tuple1)
val tuple1Result = tuple1._1 println(tuple1Result) |
3.3、元组的遍历
val tuple1 = ("hello",1,5.0f) println(tuple1)
val tuple1Result = tuple1._1 println(tuple1Result) |
//第一种方式遍历元组
for(x <- tuple1.productIterator){ println(x) } //第二种方式遍历元组 tuple1.productIterator.foreach( x => println(x)) |
4、映射Map
scala当中的Map集合与java当中的Map类似,也是key,value对形式的
4.1、不可变映射
val map1 = Map("hello" ->"world","name" -> "zhangsan","age" -> 18) |
4.2、可变映射及其操作
val map2 = scala.collection.mutable.Map("hello" ->"world","name" -> "zhangsan","age" -> 18) //可变map添加元素 map2.+=("address" ->"地球") println(map2) //可变map删除元素.注意,删除元素是返回一个删除元素之后的map,原来的map并没有改变 val map3 = map2.-("address") println(map2) println(map3)
//可变map更新元素 map2("address") ="火星" println(map2) //或者使用覆盖key的方式来更细元素 map2 += ("address" -> "北京") println(map2) //或者使用 + 来进行更新元素 //注意,map当中没有phonNo这个key,则不能更细 map2 +("address" ->"上海","phonNo" -> "13688886666") println(map2) |
4.3、获取map当中指定的key值
//通过key来进行取值 map2.get("address") //通过key来进行取值,如果没有这个key,就用后面给定的默认值 map2.getOrElse("address","非洲") //通过key来进行取值,真的没有这个key,那么就用后面给定的默认值 map2.getOrElse("phoNo","13133335555") |
4.4、遍历Map当中的元素
//遍历key与value for((k,v) <- map2){ println(k) println(v) }
//遍历获取所有的key for(k <- map2.keys) { println(k) } //遍历获取所有的value for(v <- map2.values) { println(v) }
//打印key,value对 for(kv <- map2){ println(kv) } |
4.5、将对偶的数组转变为map
//将对偶的元组转变为map val arrayMap = Array(("name","zhangsan"),("age",28)) val toMap = arrayMap.toMap println(toMap) |
5、列表(List)
scala当中也提供有与java类似的List集合操作
5.1、创建列表
注意:列表当中的元素类型可以是不同的,这一点与我们元组类似,但是列表当中的元素是可以删减的
val list1 = List("hello",20,5.0f) println(list1) |
5.2、访问列表当中的元素
//访问列表当中的元素 val list1Result = list1(0) println(list1Result) |
5.3、列表当中添加元素
我们可以从列表头部或者尾部添加元素
val list2 = list1:+50 val list3 = 100+:list1 println(list2) println(list3) |
5.4、List的创建与追加元素
Nil是一个空的List,定义为List[Nothing]
//尾部添加了Nil,那么就会出现List集合里面装List集合的现象 val list4 = 1::2 ::3 :: list1 ::Nil println(list4) //尾部没有添加Nil的值,那么所有的元素都压平到一个集合里面去了 val list5 = 1::2::3::list1 println(list5) |
5.5、变长List的创建与使用
val list6 = new ListBuffer[String] list6.append("hello") list6.append("world") println(list6.mkString(",")) val list7 = list6.toList println(list7) |
5.6、List操作延伸阅读
Scala是函数式风格与面向对象共存的编程语言,方法不应该有副作用是函数风格编程的一个重要的理念。方法唯一的效果应该是计算并返回值,用这种方式工作的好处就是方法之间很少纠缠在一起,因此就更加可靠和可重用。另一个好处(静态类型语言)是传入传出方法的所有东西都被类型检查器检查,因此逻辑错误会更有可能把自己表现为类型错误。把这个函数式编程的哲学应用到对象世界里以为着使对象不可变。
前面一章介绍的Array数组是一个所有对象都共享相同类型的可变序列。比方说Array[String]仅包含String。尽管实例化之后你无法改变Array的长度。因此,Array是可变的对象。
说到共享相同类型的不可变对象类型,Scala的List类才是。和数组一样,List[String]包含的仅仅是String。Scala的List不同于Java的java.util.List,总是不可变的(Java的List是可变)。更准确的说法,Scala的List是设计给函数式风格的编程用的。
(1)List类型定义以及List的特点:
//字符串类型List scala> val fruit=List("Apple","Banana","Orange") fruit: List[String] = List(Apple, Banana, Orange) //前一个语句与下面语句等同 scala> val fruit=List.apply("Apple","Banana","Orange") fruit: List[String] = List(Apple, Banana, Orange) //数值类型List scala> val nums=List(1,2,3,4,5) nums: List[Int] = List(1, 2, 3, 4, 5) //多重List,List的子元素为List scala> val list = List(List(1, 2, 3), List("adfa", "asdfa", "asdf")) list: List[List[Any]] = List(List(1, 2, 3), List(adfa, asdfa, asdf))
//遍历List scala> for(i <- list; from=i; j<-from)println(j) 1 2 3 adfa asdfa asdf |
(2)List与Array的区别:
1、List一旦创建,已有元素的值不能改变,可以使用添加元素或删除元素生成一个新的集合返回。
如前面的nums,改变其值的话,编译器就会报错。而Array就可以成功
scala>nums(3)=4 <console>:10: error: value update is not a member of List[Int] nums(3)=4 ^ |
2、List具有递归结构(Recursive Structure),例如链表结构
List类型和气他类型集合一样,它具有协变性(Covariant),即对于类型S和T,如果S是T的子类型,则List[S]也是List[T]的子类型。
例如:
scala>var listStr:List[Object] = List("This", "Is", "Covariant", "Example") listStr:List[Object] = List(This, Is, Covariant, Example)
//空的List,其类行为Nothing,Nothing在Scala的继承层次中的最底层 //,即Nothing是任何Scala其它类型如String,Object等的子类 scala> var listStr = List() listStr:List[Nothing] = List()
scala>var listStr:List[String] = List() listStr:List[String] = List() |
(3)List常用构造方法
//1、常用::及Nil进行列表构建 scala> val nums = 1 :: (2:: (3:: (4 :: Nil))) nums: List[Int] = List(1, 2, 3, 4) //由于::操作符的优先级是从右向左的,因此上一条语句等同于下面这条语句 scala> val nums = 1::2::3::4::Nil nums:List[Int] = List(1, 2, 3, 4) |
至于::操作符的使用将在下面介绍
(4)List常用操作
//判断是否为空 scala> nums.isEmpty res5: Boolean = false //取第一个元素 scala> nums.head res6: Int = 1 //取列表第二个元素 scala>nums.tail.head res7: Int = 2
//取第三个元素 scala>nums.tail.tail.head res8: Int = 3
//插入操作 //在第二个位置插入一个元素 scala>nums.head::(3::nums.tail) res11: List[Int] = List(1, 3, 2, 3, 4)
scala> nums.head::(nums.tail.head::(4::nums.tail.tail)) res12: List[Int] = List(1, 2, 4, 3, 4)
//插入排序算法实现 def isort(xs: List[Int]):List[Int] = { if(xs.isEmpty) Nil else insert(xs.head, issort(xs.tail)) }
def insert(x:Int, xs:List[Int]):List[Int] = { if(xs.isEmpty || x <= xs.head) x::xs else xs.head :: insert(x, xs.tail) }
//连接操作 scala>List(1, 2, 3):::List(4, 5, 6) res13: List[Int] = List(1, 2, 3, 4, 5, 6)
//去除最后一个元素外的元素,返回的是列表 scala> nums.init res13: List[Int] = List(1, 2, 3)
//取出列表最后一个元素 scala>nums.last res14: Int = 4
//列表元素倒置 scala> nums.reverse res15: List[Int] = List(4, 3, 2, 1) //一些好玩的方法调用 scala> nums.reverse.reverse == nums //丢弃前面n个元素 scala>nums drop 3 res16: List[Int] = List(4) //获取前面n个元素 scala>nums take 1 res17: List[Int] = List[1] //将列表进行分割 scala> nums.splitAt(2) res18: (List[Int], List[Int]) = (List(1, 2),List(3, 4)) //前一个操作与下列语句等同 scala> (nums.take(2),nums.drop(2)) res19: (List[Int], List[Int]) = (List(1, 2),List(3, 4)) //Zip操作 scala> val nums=List(1,2,3,4) nums: List[Int] = List(1, 2, 3, 4) scala> val chars=List(‘1‘,‘2‘,‘3‘,‘4‘) chars: List[Char] = List(1, 2, 3, 4) //返回的是List类型的元组(Tuple),返回的元素个数与最小的List集合的元素个数一样 scala> nums zip chars res20: List[(Int, Char)] = List((1,1), (2,2), (3,3), (4,4))
//List toString方法 scala> nums.toString res21: String = List(1, 2, 3, 4)
//List mkString方法 scala> nums.mkString res22: String = 1234
//转换成数组 scala> nums.toArray res23: Array[Int] = Array(1, 2, 3, 4) |
(5)List伴生对象方法
//apply方法 scala> List.apply(1, 2, 3) res24: List[Int] = List(1, 2, 3) //range方法,构建某一值范围内的List scala> List.range(2, 6) res25: List[Int] = List(2, 3, 4, 5) //步长为2 scala> List.range(2, 6,2) res26: List[Int] = List(2, 4) //步长为-1 scala> List.range(2, 6,-1) res27: List[Int] = List() scala> List.range(6,2 ,-1) res28: List[Int] = List(6, 5, 4, 3) //构建相同元素的List scala> List.make(5, "hey") res29: List[String] = List(hey, hey, hey, hey, hey)
//unzip方法 scala> List.unzip(res20) res30: (List[Int], List[Char]) = (List(1, 2, 3, 4),List(1, 2, 3, 4))
//list.flatten,将列表平滑成第一个无素 scala> val xss =List(List(‘a‘, ‘b‘), List(‘c‘), List(‘d‘, ‘e‘)) xss: List[List[Char]] = List(List(a, b), List(c), List(d, e)) scala> xss.flatten res31: List[Char] = List(a, b, c, d, e)
//列表连接 scala> List.concat(List(‘a‘, ‘b‘), List(‘c‘)) res32: List[Char] = List(a, b, c) |
(6)::和:::操作符介绍
List中常用‘::‘,发音为"cons"。Cons把一个新元素组合到已有元素的最前端,然后返回结果List。
scala> val twoThree = List(2, 3) scala> val oneTwoThree = 1 :: twoThree scala> oneTwoThree oneTwoThree: List[Int] = List(1, 2, 3) |
上面表达式"1::twoThree"中,::是右操作数,列表twoThree的方法。可能会有疑惑。表达式怎么是右边参数的方法,这是Scala语言的一个例外的情况:如果一个方法操作符标注,如a * b,那么方法被左操作数调用,就像a.* (b)--除非方法名以冒号结尾。这种情况下,方法被右操作数调用。
List有个方法叫":::",用于实现叠加两个列表。
scala> val one = List(‘A‘, ‘B‘) val one = List(‘A‘, ‘B‘) scala> val two = List(‘C‘, ‘D‘) scala> one:::two res1: List[Char] = List(A, B, C, D) |
6、Set集合
集是不重复元素的结合。集不保留顺序,默认是以哈希集实现。
如果想要按照已排序的顺序来访问集中的元素,可以使用SortedSet(已排序数据集),已排序的数据集是用红黑树实现的。
默认情况下,Scala 使用的是不可变集合,如果你想使用可变集合,需要引用 scala.collection.mutable.Set 包。
6.1、不可变集合的创建
val set1 =Set("1","1","2","3") println(set1.mkString(",")) |
6.2、可变集合的创建以及添加元素
如果我们引入的集合的包是可变的,那么我们创建的集合就是可变的
import scala.collection.mutable.Set val set2 = Set(1, 2, 3) set2.add(4) set2 += 5 //使用.这个方法添加元素,会返回一个新的集合 val set3 = set2.+(6) println(set2.mkString(",")) println(set3.mkString(" |