Scala进阶之路-高级数据类型之集合的使用

                               作者:尹正杰

版权声明:原创作品,谢绝转载!否则将追究法律责任。

  Scala 的集合有三大类:序列 Seq、集 Set、映射 Map,所有的集合都扩展自 Iterable 特质在 Scala 中集合有可变(scala.collection.mutable” 包下存放)和不可变(scala.collection.immutable” 包下存放)两种类型,immutable 类型的集合初始化后就不能改变了(注意与 val 修饰的变量进行区别)。

一.Seq  序列

1>.不可变的序列 import scala.collection.immutable._

 /*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function object SetOperation {
def main(args: Array[String]): Unit = {
//定义一个list
var list = List("yinzhengjie","Python","Golang","Java","Scala")
//查看list的头
print(s"list.head=====> ${list.head}\n")
//查看list的尾,尾就是出了头部的数据
print(s"list.tail=====> ${list.tail}\n")
//Nil表示为空,此时的list为空
list = Nil
print(s"list=====> ${list}\n")
/**
* "::" 操作符是将给定的头和尾创建一个新的列表。
* 注意,"::" 操作符是右结合的,如 100::200::300::Nil 相当于 100::(200::(300::Nil))
*/
var list2 = 100::200::300::list
println("list2=====>"+list2)
//“+”是拼接操作
var list3 = list2 + ("666666")
print(s"list3=====> ${list3}\n")
//“++”是将两个集合进行拼接操作,最终会返回一个新的list对象,将右边的集合的每一个元素追加在左边集合的尾部
var list4 = list2 ++ List("J","Q","K")
print(s"list4=====> ${list4}\n")
//“++:”是将右边的集合的每一个元素元素放置在左边集合的头部哟
var list5 = list2.++:(List("J","Q","K"))
print(s"list5=====> ${list5}\n")
//“+:”是将右边的集合的放置在左边集合的头部,并非是将右边的集合的每个元素放进去!
var list6 = list2.+:(List("J","Q","K"))
print(s"list6=====> ${list6}\n")
//“:+”是将右边的集合的放置在左边集合的尾部部,并非是将右边的集合的每个元素放进去!
var list7 = list2.:+(List("J","Q","K"))
print(s"list7=====> ${list7}\n")
//“::”方法是将右边集合的每个元素和左边的集合合并为一个新的集合
var list8 = list2::(List("J","Q","K"))
print(s"list8=====> ${list8}\n")
//判断list9集合中存在偶数的个数
val list9 = List(9,2,3,6,8,7,1,4,5)
val res1 = list9.count(x => x % 2 == 0)
print(s"res1=====> ${res1}\n")
//判断list9集合中偶数的值
val res2 = list9.filter(x => x % 2 == 0)
print(s"res2=====> ${res2}\n")
//对list9进行升序排序
val res3 = list9.sorted
print(s"res3=====> ${res3}\n")
//list9进行降序排序,如果我们不用负号("-"),那么默认是以升序排序
val res4 = list9.sortBy(x => -x)
print(s"res4=====> ${res4}\n")
//根据wordCount中的Int类型进行排序
val wordCount = List(("yinzhengjie",100),("Scala",80))
val res5 = wordCount.sortWith((x,y) => x._2 > y._2)
print(s"res5=====> ${res5}\n")
//指定每个分组允许的最大个数
val lis10 = List("yinzhengjie","Shell","Python","VBS","HTML","CSS","JavaScript","Golang","Java","Scala")
val res6 = lis10.grouped(3)
res6.foreach(x => print(x + "\t"))
print(s"res6=====> ${res6}\n")
/**
* 注意fold(定义初始值)(叠加的函数)
* 分析:val res7 = list11.fold(0)(_+_)
* fold(0)中的初始值为 : 0
* (_+_)是叠加的函数,左边的下划线是初始值,右边的下划线是list11中的每一个元素
* 综上所述:
* list11.fold(0)(_+_)会进行三次运算,因为list11的长度为3.
* 第一次运算,计算结果为: (0+9)
* 第二次运算的初始值是第一次计算的结果,计算结果为: (9+2)
* 第三次运算的初始值是上一次计算的结果,计算结果为: (11+3)
* 因此,我们可以得到最终的结果应该为: 14
*/
val list11= List(9,2,3)
val res7 = list11.fold(0)(_+_) //其实我们也可以这样写:val res7 = list11.fold(0)((x,y) => x + y)
print(s"res7=====> ${res7}\n")
/**
* 相信你理解了上面的fold的方法,那么下面的fold的方法你估计也再熟悉不过了,因为fold底层调用的就是foldLeft方法。
*/
var res8 = list11.foldLeft(0)(_+_)
var res9 = list11.foldLeft(0)(_-_)
print(s"res8=====> ${res8}\n")
print(s"res9=====> ${res9}\n")
/**
* 在你理解foldLeft的工作原理后,相信foldRight对你来说更是小菜一碟啦,因为foldLeft和fold都是从左往右计算
* 第一次运算,计算结果为: (9-0)
* 第二次运算的初始值是上一次计算的结果,计算结果为: (2-9)
* 第三次运算的初始值是上一次计算的结果,计算结果为: (3-(2-9))
* 因此,我们可以得到最终的结果应该为: 10
*/
var res10 = list11.foldRight(0)(_-_)
print(s"res10=====> ${res10}\n")
//反转list的值,使用reverse方法
var list12 = List("yinzhengjie","Shell","Python","Scala")
list12 = list12.reverse
print(s"list12=====> ${list12}\n")
//将列表进行聚合操作,如果列表中有字符串就直接拼接,如果全部是int类型就累加操作
val res11 = list12.reduce((x,y) => x + y)
print(s"res11=====> ${res11}\n")
//aggregate(在Spark已经把它封装为reduceByKey)可以模拟并行化集合,可以把集合打散,在非并行化底层还是调用的foldLeft
var res12 = list11.aggregate(0)(_ + _,_+_)
print(s"res12=====> ${res12}\n")
//计算出两个集合中的并集,就可以调用union方法
var list13 = List(1,3,5,7,9,0,8)
var list14 = List(8,0,7,2,4,6)
var res13 = list13.union(list14)
print(s"res13=====> ${res13}\n")
//计算交集,调用intersect方法即可
var res14 = list13.intersect(list14)
print(s"res14=====> ${res14}\n")
//计算两个集合的差集,即可以理解为不同元素
var res15 = list13.diff(list14)
print(s"res15=====> ${res15}\n")
//拉链函数,可以把两个元素集合的没有索引进行咬合,新城一个新的元组。如果一个集合中比另一个集合元素要少,那么会以较少元素个数的集合进行匹配。
var res16 = list13.zip(list14)
print(s"res16=====> ${res16}\n")
//格式化字符串操作,比如以“|”将list13中的每个元素隔开,并将结果以字符串的形式返回
var res17 = list13.mkString("|")
print(s"res17=====> ${res17}\n")
//计算集合的大小或者是长度
var res18 = list13.size
var res19 = list13.length
print(s"res18=====> ${res18}\n")
print(s"res19=====> ${res19}\n")
//对应list取切片操作,和Python语法有点像,同样也是挂前不顾后!
var list15 =List("yinzhengjie","Hadoop","Nginx","MySQL","TomCat","Httpd")
var res20 = list15.slice(1,3)
print(s"res20=====> ${res20}\n")
//对一个Int类型的结合进行求和运算
var list16 = List(1,2,3,4,5,6,7,8,9,10)
var res21 = list16.sum
print(s"res21=====> ${res21}\n")
}
} /*
以上代码执行结果如下:
list.head=====> yinzhengjie
list.tail=====> List(Python, Golang, Java, Scala)
list=====> List()
list2=====>List(100, 200, 300)
list3=====> List(100, 200, 300)666666
list4=====> List(100, 200, 300, J, Q, K)
list5=====> List(J, Q, K, 100, 200, 300)
list6=====> List(List(J, Q, K), 100, 200, 300)
list7=====> List(100, 200, 300, List(J, Q, K))
list8=====> List(List(100, 200, 300), J, Q, K)
res1=====> 4
res2=====> List(2, 6, 8, 4)
res3=====> List(1, 2, 3, 4, 5, 6, 7, 8, 9)
res4=====> List(9, 8, 7, 6, 5, 4, 3, 2, 1)
res5=====> List((yinzhengjie,100), (Scala,80))
List(yinzhengjie, Shell, Python) List(VBS, HTML, CSS) List(JavaScript, Golang, Java) List(Scala) res6=====> empty iterator
res7=====> 14
res8=====> 14
res9=====> -14
res10=====> 10
list12=====> List(Scala, Python, Shell, yinzhengjie)
res11=====> ScalaPythonShellyinzhengjie
res12=====> 14
res13=====> List(1, 3, 5, 7, 9, 0, 8, 8, 0, 7, 2, 4, 6)
res14=====> List(7, 0, 8)
res15=====> List(1, 3, 5, 9)
res16=====> List((1,8), (3,0), (5,7), (7,2), (9,4), (0,6))
res17=====> 1|3|5|7|9|0|8
res18=====> 7
res19=====> 7
res20=====> List(Hadoop, Nginx)
res21=====> 55
*/

