Scala集合笔记

Scala的集合框架类比Java提供了更多的一些方便的api,使得使用scala编程时代码变得非常精简,尤其是在Spark中,很多功能都是由scala的这些api构成的,所以,了解这些方法的使用,将更加有助于我们学习Scala和Spark: 
List,Map,Set的一些api的用法如下: 

Java代码  

  1. /**
  2. * Scala 集合测试
  3. */
  4. def collectionTest(): Unit ={
  5. val map =Map("red"->"红色","green"->"绿色")
  6. val colors = List("red", "green", "blue")
  7. //map函数测试 ,打印长度
  8. val size=colors.map( (f:String) => f.size  );
  9. val data=List(1,2,5,3);
  10. //reduce函数测试 求和
  11. val r=data.reduce((a:Int,b:Int)=>a+b);
  12. println(size,"            ",r)
  13. //打印取值
  14. println(map("red"))
  15. //判断是否存在
  16. println(map.contains("white"))
  17. //遍历map集合
  18. for(pair<-map) println(pair)
  19. //去重打印
  20. println(List(3,2,3,4,5).distinct)
  21. //fitler过滤
  22. println(List(3,12,33,64,15).filter(_ > 18))
  23. //扁平化处理
  24. println(List(List(1, 2), List(3, 4)).flatten)
  25. //partition 分区
  26. println(List(1, 2, 3, 4, 5) partition (_ < 3))
  27. //反转集合
  28. println(List(1, 2, 3).reverse)
  29. //slice==>与java的substring类似
  30. println(List(2, 3, 5, 7) slice (1, 4))
  31. //排序sortBy
  32. println(List("apple", "to","a","ab") sortBy (_.size) )
  33. //排序原生值
  34. println(List("apple", "to","bag","bbc","one").sorted)
  35. //splitAt值拆分一个list,根据下标的位置
  36. println(List(2, 3, 5, 7,99,45) splitAt 3)
  37. //提取第n个元素之前数据作为一个新的集合
  38. println(List(2, 3, 5, 7, 11, 13) take 2)
  39. //合并两个集合,进入一个大的集合
  40. println(List(1, 2) zip List("a", "b") )
  41. //删除前n个元素后,新生成一个集合
  42. println(List(‘a‘, ‘b‘, ‘c‘, ‘d‘) drop 1)
  43. //判断两个集合是否相等
  44. println(List(1, 2) == List(1, 2))
  45. //合并两个集合 ++
  46. println(List(1, 2) ++ Set(3, 4, 3) )
  47. //合并两个集合
  48. println(List(1, 2) ::: List(2, 3))
  49. //添加一个元素
  50. println(1 :: 2 :: Nil)
  51. //添加一个元素
  52. println(List(1,6).:+(5))
  53. //遍历每一个元素,收集case匹配上的元素值,返回一个新的集合
  54. println(List(0, 1, 0) collect {case 1 => "ok"})
  55. //将一个元素,根据特定符号,拆分成单个元素组成的集合
  56. println(List("milk,tea") flatMap (_.split(‘,‘)))
  57. //最大值
  58. println(List(41, 59, 26).max)
  59. //最小值
  60. println(List(10.9, 32.5, 4.23, 5.67).min)
  61. //连乘
  62. println(List(5, 6, 10).product)
  63. //求和
  64. println(List(11.3, 23.5, 7.2).sum )
  65. //是否存在
  66. println(List(34, 29, 18) contains 29 )
  67. //是否以xxx结束
  68. println(List(0, 4, 3) endsWith List(4, 3))
  69. //是否以xxx开始
  70. println(List(0, 4, 3) startsWith List(0) )
  71. //最少有一个值小于18即为true
  72. println(List(24, 17, 32) exists (_ < 18))
  73. println("=======================================")
  74. //必须得所有值小于18才返回true
  75. println(List(5, 17, 2) forall (_ < 18) )
  76. //求和
  77. println(List(4, 5, 6).fold(8)(_ + _))
  78. //求和
  79. println(List(4, 5, 6).foldLeft(10)(_ + _))
  80. //求和
  81. println(List(4, 5, 6).foldRight(0)(_ + _) )
  82. //求和
  83. println(List(4, 5, 6).reduce(_ + _) )
  84. //求和
  85. println(List(4, 5, 6).reduceLeft(_ + _) )
  86. //求和
  87. println(List(4, 5, 6).reduceRight(_ + _) )
  88. //阶段求和
  89. println(List(4, 5, 6).scan(0)(_ + _))
  90. //阶段求和
  91. println(List(4, 5, 6).scanLeft(0)(_ + _))
  92. //阶段求和
  93. println(List(4, 5, 6).scanRight(0)(_ + _))
  94. //集合转换字符串
  95. println(List(24, 99, 104).mkString(", "))
  96. //转成ArrayBuffer
  97. println(List(‘f‘, ‘t‘).toBuffer)
  98. //转Map to List
  99. println(Map("a" -> 1, "b" -> 2).toList )
  100. //转Set to Map
  101. println(Set(1 -> true, 3 -> true).toMap)
  102. //转List to Set
  103. println(List(2, 5, 5, 3, 2).toSet)
  104. //转List to String
  105. println(List(2, 5, 5, 3, 2).toString)
  106. //Java 与 Scala 集合互转
  107. //导入包
  108. import  collection.JavaConverters._
  109. import  collection.JavaConversions._
  110. import java.util.ArrayList;
  111. // scala 转 java
  112. val ja  =List(1,5,3).asJava
  113. println(List(1,5,3))
  114. println(ja)
  115. // java 转 scala
  116. val s =new java.util.ArrayList(3).asScala;
  117. //集合的模式匹配
  118. val statuses = List(500, 404)
  119. val msg = statuses.head match {
  120. case x if x < 500 => "okay"
  121. case _ => "whoah, an error"
  122. }
  123. println("信息:",msg)
  124. val msg2 = statuses match {
  125. case x if x contains(500) => "has error"
  126. case _ => "okay"
  127. }
  128. println("信息:",msg2)
  129. val msg3 = statuses match {
  130. case List(404, 500) => "not found & error"
  131. case List(500, 404) => "error & not found"
  132. case List(200, 200) => "okay"
  133. case _ => "not sure what happened"
  134. }
  135. println("信息:",msg3)
  136. val msg4 = statuses match {
  137. case List(500, x) => s"Error followed by $x"
  138. case List(e, x) => s"$e was followed by $x"
  139. }
  140. println("信息:",msg4)
  141. val head = List(‘r‘,‘g‘,‘b‘) match {
  142. case x :: xs => x
  143. case Nil => ‘ ‘
  144. }
  145. println(head)
  146. val code = (‘h‘, 204, true) match {
  147. case (_, _, false) => 501
  148. case (‘c‘, _, true) => 302
  149. case (‘h‘, x, true) => x
  150. case (c, x, true) => {
  151. println(s"Did not expect code $c")
  152. x
  153. }
  154. }
  155. println(code)
  156. }


