Scala Language Programing Guide（章节七）

最新推荐文章于 2022-02-04 13:39:02 发布
最新推荐文章于 2022-02-04 13:39:02 发布
阅读量724 收藏 2
点赞数 3
CC 4.0 BY-SA版权
分类专栏： Scala编程基础 文章标签： hadoop spark scala flink bigdata
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_38231448/article/details/89354185

作者：jiangzz 电话：15652034180 微信：jiangzz_wx 微信公众账号：jiangzz_wy 百知教育

集合/数组（重点）

Array

Array在Scala中指的是数组，创建方式如下所示，可以看出分配大小为10，每个元素都分配了默认值。

scala> var array=new Array[Int](10)
array: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

修改指定位置元素

scala> array(0)=1

scala> array
res57: Array[Int] = Array(1, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> array.update(1,2)

scala> array
res62: Array[Int] = Array(1, 2, 0, 0, 0, 0, 0, 0, 0, 0)

获取数组长度

scala> array.length
res63: Int = 10

scala> array.size
res64: Int = 10

数组去重

scala> array
res66: Array[Int] = Array(1, 2, 0, 0, 0, 0, 0, 0, 0, 0)

scala> array.distinct
res67: Array[Int] = Array(1, 2, 0)

Range

改元素指定在创建的时候指定步长，相比较于Array，该Range只读，不允许修改。

scala>  var range= new Range(0,10,2)
range: scala.collection.immutable.Range = Range(0, 2, 4, 6, 8)

scala> var range= 0 to 10 by 3
range: scala.collection.immutable.Range = Range(0, 3, 6, 9)

scala> var range=0 until 10 by 2
range: scala.collection.immutable.Range = Range(0, 2, 4, 6, 8)

Vector

按照下标顺序排列的向量，向量不支持修改。

scala> var vec=Vector(0,10,1)
vec: scala.collection.immutable.Vector[Int] = Vector(0, 10, 1)

scala> var vector=for(i<- 0  to 10 by 2) yield i
vector: scala.collection.immutable.IndexedSeq[Int] = Vector(0, 2, 4, 6, 8, 10)

Iterator

scala> var it=Iterator(1,2,3)
it: Iterator[Int] = non-empty iterator

scala> it.foreach(println)
1
2
3

scala> it.isEmpty
res41: Boolean = true

List

:: / +: 追加元素
scala> var list=List(1,2,3)
list: List[Int] = List(1, 2, 3)

scala> list::=10

scala> list
res84: List[Int] = List(10, 1, 2, 3)

scala> list(0)=11
<console>:13: error: value update is not a member of List[Int]
       list(0)=11
       ^

scala> list +:= -1

scala> list
res87: List[Int] = List(-1, 10, 1, 2, 3)
:::合并集合
scala> var list=List(1,2,3)
scala> var prefix=List(4,5,6)
scala> list :::= (prefix) //在list元素之前追加prefix元素，生成新的集合
scala> list
res32: List[Int] = List(4, 5, 6, 1, 2, 3)
drop/dropRight
scala> var list=List(1,2,3)
list: List[Int] = List(1, 2, 3)
scala> list.drop(2) //删除前n个元素
res30: List[Int] = List(3)
slice
scala> var list=List(1,2,3)
list: List[Int] = List(1, 2, 3)

scala> list.slice(1,3)
res104: List[Int] = List(2, 3)
reverse
scala> var list=List(1,2,3)
list: List[Int] = List(1, 2, 3)

scala> list.reverse
res105: List[Int] = List(3, 2, 1)
take/takeRight
scala> var list=List(1,2,3)
list: List[Int] = List(1, 2, 3)

scala> list.take(2)
res106: List[Int] = List(1, 2)

scala> list.takeRight(2)
res107: List[Int] = List(2, 3)
takeWhile
scala> var list=List(1,2,3)
list: List[Int] = List(1, 2, 3)

scala> list.takeWhile(x=> x<3 )
res108: List[Int] = List(1, 2)

scala> list.takeWhile(x=> x%2==1 )
res110: List[Int] = List(1)
head/last/tail
scala> var list=List(1,2,3)
list: List[Int] = List(1, 2, 3)

scala> list.head
res111: Int = 1

scala> list.tail
res112: List[Int] = List(2, 3)

scala> list.last
res113: Int = 3

ListBuffer

update
scala> import scala.collection.mutable._
import scala.collection.mutable._

scala> var list=ListBuffer[Int]()
list: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

scala> var list=ListBuffer(1,2,3)
list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

scala> list.update(0,10)

scala> list
res1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(10, 2, 3)
+=/+=:/++=/++=:

添加删除元素

scala>  var list=ListBuffer(1,2,3)
list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

scala> list.+=(4)
res12: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

scala> list.+=:(5)
res13: scala.collection.mutable.ListBuffer[Int] = ListBuffer(5, 1, 2, 3, 4)

scala> list.++=(List(6,7,8))
res14: scala.collection.mutable.ListBuffer[Int] = ListBuffer(5, 1, 2, 3, 4, 6, 7, 8)

+=集合末尾添加元素，+=:集合开始添加元素，++=追加集合在尾部，++=:在元素尾部添加元素

-/-=
scala> list.-(1)
res18: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 1)