2>.可变的序列 import scala.collection.mutable._

 /*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package cn.org.yinzhengjie.function import scala.collection.mutable.ListBuffer object ListOperationDemo { def main(args: Array[String]): Unit = {
//构建一个可变列表,初始有 3 个元素 1,2,3
val res = ListBuffer[Int](1,2,3)
print(s"res=====> ${res}\n") //创建一个空的可变列表
val res2 = new ListBuffer[Int]
print(s"res2=====> ${res2}\n") //向 res2 中追加元素,注意:没有生成新的集合
res2+= 4
res2.append(5)
print(s"res2=====> ${res2}\n") //将 res2 中的元素追加到 res 中, 注意:没有生成新的集合
res ++= res2
print(s"res=====> ${res}\n") //将 res 和 res2 合并成一个新的 ListBuffer 注意:生成了一个集合
val res3 = res ++ res2
print(s"res3=====> ${res3}\n") //将元素追加到 res 的后面生成一个新的集合
val res4 = res :+ 10
print(s"res4=====> ${res4}\n")
}
} /*
以上代码执行结果如下 :
res=====> ListBuffer(1, 2, 3)
res2=====> ListBuffer()
res2=====> ListBuffer(4, 5)
res=====> ListBuffer(1, 2, 3, 4, 5)
res3=====> ListBuffer(1, 2, 3, 4, 5, 4, 5)
res4=====> ListBuffer(1, 2, 3, 4, 5, 10)
*/