顺序输出结果如下: 

Java代码  

    1. (List(3, 5, 4),            ,11)
    2. 红色
    3. false
    4. (red,红色)
    5. (green,绿色)
    6. List(3, 2, 4, 5)
    7. List(33, 64)
    8. List(1, 2, 3, 4)
    9. (List(1, 2),List(3, 4, 5))
    10. List(3, 2, 1)
    11. List(3, 5, 7)
    12. List(a, to, ab, apple)
    13. List(apple, bag, bbc, one, to)
    14. (List(2, 3, 5),List(7, 99, 45))
    15. List(2, 3)
    16. List((1,a), (2,b))
    17. List(b, c, d)
    18. true
    19. List(1, 2, 3, 4)
    20. List(1, 2, 2, 3)
    21. List(1, 2)
    22. List(1, 6, 5)
    23. List(ok)
    24. List(milk, tea)
    25. 59
    26. 4.23
    27. 300
    28. 42.0
    29. true
    30. true
    31. true
    32. true
    33. =======================================
    34. true
    35. 23
    36. 25
    37. 15
    38. 15
    39. 15
    40. 15
    41. List(0, 4, 9, 15)
    42. List(0, 4, 9, 15)
    43. List(15, 11, 6, 0)
    44. 24, 99, 104
    45. ArrayBuffer(f, t)
    46. List((a,1), (b,2))
    47. Map(1 -> true, 3 -> true)
    48. Set(2, 5, 3)
    49. List(2, 5, 5, 3, 2)
    50. List(1, 5, 3)
    51. [1, 5, 3]
    52. (信息:,whoah, an error)
    53. (信息:,has error)
    54. (信息:,error & not found)
    55. (信息:,Error followed by 404)
    56. r
    57. 204
    58. Process finished with exit code 0
时间: 2024-11-05 20:49:01

Scala集合笔记的相关文章

Scala学习笔记及与Java不同之处总结-从Java开发者角度