scala> list
res19: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 1)

scala> var list=ListBuffer(1,2,3,1)
list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 1)

scala> list.-=(1)
res20: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 1)

scala> list
res21: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 1)

区别-表示创建新的集合但是不包含删除的这个元素，-=表示删除集合指定元素，更新原始集合

remove

删除指定位置元素

scala> var list=ListBuffer(1,2,3)
list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

scala> list.remove(0)
res25: Int = 1

scala> list
res26: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3)
insert/insertAll

在指定位置之前插入元素

scala> list
res27: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3)

scala> list.insert(0,4)

scala> list
res29: scala.collection.mutable.ListBuffer[Int] = ListBuffer(4, 2, 3)

scala> list.insertAll(2,List(1,2,3))

scala> list
res31: scala.collection.mutable.ListBuffer[Int] = ListBuffer(4, 2, 1, 2, 3, 3)
prependToList

将list1结果添加到list2中，

scala>  var list1=List(1,2,3)
list1: List[Int] = List(1, 2, 3)

scala>  var list2=ListBuffer(0,0)
list2: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 0)

scala> list2.prependToList(list1)
res34: List[Int] = List(0, 0, 1, 2, 3)

scala> list2
res36: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 0, 1, 2, 3)

Set（不可修改）

+/+=|-/-=
scala> var s=Set[Int](1,2,4,6,2)
s: scala.collection.immutable.Set[Int] = Set(1, 2, 4, 6)

scala> s.+=(1)

scala> s
s: scala.collection.immutable.Set[Int] = Set(1, 2, 4, 6)

scala> s+(7)
res12: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 7, 4)

区别是+创建新的Set并添加元素，不修改原始set，+=修改原始set,类似-、-=就不在阐述

size
scala> var s=Set[Int](1,2,4,6,2)
s: scala.collection.immutable.Set[Int] = Set(1, 2, 4, 6)

scala> s.size
res23: Int = 4

Set(可修改)

+/+=/-/-=
scala> var s=scala.collection.mutable.Set(1,2,3)
s: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

scala> s.+(4)
res25: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

scala> s
res26: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

scala> s.+=(4)
res27: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

scala> s
res28: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

scala> s.-(2)
res29: scala.collection.mutable.Set[Int] = Set(1, 3, 4)

scala> s
res30: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

scala> s.-=(2)
res31: scala.collection.mutable.Set[Int] = Set(1, 3, 4)

scala> s
res32: scala.collection.mutable.Set[Int] = Set(1, 3, 4)
remove/add
scala> var s=scala.collection.mutable.Set(1,2,3)
s: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

scala>  s.remove(2)
res37: Boolean = true

scala>  s.remove(-1)
res38: Boolean = false

scala> s
res39: scala.collection.mutable.Set[Int] = Set(1, 3)

scala> s.add(4)
res41: Boolean = true

HashMap(不可变)

+/+=/-/-=
scala> import scala.collection.immutable.HashMap
import scala.collection.immutable.HashMap

scala> var hm=HashMap[String,String](("建设","001"),("招商","002"))
hm: scala.collection.immutable.HashMap[String,String] = Map(建设 -> 001, 招商 -> 002)

scala> hm+="工商"->"003"

scala> hm.+=(("工商1","004"))

scala> hm
res4: scala.collection.immutable.HashMap[String,String] = Map(工商 -> 003, 建设 -> 001, 招商 -> 002, 工商1 -> 004)