二.Set集合

1>.不可变的 Set

 /*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function object setOperationDemo {
def main(args: Array[String]): Unit = {
var s1 =Set(1,2,3,5)
var s2 =Set(2,3,4)
//计算交集
val res1 = s1.intersect(s2)
val res2 = s1 & s2
println(s"res1 ======> ${res1}")
println(s"res2 ======> ${res2}")
//计算并集
val res3 = s1.union(s2)
val res4 = s1 | s2
println(s"res3 ======> ${res3}")
println(s"res4 ======> ${res4}")
//计算差集
val res5 = s1.diff(s2)
val res6 = s1 &~ s2
println(s"res5 ======> ${res5}")
println(s"res6 ======> ${res6}") /**
* 查看当前使用的是哪个类
*/
println(s1.getClass)
}
} /*
以上代码执行结果如下 :
res1 ======> Set(2, 3)
res2 ======> Set(2, 3)
res3 ======> Set(5, 1, 2, 3, 4)
res4 ======> Set(5, 1, 2, 3, 4)
res5 ======> Set(1, 5)
res6 ======> Set(1, 5)
class scala.collection.immutable.Set$Set4
*/

2>.可变的 Set

 /*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function import scala.collection.mutable object setOperationDemo {
def main(args: Array[String]): Unit = {
/**
* 创建一个可变的 HashSet
*/
val set1 = new mutable.HashSet[Int]()
print(s"set1=====> ${set1}\n")
/**
* 向“HashSet ”中添加元素 :
* 1>.由于set的顺序是无序的,因此插入过程中可能不存在 ;
* 2>.add一般用于追加一个元素 ;
* 3>.如果想要一次性追加多个元素可以用".+="的方式添加,也可以使用“++=”操作符 ;
*/
set1.add(4)
set1 += (100,500)
set1.+=(300,200)
set1 ++= Set (1,3,5)
print(s"set1=====> ${set1}\n") /**
* 向“HashSet”中删除元素 :
* 1>.删除一个元素一般用"remove"方法 ;
* 2>.如果要删除多个元素
*/
set1 -= (100,200)
set1.-=(3,4)
set1.remove(5)
print(s"set1=====> ${set1}\n") /**
* 查看当前使用的是那个类
*/
println (set1.getClass)
}
} /*
以上代码执行结果如下 :
set1=====> Set()
set1=====> Set(1, 300, 100, 5, 3, 500, 4, 200)
set1=====> Set(1, 300, 500)
class scala.collection.mutable.HashSet
*/