Scala与Java具有很多相似之处,但又有很多不同.这里主要从一个Java开发者的角度,总结在使用Scala的过程中所面临的一些思维转变. 这里仅仅是总结了部分两种语言在开发过程中的不同,以后会陆续更新一些切换后在开发过程中值得注意的地方.以下列举了部分,但令人印象深刻的Scala语言的不同之处,具体的代码演示样例及具体阐述见下文. ? Scala中可直接调用Java代码,与Java无缝连接. 语句能够不用";"结束.且推荐不适用";". 变量声明时以var或va

原创:Scala学习笔记(不断更新)

Scala是一种函数式语言和面向对象语言结合的新语言,本笔记中就零散记下学习scala的一些心得,主要侧重函数式编程方面. 1. 以递归为核心控制结构. 实现循环处理的方式有三种:goto,for/while,递归,其中用goto实现循环已经在现代语言中被放弃,而for/while形式的结构化编程成为主流,而递归作为另一种方案,则长期只流行在函数式编程的小圈子中. 递归被主流编程界所担心的主要是过深的调用栈,甚至以前的课堂上我们还亲自尝试过将递归改写为循环,但是现代函数式编程语言中,通过尾递归(

scala集合类型与java的转换

scala集合与java集合类型相互转换: http://www.scala-lang.org/api/current/index.html#scala.collection.JavaConverters$ 您可以通过JavaConverters package轻松地在Java和Scala的集合类型之间转换.它用asScala 装饰常用的Java集合以和用asJava 方法装饰Scala集合.    import scala.collection.JavaConverters._    val 

Spark:scala集合转化为DS/DF

scala集合转化为DS/DF 1 case class TestPerson(name: String, age: Long, salary: Double) 2 val tom = TestPerson("Tom Hanks",37,35.5) 3 val sam = TestPerson("Sam Smith",40,40.5) 4 val PersonList = mutable.MutableList[TestPerson]() 5 PersonList

Scala学习笔记及与Java不同之处总结-从Java开发人员角度

Scala与Java具有许多相似之处,但又有许多不同.这里主要从一个Java开发人员的角度,总结在使用Scala的过程中所面临的一些思维转变.这里只是总结了部分两种语言在开发过程中的不同,以后会陆续更新一些切换后在开发过程中值得注意的地方.下面列举了部分,但令人印象深刻的Scala语言的不同之处,具体的代码示例及详细阐述见下文. ? Scala中可直接调用Java代码,与Java无缝连接: 语句可以不用";"结束,且推荐不适用";": 变量声明时以var或val开头

java基础-集合笔记

Iterator(foreach) 遍历时只能通过iterator去删除(添加)元素,不能直接通过集合对象删除或添加元素 Set HashSet底层是一个HashMap HashSet添加元素,先判断hashCode,Set中没有相同的则直接添加,Set中有相同的元素,则进一步判断equals,不同则添加,相同则添加不成功 HashSet删除元素,先判断hashCode,相同则再判断equals,equals相同则删除该 List 1.元素是否相同是通过equals方法进行判断的 2.Array

再谈Scala集合

集合!集合!一个现代语言平台上的程序员每天代码里用的最多的大概就是该语言上的集合类了,Scala的集合丰富而强大,至今无出其右者,所以这次再回过头再梳理一下. 本文原文出处:  还是先上张图吧,这是我找到的最好的一个关于Scala集合的图了,出自:http://lkumarjain.blogspot.co.id/2015/01/scala-collection-framework.html : 一致的构建风格 在Scala里我们使用一致的简洁的语法实例化一个集合,不管你使用的是一个Trait还是

Scala集合类型详解

Scala集合 Scala提供了一套很好的集合实现,提供了一些集合类型的抽象. Scala 集合分为可变的和不可变的集合. 可变集合可以在适当的地方被更新或扩展.这意味着你可以修改,添加,移除一个集合的元素.而不可变集合类永远不会改变.不过,你仍然可以模拟添加,移除或更新操作.但是这些操作将在每一种情况下都返回一个新的集合,同时使原来的集合不发生改变. 集合中基本结构: 几种常用集合类型示例: // 定义整型 List   val x = List(1, 2, 3, 4)     // 定义 S

Scala集合学习总结

遍历集合可以使用迭代器iterator的那套迭代方式.Seq是一个有先后次序的序列,比如数组或列表.IndexedSeq可以通过下标进行任意元素的访问.例如ArrrayBuffer. Set是一组没有先后次序的值,在SortedSet中,元素以某种排过序的顺序被访问. Map是一组(键,值)对偶,SortedMap按照键的顺序访问实体 Scala集合有三个基本操作: head 返回集合第一个元素 tail 返回一个集合,包含除了第一元素之外的其他元素 isEmpty 在集合为空时返回true 可