scala> hm.-("工商")
res6: scala.collection.immutable.HashMap[String,String] = Map(建设 -> 001, 招商 -> 002, 工商1 -> 004)

scala> hm
res7: scala.collection.immutable.HashMap[String,String] = Map(工商 -> 003, 建设 -> 001, 招商 -> 002, 工商1 -> 004)

scala> hm.-=("工商")

scala> hm
res9: scala.collection.immutable.HashMap[String,String] = Map(建设 -> 001, 招商 -> 002, 工商1 -> 004)
get
scala> import scala.collection.immutable.HashMap
import scala.collection.immutable.HashMap

scala> var hm=HashMap[String,String](("建设","001"),("招商","002"))
hm: scala.collection.immutable.HashMap[String,String] = Map(建设 -> 001, 招商 -> 002)

scala> hm.get("招商").getOrElse("没有值")
res11: String = 002

scala> hm.get("招商1").getOrElse("没有值")
res12: String = 没有值
size
scala> hm
res16: scala.collection.immutable.HashMap[String,String] = Map(工商 -> 003, 建设 -> 001, 招商 -> 002, 工商1 -> 004)

scala> for(i<- hm) println(i._1+" -> "+i._2)
工商 -> 003
建设 -> 001
招商 -> 002
工商1 -> 004
merged
scala> var hm=HashMap[String,String](("建设","001"),("招商","002"))
hm: scala.collection.immutable.HashMap[String,String] = Map(建设 -> 001, 招商 -> 002)

scala> var newhm=HashMap[String,String](("邮政","004"))
newhm: scala.collection.immutable.HashMap[String,String] = Map(邮政 -> 004)

scala> var mergerFunction:((String,String),(String,String))=>(String,String) = (tuple1,tuple2)=>{
     |
     |    if(tuple1._1.equals(tuple2._1)){
     |       (tuple1._1,tuple2._2)
     |    }else{
     |      tuple1
     |    }
     |  }
scala> var res=hm.merged(newhm)(mergerFunction)
res: scala.collection.immutable.HashMap[String,String] = Map(邮政 -> 004, 建设 -> 001, 招商 -> 002)

scala> res
res18: scala.collection.immutable.HashMap[String,String] = Map(邮政 -> 004, 建设 -> 001, 招商 -> 002)

scala> for(i<- res) println(i)
(邮政,004)
(建设,001)
(招商,002)
keys/values
scala> var hm=HashMap[String,String](("建设","001"),("招商","002"))
hm: scala.collection.immutable.HashMap[String,String] = Map(建设 -> 001, 招商 -> 002)

scala> hm.keys
res23: Iterable[String] = Set(建设, 招商)

scala> hm.values
res24: Iterable[String] = MapLike(001, 002)

HashMap(可变)

remove/put
scala> import scala.collection.mutable.HashMap
import scala.collection.mutable.HashMap

scala> var hm=HashMap[String,String](("建设","001"),("招商","002"))
hm: scala.collection.mutable.HashMap[String,String] = Map(建设 -> 001, 招商 -> 002
                                                          
scala> hm+="工商"->"003"
res0: scala.collection.mutable.HashMap[String,String] = Map(工商 -> 003, 建设 -> 001, 招商 -> 002)

scala> hm-=("工商")
res1: scala.collection.mutable.HashMap[String,String] = Map(建设 -> 001, 招商 -> 002)

scala> hm.put("邮政","004")
res2: Option[String] = None
 
scala> hm.remove("工商")
res3: Option[String] = None
 
scala> for(i<- hm) println(i)
(建设,001)
(邮政,004)
(招商,002)

集合算子

排 序
scala> var lst=Array(1,4,6,3,2,5,7)
lst: Array[Int] = Array(1, 4, 6, 3, 2, 5, 7)

scala> lst.sorted
res30: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7)

scala> var list=Array(("a",1),("c",2),("b",3),("d",5))
list: Array[(String, Int)] = Array((a,1), (c,2), (b,3), (d,5))

scala> list.sortBy(tuple=>tuple._1)
res31: Array[(String, Int)] = Array((a,1), (b,3), (c,2), (d,5))

scala> list.sortBy(tuple=>tuple._2)
res32: Array[(String, Int)] = Array((a,1), (c,2), (b,3), (d,5))

scala> var list=Array(("a",1),("c",2),("b",3),("d",5))
list: Array[(String, Int)] = Array((a,1), (c,2), (b,3), (d,5))