三.Map映射

 /*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.basicGrammar import scala.collection.mutable object MapDemo {
def main(args: Array[String]): Unit = {
//定义不可变的map
val map = Map[String,Int]("尹正杰" -> 18)
print(s"map=====> ${map}\n") //定义一个可变的map
val changeableMap = mutable.HashMap[String,Int]()
print(s"changeableMap=====> ${changeableMap}\n") //往可变map中添加元素,这种添加方式和Java如出一辙
changeableMap.put("尹正杰", 26 )
changeableMap += "yinzhengjie" -> 18 //当然Scala也可以使用“+=”添加元素哟
changeableMap +=(("JDK",8),("Scala",2),("Hadoop",2)) //如果想要一次性添加多个元素,每个元素有逗号分隔即可
print(s"changeableMap=====> ${changeableMap}\n") //删除map中元素
changeableMap.remove("Scala")
print(s"changeableMap=====> ${changeableMap}\n")
changeableMap.-=("Hadoop") //当然Scala也可以使用“-=”删除元素哟
print(s"changeableMap=====> ${changeableMap}\n") //获取Map中的元素
val res1 = map.get("尹正杰").get
print(s"res1=====> ${res1}\n")
val res2 = changeableMap.get("尹正杰").get
print(s"res2=====> ${res2}\n") //getOrElse方法是判断Map中是否有某个key,如果有就返回具体的值,若没有则返回我们提前设定的值
val res3 = changeableMap.getOrElse("Python",100)
val res4 = changeableMap.getOrElse("JDK",200)
print(s"res3=====> ${res3}\n")
print(s"res4=====> ${res4}\n") /**
* 扩充知识点:
* 在Scala 中Option 类型样例类用来表示可能存在或也可能不存在的值(Option 的子类有Some
* 和None)。Some 包装了某个值,None 表示没有值。
* Option 是Some 和None 的父类
* Some 代表有(多例),样例类
* None 代表没有(单例),样例对象
*/
var res5:Option[Any] = Some("yinzhengjie","python","shell","vbs")
print(s"res5=====> ${res5}\n")
//取出Option的值
val res6 = res5.get
print(s"res6=====> ${res6}\n")
//判断Option是否为空
val res7 = res5.isEmpty
print(s"res7=====> ${res7}\n") /**
* Option 的get方法返回的为Option, 也就意味着res6可能取到也有可能没取到,如果res5=None 时,
* 会出现异常情况: NoSuchElementException: None.get
*/
res5=None
val res8 = res5.isEmpty
print(s"res8=====> ${res8}\n")
// val res9 = res5.get
// print(s"res9=====> ${res9}\n")
}
} /*
以上代码执行结果如下 :
map=====> Map(尹正杰 -> 18)
changeableMap=====> Map()
changeableMap=====> Map(yinzhengjie -> 18, Hadoop -> 2, 尹正杰 -> 26, Scala -> 2, JDK -> 8)
changeableMap=====> Map(yinzhengjie -> 18, Hadoop -> 2, 尹正杰 -> 26, JDK -> 8)
changeableMap=====> Map(yinzhengjie -> 18, 尹正杰 -> 26, JDK -> 8)
res1=====> 18
res2=====> 26
res3=====> 100
res4=====> 8
res5=====> Some((yinzhengjie,python,shell,vbs))
res6=====> (yinzhengjie,python,shell,vbs)
res7=====> false
res8=====> true
*/

四.元组(Tuple

  Scala 元组将固定数量的项目组合在一起,以便它们可以作为一个整体传递。与数组或列表不同,元组可以容纳不同类型的对象,但它们也是不可变的。元组是类型Tuple1,Tuple2,Tuple3 等等。目前在Scala 中只能有22 个上限,如果您需要更多个元素,那么可以使用集合而不是元组。

 /*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.basicGrammar object TupleDemo { def main(args: Array[String]): Unit = { //定义一个元组
val tuple = ("yinzhengjie",2018,true,Unit) //访问元素中的第一个元素,根据下标访问即可,默认是从1开始计数的
val res1 = tuple._1
print(s"res1=====> ${res1}\n") /**
* productIterator:
* 可以将一个元组转换成一个数组
* foreach:
* 可以遍历迭代器中的每一个元素
*/
tuple.productIterator.foreach(x => print(x + "\t"))
println() /**
* 对偶元组:
* 顾名思义。对偶元组指的是元组中元素的个数只有2个。
*/
val tuple1 = ("yinzhengjie",2018)
print(s"tuple1=====> ${tuple1}\n")
val res2 = tuple1.swap
print(s"res2=====> ${res2}\n") } } /*
以上代码执行结果如下:
res1=====> yinzhengjie
yinzhengjie 2018 true object scala.Unit
tuple1=====> (yinzhengjie,2018)
res2=====> (2018,yinzhengjie)
*/

五.Scala中的并行化集合

  Scala结合Hadoop中的MapReduce思想,可以模拟分布式计算,使用par方法即可。
 /*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.function object MyListPar {
def main(args: Array[String]): Unit = {
var list = (1 to 10).toList
println(list) /**
* 在没有开启并行化时,我们会看到执行map任务时都在主线程执行
*/
list.map(e => {
//获取当前线程名称
val name = Thread.currentThread().getName()
println(name + " : " + e)
//将listl列表中的数据乘以2
println(e * 2)
}) println("\n==============我是分割线=============\n") /**
* Scala结合Hadoop中的MapReduce思想,可以模拟分布式计算,使用par方法即可。
* 使用par方法将list对象转成并行化集合,我们会看到执行map任务时开启了多个线程执行,缺点是执行顺序不一致啦!
*/
list.par.map(e => {
//获取当前线程名称
val name = Thread.currentThread().getName()
println(name + " : " + e)
//将listl列表中的数据乘以2
println(e * 2)
})
}
} /*
以上代码执行结果如下 :
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
main : 1
2
main : 2
4
main : 3
6
main : 4
8
main : 5
10
main : 6
12
main : 7
14
main : 8
16
main : 9
18
main : 10
20 ==============我是分割线============= scala-execution-context-global-11 : 1
2
scala-execution-context-global-11 : 2
4
scala-execution-context-global-14 : 8
scala-execution-context-global-12 : 6
12
scala-execution-context-global-12 : 7
14
scala-execution-context-global-13 : 3
6
scala-execution-context-global-13 : 4
8
scala-execution-context-global-13 : 5
10
16
scala-execution-context-global-14 : 9
18
scala-execution-context-global-14 : 10
20 */

六.小试牛刀

1>.对数组的字符串进行单词统计

  不知道你是否感觉到了,大数据统计不管是MapReduce还是Spark他们最终的计算都类似于之中WordCount,因此想要学习大数据,练习写WordCount是你必经之路,我们可以对一个数组的数据进行单词统计,以及排序等操作,只需要一行就可以搞定,而且速度那是相当的快呀!下面我介绍4中单词统计的方式,其实万变不离其宗。具体代码如下:

 /*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/
package cn.org.yinzhengjie.basicGrammar object WordCount { def main(args: Array[String]): Unit = {
//定义需要统计的单词
val words = Array("hello Scala","hello Spark","hello Java","Java Scala") // 实现方式一
val res1 = words .flatMap(_.split(" ")) // 对数组中的每个元素进行切分, 并进行扁平化操作
.map((_, 1)) // 将数组的每个元素转换成一个对偶元组, 元组的第二个元素为1
.groupBy(_._1) // 对集合中的所有元素进行按单词分组, 相同单词的元组分到一组
.mapValues(_.length) // 对每个key 的value 集合进行求长度操作
.toList // 将map 转换成List
.sortBy(t => - t._2) // 实现降序排列,默认是升序排列 // 实现方式二
val res2 = words .flatMap(_.split(" ")).groupBy(x => x).map(t => (t._1,t._2.length)).toList.sortBy(t => t._2) //实现方式三
val res3 = words.flatMap(_.split(" ")).map(x =>(x,1)).groupBy(x=>x._1).mapValues(t=>t.foldLeft(0)(_+_._2)) //实现方式四
val res4 = words.flatMap(_.split(" ")).map(x =>(x,1)).groupBy(x =>x._1).mapValues(t=>t.foldRight(0)(_._2 + _)).toList.sortBy(t => - t._2) print(s"res1=====> ${res1}\n")
print(s"res2=====> ${res2}\n")
print(s"res3=====> ${res3}\n")
print(s"res4=====> ${res4}\n") }
} /*
以上代码执行结果如下:
res1=====> List((hello,3), (Scala,2), (Java,2), (Spark,1))
res2=====> List((Spark,1), (Scala,2), (Java,2), (hello,3))
res3=====> Map(Spark -> 1, Scala -> 2, Java -> 2, hello -> 3)
res4=====> List((hello,3), (Scala,2), (Java,2), (Spark,1))
*/