scala> list.sortWith((t1,t2)=> t1._2 < t2._2)
res33: Array[(String, Int)] = Array((a,1), (c,2), (b,3), (d,5))
flatten
scala> var lst=List(Array("a","c"),Array("d","b"))
lst: List[Array[String]] = List(Array(a, c), Array(d, b))

scala> lst.flatten
res34: List[String] = List(a, c, d, b)
Map
scala>  var lst=List("hello world","good good study","day day up")
lst: List[String] = List(hello world, good good study, day day up)

scala> lst.map(item=>item.split(" "))
res35: List[Array[String]] = List(Array(hello, world), Array(good, good, study), Array(day, day, up))

scala> lst.map(item=>item.split(" ")).flatten
res36: List[String] = List(hello, world, good, good, study, day, day, up)
flatMap
scala> var lst=List("hello world","good good study","day day up")
lst: List[String] = List(hello world, good good study, day day up)

scala> lst.flatMap(item=>item.split(" "))
res39: List[String] = List(hello, world, good, good, study, day, day, up)

scala> lst.flatMap(_.split(" "))
res41: List[String] = List(hello, world, good, good, study, day, day, up)
filter
scala> var lst=List("hello world","good good study","day day up")
lst: List[String] = List(hello world, good good study, day day up)

scala> lst.flatMap(_.split(" ")).filter(_.equals("good"))
res42: List[String] = List(good, good)
groupBy
scala> var lst=Array("a","b","d","c","b","a","d","d")
lst: Array[String] = Array(a, b, d, c, b, a, d, d)

scala> lst.groupBy(x=>x)
res43: scala.collection.immutable.Map[String,Array[String]] = Map(b -> Array(b, b), d -> Array(d, d, d), a -> Array(a, a), c -> Array(c))

scala> var lst=Array(("a",1),("b",2),("a",2))
lst: Array[(String, Int)] = Array((a,1), (b,2), (a,2))

scala> lst.groupBy(x=>x._1).map(x=>(x._1,(for(i <- x._2) yield i._2).sum))
res44: scala.collection.immutable.Map[String,Int] = Map(b -> 2, a -> 3)
fold
scala> var lst=Array(Array(1,2,3),Array(1,2,4),Array(5,6,7),Array(9,4))
lst: Array[Array[Int]] = Array(Array(1, 2, 3), Array(1, 2, 4), Array(5, 6, 7), Array(9, 4))

scala> lst.flatten.fold(0)((x,y)=>x+y)
res45: Int = 44
aggregate
scala> var lst=List(1,2,4,5,6)
lst: List[Int] = List(1, 2, 4, 5, 6)
                  初始值   局部计算    汇总逻辑
scala> lst.aggregate(0)((x,y)=>x+y,(x,y)=>x+y)
res46: Int = 18

scala>
reduce
scala> var lst=List(1,2,4,5,6)
lst: List[Int] = List(1, 2, 4, 5, 6)

scala> lst.reduce(_+_)
res47: Int = 18
group
scala> var lst=Array(1,2,4,5,6,7)
lst: Array[Int] = Array(1, 2, 4, 5, 6, 7)

scala> lst.grouped(3).toList
res48: List[Array[Int]] = List(Array(1, 2, 4), Array(5, 6, 7))
zip
scala> var v=Vector(1,2,4)
v: scala.collection.immutable.Vector[Int] = Vector(1, 2, 4)

scala> v.zip(Array("a","b","c"))
res52: scala.collection.immutable.Vector[(Int, String)] = Vector((1,a), (2,b), (4,c))
unizp
scala> var v=List(("a",1),("b",2),("c",3))
v: List[(String, Int)] = List((a,1), (b,2), (c,3))

scala> v.unzip
res53: (List[String], List[Int]) = (List(a, b, c),List(1, 2, 3))
diff|intersect|union
scala> var v=List(1,2,3)
v: List[Int] = List(1, 2, 3)

scala> v.diff(List(2,3,5))
res54: List[Int] = List(1)

scala> var v=List(1,2,3,5)
v: List[Int] = List(1, 2, 3, 5)

scala> v.intersect(List(2,4,6))
res55: List[Int] = List(2)

scala> var v=List(1,2,3,5)
v: List[Int] = List(1, 2, 3, 5)