2>.

Scala进阶之路-高级数据类型之集合的使用的更多相关文章

  1. Scala进阶之路-高级数据类型之数组的使用

    Scala进阶之路-高级数据类型之数组的使用 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.数组的初始化方式 1>.长度不可变数组Array 注意:顾名思义,长度不可变数 ...

  2. Scala进阶之路-Scala中的高级类型

    Scala进阶之路-Scala中的高级类型 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.类型(Type)与类(Class)的区别 在Java里,一直到jdk1.5之前,我们说 ...

  3. Scala进阶之路-Scala高级语法之隐式(implicit)详解

    Scala进阶之路-Scala高级语法之隐式(implicit)详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 我们调用别人的框架,发现少了一些方法,需要添加,但是让别人为你一 ...

  4. Scala进阶之路-统计商家id的标签数以及TopN示例案例分析

    Scala进阶之路-统计商家id的标签数以及TopN示例案例分析 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.项目需求 将“temptags.txt”中的数据进行分析,统计出 ...

  5. Scala进阶之路-Scala的基本语法

    Scala进阶之路-Scala的基本语法 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.函数式编程初体验Spark-Shell之WordCount var arr=Array( ...

  6. Scala进阶之路-Spark本地模式搭建

    Scala进阶之路-Spark本地模式搭建 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.Spark简介 1>.Spark的产生背景 传统式的Hadoop缺点主要有以下两 ...

  7. Scala进阶之路-Scala中的泛型介绍

    Scala进阶之路-Scala中的泛型介绍 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 通俗的讲,比如需要定义一个函数,函数的参数可以接受任意类型.我们不可能一一列举所有的参数类 ...

  8. Scala进阶之路-尾递归优化

    Scala进阶之路-尾递归优化 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 递归调用有时候能被转换成循环,这样能节约栈空间.在函数式编程中,这是很重要的,我们通常会使用递归方法来 ...

  9. Scala进阶之路-Scala特征类与unapply反向抽取

    Scala进阶之路-Scala特征类与unapply反向抽取 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.Scala特征类分析 1>.Unit 答:用于定义返回值类型, ...

随机推荐

  1. 用wireshark抓包分析TCP三次握手、四次挥手以及TCP实现可靠传输的机制

    关于TCP三次握手和四次挥手大家都在<计算机网络>课程里学过,还记得当时高超老师耐心地讲解.大学里我遇到的最好的老师大概就是这位了,虽然他只给我讲过<java程序设计>和< ...

  2. 多屏判断css改写

    function replaceBodyClass(){ for(var i in map){ if(map[i](width)){ document.body.className = documen ...

  3. phpStorm使用技巧及快捷键

    下面是PhpStorm的注册码.Key,其license由用户名和License值组成. User name: EMBRACE License key: ===== LICENSE BEGIN === ...

  4. 转载:监控每个节点(Indices部分)

    集群的健康只是一个方面,它是对整个集群所有方面的一个很高的概括.节点状态的api是另外一个方面,它提供了关于你的集群中每个节点令你眼花缭乱的统计数据. 节点的状态提供了那么多的统计数据,在你很熟悉它们 ...

  5. 深入浅出ExtJS 第二章 Ext框架基础

    2.1 面向对象的基础架构(对象模型) 2.1.1 创建类 >.定义一个类: Ext.define('demo.Demo',{ name:'Lingo', hello:function () { ...

  6. (转)C++重写、重载和重定义的区别

    C++ 重写重载重定义区别 (源自:http://blog.163.com/clevertanglei900@126/blog/static/111352259201102441934870/) 1 ...

  7. jquery之each遍历list列表

    <!DOCTYPE html><html lang="en"><head>    <meta charset="UTF-8&qu ...

  8. runAllManagedModulesForAllRequests

    https://weblog.west-wind.com/posts/2012/Oct/25/Caveats-with-the-runAllManagedModulesForAllRequests-i ...

  9. unittest单元测试框架

    unittest单元测试框架 概述: 单元测试框架主要用来完成以下三件事: 提供用例组织与执行:当测试用例只有几条时,可以不必考虑用例的组织,但是当用例达到成百上千条时,大量的用例堆砌在一起,就产生了 ...

  10. poj3261

    题解: 同bzoj1717 代码: #include<bits/stdc++.h> using namespace std; ,P2=,P=; int a1[P],num[P],a2[P] ...