scala> v.union(List(2,4,6))
res56: List[Int] = List(1, 2, 3, 5, 2, 4, 6)
distinct
scala> var v=List(1,2,3,3,5)
v: List[Int] = List(1, 2, 3, 3, 5)

scala> v.distinct
res57: List[Int] = List(1, 2, 3, 5)
Sliding
scala> var v=List(1,2,3,3,5)
v: List[Int] = List(1, 2, 3, 3, 5)

scala>  v.sliding(3,1).toList
res60: List[List[Int]] = List(List(1, 2, 3), List(2, 3, 3), List(3, 3, 5))
字符统计
scala> var arrs=Array("this is a demo","good good study","day day up")
arrs: Array[String] = Array(this is a demo, good good study, day day up)

scala> arrs.map(_.split(" ")).flatten.map((_,1)).groupBy(_._1).map(x=>(x._1,(for(i<- x._2) yield i._2.toInt).toList.sum)).toList.sortBy(_._1).foreach(println)
(a,1)
(day,2)
(demo,1)
(good,2)
(is,1)
(study,1)
(this,1)
(up,1)
文件字符
var source=Source.fromFile("D:\\demo\\words\\t_words")
var array=ArrayBuffer[String]()
val reader = source.bufferedReader()
var line = reader.readLine()
while(line!=null){
    array+=line
    line = reader.readLine()
}
array.flatMap(_.split(" "))
    .map((_,1))
    .groupBy(_._1)
    .map(x=> (x._1,x._2.size))
    .toList
    .sortBy(_._1)
    .foreach(println)

reader.close()

更多精彩内容关注

微信公众账号

每天学一点Scala之 take、takeRight、takeWhile 与 filter
weixin_34402090的博客
09-08 458
比较简单，直接上例子objecttakeWhileTest{ defmain(args:Array[String]):Unit={ valnames=List("spark","hadoop","kafka","hive","mesos","zero","xyz","marathon") //需求：将names容器中，...
scala 系列 ---- take,takeRight,takeWhile的使用详解用法及代码示例
mojolang
01-20 3044
take : takeRight(n: Int): List[A] 提取列表的前n个元素 takeRight: takeRight(n: Int): List[A] 提取列表的最后n个元素 takeWhile: takeWhile(p: (A) ⇒ Boolean): List[A] 从左向右提取列表的元素，直到条件p不成立 val nums = List(1,2,3,4,5,6,7,8) println(nums) val leftNums = nums.take(2) .
kafka mq
婲落ヽ红颜谇的博客
07-03 670
作者：jiangzz 电话：15652034180 微信：jiangzz_wx 微信公众账号：jiangzz_wy Apache Kafka 消息队列 消息队列 消息：系统间通信介质，存在形式多样化一般使用 字节序列化、Json、xml等 队列：先进先出 FIFO 数据结构 消息队列(Message Queue)：可以用于系统间通讯的一个组件-middle ware（中间件），该组件可以用于做消息...
Scala Language Programing Guide（章节一）
麦田里的守望者-蒋中洲【相信相信的力量】
04-17 502
Scala编程指南Scala Language Programing Guide介绍环境配置变量变量声明数值转换数组元组分支循环条件分支while/do-whileBreakfor循环数组遍历数组计算模式匹配数值匹配类型匹配函数函数声明标准函数可变长参数参数默认值参数命名内嵌函数柯里化(Currying)匿名函数Class & object单例类类伴生对象抽象类Trait(接口)继承&am...
Scala Language Programing Guide（章节三）
麦田里的守望者-蒋中洲【相信相信的力量】
04-17 534
作者：jiangzz 电话：15652034180 微信：jiangzz_wx 微信公众账号：jiangzz_wy 百知教育 Class & object 由于Scala没有静态方法和静态类，通过object去定义静态方法或者静态对象。当object和Class放在一个文件中时候称该object为当前Class的伴生对象。 单例类 单例类使用object修饰，所有声明在object中的方法...
官网翻译之RDD Programming Guide-Scala
s127838498的专栏
11-14 616
Overview(概述) At a high level, every Spark application consists of a driver program that runs the user’s main function and executes various parallel operations on a cluster. The main abstraction Spark ...
Spark开发指南Spark Programming Guide
GarfieldEr007的专栏
11-25 2213
Spark Programming Guide     Overview     Linking with Spark     Initializing Spark         Using the Shell     Resilient Distributed Datasets (RDDs)         Parallelized Collections         Ext
Spark-RDD Programming Guide
cxu123321的博客
05-15 307
RDD Programming Guide Overview Linking with Spark Initializing Spark Using the Shell Resilient Distributed Datasets (RDDs) Parallelized Collections External Datasets RDD Operations Basics Passing Functions to Spark Understanding closure
Scala学习记录
杰之行的博客
02-04 889
Scala（发音为/ˈskɑːlə, ˈskeɪlə/）是一门多范式的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。洛桑联邦理工学院的Martin Odersky于2001年基于Funnel的工作开始设计Scala。Java平台的Scala于2003年底/2004年初发布。
scala-patterns：:trophy:Scala4You设计模式
02-16
Scala设计模式 :musical_keyboard: 目录 :index_pointing_up: 概括 Scala设计模式旨在为自适应应用程序原型提供各种用例场景和体系结构概念。 mkdocs.yml # ... user-guide/ changelog.md # Changelog page
Learning-Scala-Practical-Functional-Programming-for-the-JVM.pdf
04-10
This book is meant for developers who have worked in object-oriented languages such...programming language, this book provides an organized and examples-based guide that follows a gradual learning curve.
Programming.in.Scala_A.Comprehensive.Step-by-step.Guide[2009][EN][PDF]
02-09
Programming.in.Scala_A.Comprehensive.Step-by-step.Guide[2009][EN][PDF] Programming in Scala is the definitive book on Scala, the new language for the Java Platform that blends object-oriented and ...
Programming in Scala, 2nd Edition
04-03
This book is the authoritative tutorial on the Scala programming language, co-written by the language's designer, Martin Odersky. This second edition provides more than 100 pages of new material that ...
Scala编程指南-第二版
麦田里的守望者-蒋中洲【相信相信的力量】
09-19 823
Scala Language 语言介绍 Scala是一门多范式的编程语言,同时支持面向对象和面向函数编程风格。它以一种优雅的方式解决现实问题。虽然它是强静态类型的编程语言，但是它强大的类型推断能力，使其看起来就像是一个动态编程语言一样。Scala语言最终会被翻译成java字节码文件，可以无缝的和JVM集成，并且可以使用Scala调用java的代码库。除了Scala编程语言自身的特性以外，目前比较流...
Scala Language Programing Guide(章节二)
麦田里的守望者-蒋中洲【相信相信的力量】
04-17 607
Scala Language Programing Guide 作者：jiangzz 电话：15652034180 微信：jiangzz_wx 微信公众账号：jiangzz_wy 百知教育 变量 Scala语言中没有原始数据类型，这一点和Java语言不同，在Scala中一切且对象。以下是Scala语言中常见类型和类型间的继承关系。 在Java中常见的基本类型在Scala中都被剔除了,Scala将...
Scala 编程指南-课件版本
麦田里的守望者-蒋中洲【相信相信的力量】
10-22 575
概述 Scala用一种简洁的高级语言将面向对象和函数式编程结合在一起。传统业务开发- 领域模型设计（面向对象开发）; 大数据开发 - 数据集计算模型-（函数式编程）。函数编程强调的是程序对数据的运行算能力。在面向对象计算数据的时候采取代码不动移动数据.在函数式编程计算的时候数据不动代码动。Scala是一门多范式的编程语言,同时支持面向对象和面向函数编程风格。它以一种优雅的方式解决现实问题。虽然它是强静态类型的编程语言，但是它强大的类型推断能力，使其看起来就像是一个动态编程语言一样。Scala语言最终会被翻译
Scala 算子详解-章节7
麦田里的守望者-蒋中洲【相信相信的力量】
02-14 530
Java集合和Scala集合相互转换 import scala.collection.JavaConverters._ object TestJavaScalaCollection { def main(args: Array[String]): Unit = { val arrayList = new util.ArrayList[String]() arrayList....
Scala Language Programing Guide（章节六）
麦田里的守望者-蒋中洲【相信相信的力量】
04-17 435
作者：jiangzz 电话：15652034180 微信：jiangzz_wx 微信公众账号：jiangzz_wy 百知教育 异常处理 Scala 的异常处理和其它语言比如 Java 类似。Scala 的方法可以通过抛出异常的方法的方式来终止相关代码的运行，不必通过返回值。Scala 抛出异常的方法和 Java一样，使用 throw 方法，例如，抛出一个新的参数异常： throw new Ille...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值