scala

1000多

施碧嘉兰

今天说一说Java中的接口和Scala中的trait。一直就把特质当做半个接口用，因为确实挺像的，但仔细看，还是有很大区别的。1.接口不会有构造器，特质可以有构造器，并且在实现类继承特质的时候，先要调用特质的构造器。trait构造器的调用顺序小结：class B{}trait C extends E{}trait D extends E{}A extends B with C with D(1)先调用父类构造器B(2)继承多个trait从从左至右依次执行，先调用父trait E构造器，再调用C，再调用D构造器(3)如果多个trait继承同一个父trait，则父trait只执行一次(4)所有父类构造器和trait构造器执行完毕之后再执行自己的构造器A2.接口中不能有未初始化的属性，且属性的修饰都是public static final，特质中可以有未初始化的属性变量，即抽象字段；未初始化的属性可以有提前定义的特性，有两种方法，例如：trait A{val name:String//抽象字段println("name: "+name)//特质中构造器执行的语句}class B extends A{val name:String = "张三" }此时如果在main函数中new B的话，肯定会报错，因为new B必然先会调用特质中的构造器，而name并没有被赋值，所以会报错。有三种方法解决：(1)class B extends {val name:String = "张三" //提前定义在类前} with A{}(2)class B{}main函数中new B的时候：val b = new {val name:String = "张三"//提前定义在new对象前} with B with A(3)利用lazy特性trait A{lazy val name:String = nullprintln("name: "+name)}class B extends A{override lazy val name:String = "张三"}

object在scala中没有静态方法和静态字段，所以在scala中可以用object来实现这些功能，直接用对象名调用的方法都是采用这种实现方式，例如Array.toString。对象的构造器在第一次使用的时候会被调用，如果一个对象从未被使用，那么他的构造器也不会被执行；对象本质上拥有类（scala中）的所有特性，除此之外，object还可以一扩展类以及一个或者多个特质：例如，abstract class ClassName（val parameter）{}object Test extends ClassName(val parameter){}trait TraitA{}trait TraitB{}trait TraitC{}object Test1 extends TraitA with TraitB with TraitC{}注意：object不能提供构造器参数，也就是说object必须是无参的我们通常会定义和使用object的apply方法，有如下情形，apply方法就会被调用，Object（参数1 ，参数2 ，……）这样是隐含的调用apply方法，当然也可以显示的调用，如下Array（"Mary","tong"）,当然也可以这样来写Array.apply（"Mary","tong"）,一般我们提倡隐式的写法。所有的main方法都必须在object中被调用，来提供程序的主入口，十分简单，不举例说明，处理main方法以外，scala中还提供了扩展App特质，然后将程序代码放入都早起方法体内，如object Hello extends App{println（"Hello World ！！！"）}这样的代码可以直接执行，输出如果需要命令行参数，可以直接调用args属性来得到，例如def main(args: Array[String]) { if (args.length > 0 ) println("Hello " + args(0)) else println("Hello World")}scala中并没有枚举类型，但是，标准类库中提供了一个枚举类型的接口，在object下面，可以扩展出枚举类型（Enumeration），具体示例如下：object EnumerationDemo extends Enumeration{ val red, green, blue, pink = Valueval black = Value // 上面一条语句是简写val white = Valueval gray = Valueval yellow = Value(12, "huang") //可以随意指定id和名称，但是避免重复val purple = Value("zi") //id为13val orange = Value(20)}上面的代码为实现枚举类型的具体代码，如果不指定id和name，系统默认是id从0开始，name就是变量的名称，可以指定其中的任何一个或者是两个全部指定，已经指定的就按指定的初始化，并且后面的依次递增。枚举的引用可以直接objectName.red这样来进行引用，也可以将import objectName._来进行导入引用，还可以给枚举类型增加一个类型别名，具体如下：object EnumerationDemo extends Enumeration{ type EnumerationDemo = Value val red, green, blue, pink = Valueval black = Valueval white = Valueval gray = Valueval yellow = Value(12, "huang") val purple = Value("zi") val orange = Value(20)}现在枚举类型变成了EnumerationDemo.EnumerationDemo 这种用法只有在使用import语句的时候才显得有意义。package enumerationimport EnumerationDemo._/** * Created by tongtong on 2015/9/8. **/class EnumDemo { def transportation(color:Enumeration): Unit ={ if (color == red) "Stop" else if (color == green) "go" else if (color == yellow) "wait" }}枚举类型也可以通过for循环将所有元素输出，同时可以通过Enumeration（Int）和Enumeration.withName（""）来进行定位操作class在scala中，类名可以和对象名为同一个名字，该对象称为该类的伴生对象，类和伴生对象可以相互访问他们的私有属性，但是他们必须在同一个源文件内。类只会被编译，不能直接被执行，类的申明和主构造器在一起被申明，在一个类中，主构造器只有一个，所有必须在内部申明主构造器或者是其他申明主构造器的辅构造器，主构造器会执行类定义中的所有语句。scala对每个字段都会提供getter和setter方法，同时也可以显示的申明，但是针对val类型，只提供getter方法，默认情况下，字段为公有类型，可以在setter方法中增加限制条件来限定变量的变化范围，在scala中方法可以访问改类所有对象的私有字段

有些时候, 我们会遇到一些特定的需求, 即: 在不影响当前继承体系的情况下, 对某些类(或者某些对象)的功能进行加强, 例如: 有猴子类和大象类, 它们都有姓名, 年龄, 以及吃的功能, 但是部分的猴子经过马戏团的训练后, 学会了骑独轮车. 那骑独轮车这个功能就不能定义到父类(动物类)或者猴子类中, 而是应该定义到特质中. 而Scala中的特质, 要用关键字trait修饰. 定义特质 继承特质 注意 需求 参考代码 需求 参考代码 需求 参考代码 需求 参考代码 有些时候, 我们希望在不改变类继承体系的情况下, 对对象的功能进行临时增强或者扩展, 这个时候就可以考虑使用对象混入技术了. 所谓的对象混入指的就是: 在scala中, 类和特质之间无任何的继承关系, 但是通过特定的关键字, 却可以让该类对象具有指定特质中的成员. 需求 参考代码 概述 设计模式（Design Pattern）是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它并不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。 分类 设计模式一共有23种, 分为如下的3类: 当特质中有多个抽象方法, 而我们只需要用到其中的某一个或者某几个方法时, 不得不将该特质中的所有抽象方法给重写了, 这样做很麻烦. 针对这种情况, 我们可以定义一个抽象类去继承该特质, 重写特质中所有的抽象方法, 方法体为空. 这时候, 我们需要使用哪个方法, 只需要定义类继承抽象类, 重写指定方法即可. 这个抽象类就叫: 适配器类. 这种设计模式(设计思想)就叫: 适配器设计模式. 结构 需求 参考代码 在现实生活中, 我们会遇到论文模板, 简历模板, 包括PPT中的一些模板等, 而在面向对象程序设计过程中，程序员常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。 例如，去银行办理业务一般要经过以下4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的，可以在父类中实现，但是办理具体业务却因人而异，它可能是存款、取款或者转账等，可以延迟到子类中实现。这就要用到模板方法设计模式了. 在Scala中, 我们可以先定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤, 这就是: 模板方法设计模式. 优点 缺点 需求 参考代码 多个trait中出现了同一个方法, 且该方法最后都调用了super.该方法名(), 当类继承了这多个trait后, 就可以依次调用多个trait中的此同一个方法了, 这就形成了一个调用链。 执行顺序为: 这种设计思想就叫: 职责链设计模式. 需求 通过Scala代码, 实现一个模拟支付过程的调用链. 步骤 参考代码 如果遇到一个类继承了某个父类且继承了多个父特质的情况，那该类(子类), 该类的父类, 以及该类的父特质之间是如何构造的呢？ 要想解决这个问题, 就要用到接下来要学习的trait的构造机制了. 需求 步骤 参考代码 在Scala中, trait(特质)也可以继承class(类)。特质会将class中的成员都继承下来。 需求 参考代码

scala提供两种Actor：基于线程的Actor和基于事件的Actor。一、基于线程的Actor1、每个基于线程的Actor运行在自己的JVM线程中，它们被java线程调度器调度，是一个可抢占的优先级调度器。这种Actor使用receive模型，它从线程池获取一个线程后一直使用。2、实现方法：基于线程的Actor的实现方法是继承scala.actors.Actor，完成其act方法，并通过start方法来启动它：[java] view plaincopyimport scala.actors.Actor object HiActor extends Actor { def act() { while(true) { receive { case "EXIT" => println("Exiting...");exit() case msg => println("Hello " + msg) } } } } HiActor.start // 使用start方法启动Actor HiActor ! "def" HiActor ! "EXIT"

8月1日，斯柯达发布了SCALA 和 Kamiq中期改款版本，斯柯达Scala国内称为昕锐，而Kamiq则称为柯米克。这两款车型在外观、配置和安全方面进行了小幅改进。从外观上看，新款斯柯达Scala 和 Kamiq变化不大，因为设计师选择了保守调整。变化主要集中在前脸上，包括重新设计的车头大灯（可选配矩阵 LED 技术）以及稍微调整的进气格栅和保险杠。侧面保持基本不变， 配备了新设计的18 英寸合金轮毂，带有银色或黑色装饰。两款新车都有九种外观颜色可供选择，其中Scala可选择独特的钢灰色，而Kamiq可选择凤凰橙，以及带有黑色 A 柱和车顶的双色调车身。尾部则采用了新设计的 LED尾灯和新的后保险杠。内饰方面，主要对材质和配置进行了更新。斯柯达在内饰、垫子和地板上使用了更多的可回收环保材料，而车门面板和车顶内衬则使用了洋麻等可再生材料。顶配Monte Carlo车型标配可调节的 LED 环境照明，以及一些运动风格，例如前排座椅的集成头枕，可提供更大的横向支撑。2024款Scala 和 Kamiq标配8英寸全液晶仪表盘，也可以升级到 10.25 英寸大屏，同样标配8.25 英寸中控触摸屏，或者您也可以选择更大的 9.2 英寸中控触摸屏。还标配两个 15 瓦的 USB-C 端口。安装在车内后视镜中的额外端口还可以用来连接行车记录仪。安全方面，2024款Scala 和 Kamiq最多配备九个安全气囊。还有乘员保护功能，如果检测到即将发生碰撞，它会自动关闭所有窗户并拉紧前排座椅安全带。动力方面，这两款车将配备 1.0 TSI 三缸发动机，采用五速手动变速箱时，输出功率为95 马力（75 千瓦）；搭配六速手动变速箱或七速双离合变速箱时，输出功率为 115 马力（85 千瓦）。高配车型搭载1.5 TSI 四缸发动机，输出功率为150 马力（110 千瓦），同样匹配六速手动变速箱或七速双离合变速箱。1.5T发动机还支持可变停缸技术，可在不需要动力时关闭两个汽缸来节省燃料。鉴于欧盟更严格的排放法规，在欧洲，2024款Scala 和 Kamiq将不再配备柴油发动机。来源：斯柯达新车迷编辑，喜欢本文请点赞、转发、关注新车迷，谢谢！【本文来自易车号作者新车迷Auto，版权归作者所有,任何形式转载请联系作者。内容仅代表作者观点，与易车无关】

??? SWITCH expression must be a scalar or string constant. 表示：switch的表达式必须是数值或字符常量，不能是矩阵。

Scala的case class使得对对象进行模式匹配变得非常方便，简单的来说，Scala的case class就是在普通的类定义前加case这个关键字，然后你可以对这些类来模式匹配。 在我们详细介绍Scala的Case class和模式匹配之前

escalation英音：[,esku0259"leiu0283u0259n]美音：[,u025bsku0259"leu0283u0259n]词典解释escalation名词 n.1. 逐步上升;逐步扩大[U][C]

你的belta是2x1向量，belta<( ) 返回的也是2X1，不能与前面的做逻辑运算。这种小问题很好检查的，你把那个长表达式的每一个运算单独跑一下，一眼就看出来了。

you can go upstairs by escalator. Do you own or rent your video? There is a drugstore on the street.He went the theater last night.

Escalator down, Please hold the handrail for safety.翻译可以有很多种，很难猜到你听到的是啥，反正这句差不多意思。

helped bought Where can you find the signs? Which escalator can I use? You don"t have to book the ticket

电梯 阶梯仕电梯呀 什麼用法 它就只是一个名词 与升降式电梯 elevator 不同

日文我全部翻了，因为觉得英文太容易就没必要翻了Crystal Kay - ESCALATOR作词：MONA作曲：KOSUKE MORIMOTO内心矛盾的瞬间松开牵着的手不禁地将之甩开 Dirty talk先迈半步也在温柔地等待狡猾的自己 焦急万分On the Escalator如果回过头 You"re still for away远望过去 Why don"t you follow me你在看哪里，在想什么呀？Thought you always be there for meOne step too far 什么也不说 就这样离开了Two steps too far 最重要的是Oh baby 明明只有你啊渐渐地远离我喜欢的美丽侧脸心痛如绞 如此 Lovin" you意外交接的目光该用怎样的表情来面对呢什么也做不了 悸动是 Escalation在这风中 You"re still for away让你困扰 Why am I hurting too?终于感受到真正的心意Thought you always be there for meOne step too far 什么也不说就这样地远离Two steps too far 明明想要被爱Oh baby 明明一定是一样的心情却连自己的都不清楚如此不坦率的我 真想改变啊One step too far 什么也不说就这样离去Two steps too far 一定要道歉Oh baby 明明知道的One step too far 却什么也不说就这样离去Two steps too far 最重要的Oh baby 只有你One step too far 什么也不说就这样离去Two steps too far 想要被爱Oh baby 明明是一样的心情One step closer 什么也不说就这样离去Two steps closer 最重要的Oh baby 只有你啊

需要，因为后面跟的是清辅音。清辅音是发音时声带不振动的辅音叫做清辅音。与浊辅助音相对。在美国英语里面，发清辅音的字母有：p、t、k、c、q、f、s（在词首或词中，前或后接清辅音），th（在实词中）、sh、h、ch、tch、ts、tr、wh。而s、c都是清辅音，两个清辅音相连是后面的一个就会浊化（即声带会有震动）。学英语时，你会发现这个规律，一般s后的音节都会浊化，例如：school，它既不发/c/，/ch/它发/g/的音。再例如speech中的/p/就发/b/的音。

e(leva)tor--电梯这个词你记得吗e(scala)tor--自动楼梯自动楼梯台阶都是成“S”型的，上下时还会发出“卡啦”（cala）的声音，这样会好记些吗

电梯的意思，手扶的那种，不是升降的（升降的叫lift 或者 elevator 一个英式一个美式）用法： 一般可以说 take the escalator (上电梯)go up the escalator / go down the escalator （坐电梯向上/ 坐电梯向下）

escalator的中文意思是自动扶梯 方法1.既然已经在百度知道上提问了一次,并且有人为你解答,应该有印象了吧,不要浪费每一次可以学东西的机会 方法2.elevator和escalator的意思可以认为是一样的,现在应该记住了吧 方法3.lator这是个很熟悉的后缀,esca谐音：爱思考 希望这个方法对你有效,谢谢你教给我一个新单词：escalator

名词 n. [C]1.自动楼梯,电扶梯The new store has escalators to carry customers from one floor to another. 这家新商店有自动扶梯将顾客从一层楼面运送到另一层楼面。2.(工资等)按生活指数作出调整的条款

escalator ["eskəleitə] n. （美）自动扶梯；电动扶梯

escalator 英[u02c8esku0259u02ccleu026atu0259] 美[u02c8u025bsku0259u02ccletu025a] 复数：escalators n. 1.自动扶梯； 电扶梯 ；滚梯 名词 n.1.自动扶梯； 电扶梯 ；滚梯 I don"t like escalator—I"ll climb the stairs.我不喜欢自动扶梯, 我要爬楼梯。

dose escalation and expansion剂量递增与扩大重点词汇dose剂量，药量; 一服，一剂; 一回，一次，一番; 配料，增味剂; 服药; 给药; 给…服药; 把配分剂量; 在中加料escalation扩大，增加

DomenicoScalaDomenicoScala是一名摄影师，代表作品有《我们时代的英雄》、《湖边的暴力》等。外文名：DomenicoScala职业：摄影师代表作品：《我们时代的英雄》、《湖边的暴力》等合作人物：SergioCapogna

escalation [u02ccesku0259u02c8leu026au0283n] 埃斯克雷迅gifted [u02c8ɡu026aftu026ad] 给夫提的intellectual [u02ccu026antu0259u02c8lektu0283uu0259l] 因特来客修

FrancescaLanciniFrancescaLancini是一名演员，代表作品有《人力资本》、《十二罗汉》等。外文名：FrancescaLancini职业：演员代表作品：《人力资本》、《十二罗汉》等合作人物：保罗·维尔奇主要作品

Scala的caseclass使得对对象进行模式匹配变得非常方便，简单的来说，Scala的caseclass就是在普通的类定义前加case这个关键字，然后你可以对这些类来模式匹配。在我们详细介绍Scala的Caseclass和模式匹配之前，我们可以通过一个简单的例子来说明一些基本概念。我们设计一个函数库，这个函数库可以用来计算算术表达式，为简单起见，我们设计的算术表达式只侧重于变量，数字，单操作符，和双操作符。我们可以采用如下的Scala类定义：abstractclassExprcaseclassVar(name:String)extendsExprcaseclassNumber(num:Double)extendsExprcaseclassUnOp(operator:String,arg:Expr)extendsExprcaseclassBinOp(operator:String,left:Expr,right:Expr)extendsExpr这里我们定义了一个抽象类Expr和四个子类（分别代表变量，数值，单操作符，双操作符），Scala允许我们不定义类的实现，实际我们是classC和classC{}是等价的。

两个处理器，至于是不是双核，不太了解。双核处理器(DualCoreProcessor)：双核处理器是指在一个处理器上集成两个运算核心，从而提高计算能力。首先要了解双核。请看Intel和AMD各自的双核，我们重点是学习它们的区别，只有在了解之后才能知道，选哪一个更好，或者更有性价比。要指正的是，intel和AMD的缓存的用处是不一样的，并不能直接相比，转贴中关于缓存的说法是错的。AMDL1缓存与L2缓存和INTELL1缓存L2缓存大小无可比性，大家可不要乱来比。INTEL的L1缓存是数据代码指令追存缓存，而AMDL1缓存是实数据读写缓存。INTERLL1缓存里(电脑自动关机)存着数据在L2缓存里(电脑自动关机)的地址，L1缓并不存有实际数据，所以大家看到INTELCPU的L1缓存都比较小。相反AMDL1缓存里(电脑自动关机)则存实际数据，当L1缓存满了时,再把数据存到L2缓存，所以大家看到AMDCPU的L1缓存都比较大，为128K。因为L1缓存比L2缓存的延迟速度更小，所以在缓存上，AMDCPU比INTELCPU的效率更高。而说起L2缓存的大小，我们强调INTELCPU的L2缓存超大，不过L2缓存其实在一般使用中并没起到什么作用，反而倒浪费了消费者钱。CPU处理数据概率，CPU使用0-128K缓存的概率是80%。CPU使用128-256K缓存的概率是10%。CPU使用256-512K缓存的概率是5%。CPU使用512-1M缓存的概率是3%。CPU使用更大缓存的概率是2%。所以说太大的缓存并不是很有用。AMD和Intel的内存控制的架构都不一样，仅仅用几个数据根本无法反映出实际情况，实际上是AMD的架构更不存在瓶颈，Intel的共享FSB架构需要和其它硬件设备争夺带宽，延迟也大，大L2的目的也正是为了降低FSB瓶颈的影响。双核处理器可以说是CPU领域最大的亮点。毕竟X86处理器发展到了今天，在传统的通过增加分支预测单元、缓存的容量、提升频率来增加性能之路似乎已经难以行通了。因此，当单核处理器似乎走到尽头之际，Intel、AMD都不约而同地推出了自家的双核处理器解决方案：PentiumD、Athlon64X2!。所谓双核处理器，简单地说就是在一块CPU基板上集成两(电脑没声音)个处理器核心，并通过并行总线将各处理器核心连接起来。双核其实并不是一个全新概念，而只是CMP(ChipMultiProcessors，单芯片多处理器)中最基本、最简单、最容易实现的一种类型。

你的这个代码要用spark shell里面才能执行, sc是spark的context,只装scala是没有spark环境的.

Scala类和java类中有些区别，在Scala声明private变量会Scala编译器会自动生成get,set,在Scala中变量是需要初始化的，如果不声明private默认是public的objectScala中没有静态修饰符，static，在object下的成员全部都是静态的，如果在类中声明了与该类相同的名字的object则该object是该类的“半生对象”，可以理解把类中的static集中放到了object对象中，伴生对象和类文件必须是同一个源文件，可以用伴生对象做一些初始化的操作。trait在java中可以通过interface实现多重继承，在Scala中可以通过特征（trait）实现多重继承，不过与java不同的是，它可以定义自己的属性和实现方法体，在没有自己的实现方法体时可以认为它时javainterface是等价的，在Scala中也是一般只能继承一个父类，可以通过多个with进行多重继承。

打成Jar包，直接用spark-submit 方式运行就可以成功，直接用IntelliJ就总是失败，不知道怎么回事，求大神指点。程序是object HelloSpark {def main(args:Array[String]): Unit ={if(args.length!=2){System.err.println("Usage:HelloSpark <Input> <Output>")System.exit(1)}val conf = new SparkConf().setAppName("helloSpark").setMaster("spark://master:7077").set("spark.executor.memory", "1g").set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")val sc = new SparkContext(conf)sc.textFile(args(0)).map(_.split(" ")).filter(_.length==6).map(x=>(x(1),1)).reduceByKey(_+_).map(x=>(x._2,x._1)).sortByKey(false).map(x=>(x._2,x._1)).saveAsTextFile(args(1))sc.stop()}这是网上的一个实例，步骤都是一步一步来的。16/02/23 16:39:53 WARN TaskSetManager: Lost task 0.0 in stage 0.0 (TID 0, worker1): java.lang.ClassNotFoundException: com.spark.firstApp.HelloSpark$$anonfun$2at java.net.URLClassLoader.findClass(URLClassLoader.java:381)at java.lang.ClassLoader.loadClass(ClassLoader.java:424)at java.lang.ClassLoader.loadClass(ClassLoader.java:357)at java.lang.Class.forName0(Native Method)at java.lang.Class.forName(Class.java:348)at org.apache.spark.serializer.JavaDeserializationStream$$anon$1.resolveClass(JavaSerializer.scala:68)at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1613)at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1993)at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1918)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1801)at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1993)at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1918)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1801)......at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:213)at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)at java.lang.Thread.run(Thread.java:745)16/02/23 16:39:53 INFO TaskSetManager: Starting task 0.1 in stage 0.0 (TID 2, worker0, partition 0,NODE_LOCAL, 2134 bytes)16/02/23 16:39:53 INFO TaskSetManager: Lost task 1.0 in stage 0.0 (TID 1) on executor worker2: java.lang.ClassNotFoundException (com.spark.firstApp.HelloSpark$$anonfun$2) [duplicate 1]16/02/23 16:39:53 INFO TaskSetManager: Starting task 1.1 in stage 0.0 (TID 3, worker2, partition 1,NODE_LOCAL, 2134 bytes)16/02/23 16:39:53 INFO TaskSetManager: Lost task 1.1 in stage 0.0 (TID 3) on executor worker2: java.lang.ClassNotFoundException (com.spark.firstApp.HelloSpark$$anonfun$2) [duplicate 2]16/02/23 16:39:53 INFO TaskSetManager: Starting task 1.2 in stage 0.0 (TID 4, worker1, partition 1,NODE_LOCAL, 2134 bytes)16/02/23 16:39:53 INFO TaskSetManager: Lost task 1.2 in stage 0.0 (TID 4) on executor worker1: java.lang.ClassNotFoundException (com.spark.firstApp.HelloSpark$$anonfun$2) [duplicate 3]16/02/23 16:39:53 INFO TaskSetManager: Starting task 1.3 in stage 0.0 (TID 5, worker1, partition 1,NODE_LOCAL, 2134 bytes)16/02/23 16:39:53 INFO TaskSetManager: Lost task 1.3 in stage 0.0 (TID 5) on executor worker1: java.lang.ClassNotFoundException (com.spark.firstApp.HelloSpark$$anonfun$2) [duplicate 4]16/02/23 16:39:53 ERROR TaskSetManager: Task 1 in stage 0.0 failed 4 times; aborting job16/02/23 16:39:53 INFO TaskSchedulerImpl: Cancelling stage 016/02/23 16:39:53 INFO TaskSchedulerImpl: Stage 0 was cancelled16/02/23 16:39:53 INFO DAGScheduler: ShuffleMapStage 0 (map at HelloSpark.scala:20) failed in 10.015 s16/02/23 16:39:53 INFO DAGScheduler: Job 0 failed: sortByKey at HelloSpark.scala:21, took 10.156984 sException in thread "main" org.apache.spark.SparkException: Job aborted due to stage failure: Task 1 in stage 0.0 failed 4 times, most recent failure: Lost task 1.3 in stage 0.0 (TID 5, worker1): java.lang.ClassNotFoundException: com.spark.firstApp.HelloSpark$$anonfun$2at java.net.URLClassLoader.findClass(URLClassLoader.java:381)at java.lang.ClassLoader.loadClass(ClassLoader.java:424)at java.lang.ClassLoader.loadClass(ClassLoader.java:357)at java.lang.Class.forName0(Native Method)at java.lang.Class.forName(Class.java:348)at org.apache.spark.serializer.JavaDeserializationStream$$anon$1.resolveClass(JavaSerializer.scala:68)at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1613)at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1993)at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1918)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1801)at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1993)at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1918)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1801)at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1993)at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1918)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1801)at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)at scala.collection.immutable.$colon$colon.readObject(List.scala:362)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)at java.lang.reflect.Method.invoke(Method.java:497)at java.io.ObjectStreamClass.invokeReadObject(ObjectStreamClass.java:1017)at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1896)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1801)at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1993)at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1918)at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1801)at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1993)at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1918)......at org.apache.spark.serializer.JavaSerializerInstance.deserialize(JavaSerializer.scala:115)at org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:64)at org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:41)at org.apache.spark.scheduler.Task.run(Task.scala:89)at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:213)at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)at java.lang.Thread.run(Thread.java:745)Driver stacktrace:at org.apache.spark.scheduler.DAGScheduler.org$apache$spark$scheduler$DAGScheduler$$failJobAndIndependentStages(DAGScheduler.scala:1431)at org.apache.spark.scheduler.DAGScheduler$$anonfun$abortStage$1.apply(DAGScheduler.scala:1419)at org.apache.spark.scheduler.DAGScheduler$$anonfun$abortStage$1.apply(DAGScheduler.scala:1418)at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:47)at org.apache.spark.scheduler.DAGScheduler.abortStage(DAGScheduler.scala:1418)at org.apache.spark.scheduler.DAGScheduler$$anonfun$handleTaskSetFailed$1.apply(DAGScheduler.scala:799)at org.apache.spark.scheduler.DAGScheduler$$anonfun$handleTaskSetFailed$1.apply(DAGScheduler.scala:799)at scala.Option.foreach(Option.scala:236)at org.apache.spark.scheduler.DAGScheduler.handleTaskSetFailed(DAGScheduler.scala:799)at org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:1640)......Caused by: java.lang.ClassNotFoundException: com.spark.firstApp.HelloSpark$$anonfun$2at java.net.URLClassLoader.findClass(URLClassLoader.java:381)at java.lang.ClassLoader.loadClass(ClassLoader.java:424)at java.lang.ClassLoader.loadClass(ClassLoader.java:357)at java.lang.Class.forName0(Native Method)at java.lang.Class.forName(Class.java:348)at org.apache.spark.serializer.JavaDeserializationStream$$anon$1.resolveClass(JavaSerializer.scala:68)at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1613)at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)......16/02/23 16:39:53 INFO SparkContext: Invoking stop() from shutdown hook16/02/23 16:39:53 INFO SparkUI: Stopped Spark web UI at :404016/02/23 16:39:53 INFO SparkDeploySchedulerBackend: Shutting down all executors......Process finished with exit code 1这个问题我解决了，在设置SparkConf()的时候，需要把本机生成的JAR包路径进行制定，如：val conf = new SparkConf().setAppName("SogouResult").setMaster("spark://master:7077").setJars(List("D:\IDEA workspace\helloSpark\out\artifacts\helloSpark_jar\helloSpark.jar"))

定义变量要用var关键字，语法是：var 变量名:变量类型[=初始值][;]其中，[]中的内容表示是可选的。如：var n:Int=100定义了一个整型变量叫n，初始值是100。如果在定义时指定了初始值，则变量类型的指定也可以省略，如：var n=1001

不用捕获是因为Scala 编译器不做这方面检查啊，自然你不捕获不抛出也能过编译。至于为什么Scala 编译器不检查异常，是因为语言设计者们认为异常不是好的错误处理实践。理由如下：1，异常会打断执行流，因此不是类型安全的2，异常不利于类型推断3，从实践来看，大部分程序员并不会认真处理异常，不是catch下打个log就是继续往外throw了事，结果就是又臭又长的throw4, 丑，这是原罪。Scala 鼓励使用类型来表示错误信息，例如Option与Future ，Either, 选择与未来（:-D），这样控制流里你可以带着错误信息一直往下走，直到一个能优雅处理错误的位置。

首先写一个样例类Demo 运行后，使用反编译打开，会发现一个样例类 Dollar会生成Dollar$.class和Dollar.class文件 首先来看Dollar$.class 然后Dollar.class 1、样例类默认实现了序列化，实现了scala的Product 2、构造器中的value当成了属性，且默认都是val(对应Java的final) 3、默认实现了apply和unapply，这就是为何样例类不用new可以直接使用的原 4、默认实现了常用的toString/equals/hashCode/copy方法

这行代码定义了一个变量，类型为函数，你可以在脑海中简化为：val fun = 3 * _其中fun后面冒号的"(Double) => Double"是一个整体，是变量fun的类型这种形式的类型代表了一个函数，"=>"之前的是函数的参数，之后的是返回类型这里是声明fun是一个接受一个Double型参数并返回Double型结果的函数"="就是赋值，"="左边是变量及变量类型声明，右边是一个数据具体来说，右边是一个函数的简写，等价于"x => 3 * x"，就是返回输入参数的3倍总的来说："=>"在scala里是声明函数的，其前面是参数，后面是返回结果"="就是赋值，跟别的语言没有不同，你这里看糊了主要还是一时没有看清代码的结构

Scala是一种高级编程语言，它结合了面向对象编程和函数式编程的特点，并且被广泛用于现代计算机科学与软件工程领域。在英国的本科计算机课程中，Scala通常是在上层课程中介绍的，主要着重于以下几个方面的学习：1. 函数式编程：学习Scala编程的核心，包括不可变数据结构、函数组合和高阶函数等主题。2. 面向对象编程：理解对象和类的概念，学习Scala中的继承和多态，以及如何使用它们来编写可读性更高的代码。3. 并发编程：Scala与Java一样，为开发人员提供了一套底层Java并发库，但Scala提供了更好的控制和可操作性。4. 容器和集合：Scala集合库有助于开发人员更轻松地处理数据，使代码更具可读性和可重用性。如果需要找靠谱的Scala辅导老师，可以尝试以下途径：1. 在学校技术团队或技术协会里寻求帮助。一些大学会有各种技术相关的学生团队和协会，其中一些可能提供Scala编程辅导和训练。2. 在社交媒体平台上寻找。有些Scala社区在Facebook和Twitter等平台上很活跃，有可能会在这里找到Scala相关的帮助和资源。3. 在线寻求辅导。有很多网站和平台，如Udemy、Coursera和LinkedIn Learning 等提供了许多Scala编程的在线课程，可以寻求这些课程的帮助。如果以上途径不能解决您课业上的困难，也可以找专业的留学生辅导机构，比如英国翰思教育，感兴趣的可以去官网咨询一下。总之，Scala课程需要耐心、时间和努力学习。找到一个靠谱的辅导老师，可以帮助你更好地理解Scala编程，并尽快掌握这项技能。

切换到scala环境中存放test.scala文件的文件夹下先编译：scalac test.scala再执行：scala -classpath . HelloWorld (这里HelloWorld为代码中的对象名称)

我没有实践过 但是据我所知 是这样的

这样就把控制符改为不在类的状态了。scanf函数最主要的用法是：scanf("输入控制符",输入参数);函数原型：intscanf(constchar*restrictformat,...);函数scanf()是从标准输入流stdin(标准输入设备，一般指向键盘)中读内容的通用子程序，可以说明的格式读入多个字符，并保存在对应地址的变量中。scala语言的介绍：Object-OrientedMeetsFunctional；Java：面向对象语言；C语言：是函数编程，函数不需要放在类中；Scala语言集成Java语言和C语言的2大优点；Scala既能做大型项目的开发，也能做数据分析OOP+FP

条件表达式Scala的if/else语法结构和Java或C++一样。不过，在Scala中if/else表达式有值，这个值就是跟在if或else之后的表达式的值。例如：if (x > 0) 1 else -1上述表达式的值是1或u22121，具体是哪一个取决于x的值。你可以将if/else表达式的值赋值给变量：val s = if (x > 0) 1 else -1这与如下语句的效果一样：if (x > 0) s = 1 else s = -1不过，第一种写法更好，因为它可以用来初始化一个val。而在第二种写法当中，s必须是var。（之前已经提过，Scala中的分号绝大多数情况下不是必需的。）Java和C++有一个?:操作符用于同样目的。如下表达式x > 0 ? 1 : -1 // Java或C++等同于Scala表达式 if (x > 0) 1 else u22121。不过，你不能在?:表达式中插入语句。Scala的if/else将在Java和C++中分开的两个语法结构if/else和?:结合在了一起。在Scala中，每个表达式都有一个类型。举例来说，表达式 if (x > 0) 1 else u22121的类型是Int，因为两个分支的类型都是Int。混合类型表达式，比如：if (x > 0) "positive" else -1上述表达式的类型是两个分支类型的公共超类型。在本例中，其中一个分支是java.lang.String，而另一个分支是Int。它们的公共超类型叫做Any。（详细内容参见8.11节。）如果else部分缺失了，比如：if (x > 0) 1那么有可能if语句没有输出值。但是在Scala中，每个表达式都应该有某种值。这个问题的解决方案是引入一个Unit类，写做()。不带else的这个if语句等同于if (x > 0) 1 else ()你可以把()当做是表示“无有用值”的占位符，将Unit当做Java或C++中的void。（从技术上讲，void没有值但是Unit有一个表示“无值”的值。如果你一定要深究的话，这就好比空的钱包和里面有一张写着“没钱”的无面值钞票的钱包之间的区别。）说明：Scala没有switch语句，不过它有一个强大得多的模式匹配机制，我们将在第14章中看到。在现阶段，用一系列的if语句就好。注意：REPL比起编译器来更加“近视”——它在同一时间只能看到一行代码。举例来说，当你键入如下代码时：if (x > 0) 1else if (x == 0) 0 else -1REPL会执行 if (x > 0) 1，然后显示结果。之后它看到接下来的else关键字就会不知所措。如果你想在else前换行的话，用花括号：if (x > 0) { 1} else if (x == 0) 0 else -1只有在REPL中才会有这个顾虑。在被编译的程序中，解析器会找到下一行的else。提示：如果你想在REPL中粘贴成块的代码，而又不想担心REPL的近视问题，可以使用粘贴模式。键入：:paste把代码块粘贴进去，然后按下Ctrl+D。这样REPL就会把代码块当做一个整体来分析。语句终止在Java和C++中，每个语句都以分号结束。而在Scala中——与JavaScript和其他脚本语言类似——行尾的位置不需要分号。同样，在}、else以及类似的位置也不必写分号，只要能够从上下文明确地判断出这里是语句的终止即可。不过，如果你想在单行中写下多个语句，就需要将它们以分号隔开。例如：if (n > 0) { r = r * n; n -= 1 }我们需要用分号将 r = r * n 和 n -= 1 隔开。由于有}，在第二个语句之后并不需要写分号。如果你在写较长的语句，需要分两行来写的话，就要确保第一行以一个不能用做语句结尾的符号结尾。通常来说一个比较好的选择是操作符：s = s0 + (v - v0) * t + // +告诉解析器这里不是语句的末尾0.5 * (a - a0) * t * t在实际编码时，长表达式通常涉及函数或方法调用，如此一来你并不需要过分担心——在左括号（之后，编译器直到看到匹配的）才会去推断某处是否为语句结尾。正因如此，Scala程序员们更倾向于使用Kernighan & Ritchie风格的花括号：if (n > 0) {r = r * nn -= 1}以{结束的行很清楚地表示了后面还有更多内容。许多来自Java或C++的程序员一开始并不适应省去分号的做法。如果你倾向于使用分号，用就是了——它们没啥坏处。块表达式和赋值在Java或C++中，块语句是一个包含于{ }中的语句序列。每当你需要在逻辑分支或循环中放置多个动作时，你都可以使用块语句。在Scala中，{ }块包含一系列表达式，其结果也是一个表达式。块中最后一个表达式的值就是块的值。这个特性对于那种对某个val的初始化需要分多步完成的情况很有用。例如，val distance = { val dx = x - x0; val dy = y - y0; sqrt(dx * dx + dy * dy) }{ }块的值取其最后一个表达式，在此处以粗体标出。变量dx和dy仅作为计算所需要的中间值，很干净地对程序其他部分而言不可见了。在Scala中，赋值动作本身是没有值的——或者，更严格地说，它们的值是Unit类型的。你应该还记得，Unit类型等同于Java和C++中的void，而这个类型只有一个值，写做()。一个以赋值语句结束的块，比如{ r = r * n; n -= 1}的值是Unit类型的。这没有问题，只是当我们定义函数时需要意识到这一点。由于赋值语句的值是Unit类型的，别把它们串接在一起。x = y = 1 // 别这样做y = 1的值是()，你几乎不太可能想把一个Unit类型的值赋值给x。（与此相对应，在Java和C++中，赋值语句的值是被赋的那个值。在这些语言中，将赋值语句串接在一起是有意义的。）输入和输出如果要打印一个值，我们用print或println函数。后者在打印完内容后会追加一个换行符。举例来说，print("Answer: ")println(42)与下面的代码输出的内容相同：println("Answer: " + 42)另外，还有一个带有C风格格式化字符串的printf函数：printf("Hello, %s! You are %d years old. ", "Fred", 42)你可以用readLine函数从控制台读取一行输入。如果要读取数字、Boolean或者是字符，可以用readInt、readDouble、readByte、readShort、readLong、readFloat、readBoolean或者readChar。与其他方法不同，readLine带一个参数作为提示字符串：val name = readLine("Your name: ")print("Your age: ")val age = readInt()printf("Hello, %s! Next year, your will be %d. ", name, age + 1)

(1 to 10) map { case x => 2*x }中的{ case x => 2*x } 得到的是一个PartialFunction 。然而，事实并非如此。简单说，凡是Scala中出现如下表达式时：{ case p1 => e1; case p2 => e2; ...; case pn => en }其结果为Scala中的匿名函数(Anonymous Function) ,但是其具体类型是根据其所处位置而定，可能是一个FunctionN，也可能是一个PartialFunction （这里的FunctionN指的是非PartialFunction的Function）。下面用一段小代码证明之：scala> def needfunc[F](f: F) = fneedfunc: [F](f: F)Fscala> needfunc[PartialFunction[Int, Int]]({ case x => 2*x }).getClass.getSuperclasswarning: there was one feature warning; re-run with -feature for detailsres0: Class[?0] forSome { type ?0 >: ?0; type ?0 <: PartialFunction[Int,Int] } = class scala.runtime.AbstractPartialFunction$mcII$spscala> needfunc[Int => Int]({ case x => 2*x }).getClass.getSuperclasswarning: there was one feature warning; re-run with -feature for detailsres1: Class[?0] forSome { type ?0 >: ?0; type ?0 <: Int => Int } = class scala.runtime.AbstractFunction1$mcII$sp上面的结果表明，当我需要一个Function(非PartialFunction)时，我得到的就是一个非PartialFunction的Function；当我需要一个PartialFunction时，得到就是PartialFunction。当然，我不是仅有上面的例子就下结论。实际上，《Scala语言规范》(Scala Language Specification)对此有具体规定，引用如下：Pattern MatchingPattern Matching Anonymous FunctionsBlockExpr ::= `{" CaseClauses `}"An anonymous function can be defined by a sequence of cases{ case p1 => b1; …… case pn => bn }which appear as an expression without a prior match. The expected type of such an expression must in part be defined. It must be either scala.Functionkk[S1,…,Sk, R] for some k>0, or scala.PartialFunction[S1, R], where the argument type(s) S1,…,Sk must be fully determined, but the result type R may be undetermined.为啥需要搞清什么时候是PartialFunction而什么时候是FunctionN呢，这里涉及另一个问题：PartialFunction在某些时候相对FunctionN会存在性能问题！这是另一个有趣的问题了。

函数式编程或称函数程序设计，又称泛函编程，是一种编程范型，它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。函数编程语言最重要的基础是λ演算（lambda calculus）。而且λ演算的函数可以接受函数当作输入（引数）和输出（传出值）。比起命令式编程，函数式编程更加强调程序执行的结果而非执行的过程，倡导利用若干简单的执行单元让计算结果不断渐进，逐层推导复杂的运算，而不是设计一个复杂的执行过程。面向对象程序设计是一种程序设计范型，同时也是一种程序开发的方法。对象指的是类的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。目前已经被证实的是，面向对象程序设计推广了程序的灵活性和可维护性，并且在大型项目设计中广为应用。 此外，支持者声称面向对象程序设计要比以往的做法更加便于学习，因为它能够让人们更简单地设计并维护程序，使得程序更加便于分析、设计、理解。反对者在某些领域对此予以否认。当我们提到面向对象的时候，它不仅指一种程序设计方法。它更多意义上是一种程序开发方式。

都是编程语言啊。Scala运行于Java平台（Java虚拟机），并兼容现有的Java程序。它也能运行于Java ME, CLDC（Java Platform, Micro Edition Connected Limited Device Configuration）上。目前还有另一.NET平台的实现，不过该版本更新有些滞后。 Scala的编译模型（独立编译，动态类加载）与Java和C#一样，所以Scala代码可以调用Java类库（对于.NET实现则可调用.NET类库） 。 Scala包中包含了编译器和类库，以BSD许可证发布。面向对象，函数式编程

先说结论：你会得到一个装了“1 2 3”三个元素的列表。 不过，对于Java程序员来说，这应该是一种很陌生的用法。 在《同样是访问数组的第一个元素,为什么Scala选择不用array[0]?》中我们讲到Scala是有不少“糖”的，比如1 + 2实际上等同于对“1”这个Int类型调用了“+”这个方法，并且传入“2”这个参数，也就是：(1).+(2)。 那么在这里，可以尝试推导下，1 :: 2是不是等于(1).::(2)呢？很可惜并不是。实际上标题里的语句应该倒着执行，也就是说，实际上是先执行了Nil.::(2)。这条语句得到的结果是一个仅包含了2这个元素的列表。 因此 :: 代表的是，把某样东西和某个列表拼接在一起，并返回一个新的列表。 这里的 :: 我们读作cons，借鉴自老祖宗Lisp的语法，刚才的2 :: Nil在Lisp里我们写作(cons 2 "())。 看到这里，大概你也猜到Nil代表的是一个空列表了吧？ 当然，这里除了借鉴了语法之外，还有一个很重要的点， 方法调用返回的其实是一个新的List，而不是在原来的List里进行头插。 也是之前一篇文章提到的不可变数据结构的一种应用。 不得不赞一下，Scala给了大家一个启示：Lisp也是可以不要括号的！ （如果有人想看关于Lisp的东西，请在文章下方留个言哦） 同样是把方法调用转化为中缀表达式的语法糖，一会是对于操作符的左边执行方法调用，一会是对于操作符的右边执行方法调用，到底有什么便于记忆的规则么？ 实际上，Martin在《Programming in Scala》里给出了答案： 简单说，除非是以冒号结尾的方法，否则一律像 a * b 这样处理。

1、scala是什么其实，scala是 一种语法，类似Java，而sbt是 一个构建工具，类似maven,gradle,ant等。在eclipse中只有scala开发环境的插件，可以构建scala project，但是没有sbt 插件，就像没有maven插件的eclipse，只能构建和编辑java project，但是整不了maven project。2、 构建步骤1）构建Scala语言环境 ，和java一样，主要分两步：下载软件、配置HOME和Path.2）安装SBT 工具，下载、配置全局变量（在windows环境中添加sbt.bat脚本，可以直接运行）3）使用SBT生成一个类似maven 包结构的scala project。3、实际操作1）新建一个目录叫 test2）在test目录中新建文件build.sbt3）在test目录新建project目录，进入project目录，并新建plugins.sbt，在其中添加 addSbtPlugin("com.typesafe.sbteclipse" % "sbteclipse-plugin" % "2.4.0")4）在build.sbt中配置工程的name，scala编译环境，依赖等等。如：import sbt._import Process._import Keys._EclipseKeys.createSrc := EclipseCreateSrc.Default + EclipseCreateSrc.Resourcelazy val commonSettings = Seq( name := "test", organization := "com.marsyoung", version := "0.0.1-SNAPSHOT", scalaVersion := "2.11.7")lazy val root = (project in file(".")). settings(commonSettings: _*). settings( libraryDependencies ++= Seq( "junit" % "junit" % "4.4", "javax.ws.rs" % "jsr311-api" % "1.1.1" ) )5）在cmd中进入对应的project目录，即test目录。运行sbt。6）执行eclipse命令，将对应的项目转化成可以引入eclipse开发工具并且目录结构类似maven的项目。7）打开已经安装了scala ide的eclipse，导入对应的project，会自动的编译成scala peoject.4、小提示SBT配置使其支持本地maven和私服，如下：在用户根目录下的.sbt文件夹内，在windows下就是C->用户->用户名->.sbt目录下新建repositories文件并插入内容：[repositories] local activator-launcher-local: file:////${activator.local.repository-${activator.home-${user.home}/.activator}/repository}, [organization]/[module]/(scala_[scalaVersion]/)(sbt_[sbtVersion]/)[revision]/[type]s/[artifact](-[classifier]).[ext] activator-local: file:////${activator.local.repository-D:/maven/repo3.3.1} sohu-public: http://xxx.com/nexus/content/groups/public typesafe-releases: http://repo.typesafe.com/typesafe/releases typesafe-ivy-releasez: http://repo.typesafe.com/typesafe/ivy-releases, [organization]/[module]/(scala_[scalaVersion]/)(sbt_[sbtVersion]/)[revision]/[type]s/[artifact](-[classifier]).[ext] sonatype-oss-releases sonatype-oss-snapshots maven-central本地maven地址为：D:/maven/repo3.3.1

1，构建系统的选择，sbt更合适用来构建Scala工程，maven更合适用来构建Java工程2，对于spark中的API来说，Java和Scala有差别，但差别并不大3，如果用Scala开发spark原型程序，可以用spark-shell逗打草稿地，或者直接使用spark-shell做交互式实时查询4，用Scala代码量将减少甚至一个数量级，不过Scala的使用门槛较高建议：使用Scala构建spark作业，因为spark本身为sbt所构建，同时使用Scala开发spark作业将有助于理解spark的实现机制作者：egraldlo链接：

scala> :paste// Entering paste mode (ctrl-D to finish) //该行是Enter之后自动显示的val movies = sc.textFile("sffs.dat").map{line=>val fields = line.split("::")(fields(0).toInt, fields(1))}.collectAsMap() //注释：此时按ctrl-D无法结束，按Enter另起一行，再按ctrl-D，结束

如果使用ide的话并不需要配置环境变量， 在ide中指定scala的home路径就可以了， 如果为了方便的话可以在 /etc/profile 这个文件中修改 PATH 这一行， 加上 ${你的scala路径}/bin，这样你运行命令行的时候就可以 scala 直接进入编辑器了。

一、编写第一个用scala写的spark应用：仿照spark的 quick-start的Self-Contained Applications写出第一个scala完整程序链接如下：即：/* SimpleApp.scala */import org.apache.spark.SparkContextimport org.apache.spark.SparkContext._import org.apache.spark.SparkConfobject SimpleApp {def main(args: Array[String]) {val logFile = "YOUR_SPARK_HOME/README.md" // Should be some file on your systemval conf = new SparkConf().setAppName("Simple Application")val sc = new SparkContext(conf)val logData = sc.textFile(logFile, 2).cache()val numAs = logData.filter(line => line.contains("a")).count()val numBs = logData.filter(line => line.contains("b")).count()println("Lines with a: %s, Lines with b: %s".format(numAs, numBs))}}整个程序作用是：找到这个文件YOUR_SPARK_HOME/README.md中有几个a和几个b。二、用sbt进行打包成jar：命令：sbt package具体步骤见中的Self-Contained Applications打包时候几点注意：1、目录结构一定要对目录结构可以通过find .来看有点类似cmake的感觉2、总时间，近30分钟，开始打开会terminal没现象10分钟，然后开始要各种resolve，之后要下载很多库，我这边网速超慢sbt是个联网编译器，Spark的应用用到了很多RDD的变换，来编译这些库都得去网上下相应的包最后显示，编译时间11s这时成功完成SimpleApp三、在本机上测试：命令为：YOUR_SPARK_HOME/bin/spark-submit --class "SimpleApp" --master local[4] target/scala-2.10/simple-project_2.10-1.0.jar我对jar的理解就是一个可执行文件了，这个可执行文件在JVM上就可以跑了，local中4是指设置成4个线程，但具体原因我也不知道注意submit的参数：--class中 SimpleApp是包名上传的的jar的地址别写错一、编写第一个用scala写的spark应用：仿照spark的 quick-start的Self-Contained Applications写出第一个scala完整程序链接如下：即：/* SimpleApp.scala */import org.apache.spark.SparkContextimport org.apache.spark.SparkContext._import org.apache.spark.SparkConfobject SimpleApp {def main(args: Array[String]) {val logFile = "YOUR_SPARK_HOME/README.md" // Should be some file on your systemval conf = new SparkConf().setAppName("Simple Application")val sc = new SparkContext(conf)val logData = sc.textFile(logFile, 2).cache()val numAs = logData.filter(line => line.contains("a")).count()val numBs = logData.filter(line => line.contains("b")).count()println("Lines with a: %s, Lines with b: %s".format(numAs, numBs))}}整个程序作用是：找到这个文件YOUR_SPARK_HOME/README.md中有几个a和几个b。二、用sbt进行打包成jar：命令：sbt package具体步骤见中的Self-Contained Applications打包时候几点注意：1、目录结构一定要对目录结构可以通过find .来看有点类似cmake的感觉2、总时间，近30分钟，开始打开会terminal没现象10分钟，然后开始要各种resolve，之后要下载很多库，我这边网速超慢sbt是个联网编译器，Spark的应用用到了很多RDD的变换，来编译这些库都得去网上下相应的包最后显示，编译时间11s这时成功完成SimpleApp三、在本机上测试：命令为：YOUR_SPARK_HOME/bin/spark-submit --class "SimpleApp" --master local[4] target/scala-2.10/simple-project_2.10-1.0.jar我对jar的理解就是一个可执行文件了，这个可执行文件在JVM上就可以跑了，local中4是指设置成4个线程，但具体原因我也不知道注意submit的参数：--class中 SimpleApp是包名上传的的jar的地址别写错阅读全文

不修改，返回新值： def inc(a:Int) = a + 1，方法参数是不可变的，若真要能改，就wrap一下，间接传入var：class A(var a : Int)def changeA(a: A) { a.a = 3 }val a = new A(1)changeA(a)println(a.a)

在Linux上安装Scala，有下面的2种方法。1)DefaultScalaversionavailableonyourLinuxboxbytypingbelowcommandsudoapt-getinstallscala2)Ifyouwanttogetthelatestversionofthescalabelowarethestepsa)Download

大数据（big data），是指无法在可承受的时间范围内用常规软件工具进行捕捉、管理和处理的数据集合。有人把数据比喻为蕴 藏能量的煤矿。煤炭按照性质有焦煤、无烟煤、肥煤、贫煤等分类，而露天煤矿、深山煤矿的挖掘成本又不一样。与此类似，大数据并不在“大”，而在于“有用”。价值含量、挖掘成本比数量更为重要。对于很多行业而言，如何利用这些大规模数据是成为赢得竞争的关键。大数据的价值体现在以下几个方面：1)对大量消费者提供产品或服务的企业可以利用大数据进行精准营销;2) 做小而美模式的中长尾企业可以利用大数据做服务转型;3) 面临互联网压力之下必须转型的传统企业需要与时俱进充分利用大数据的价值。

7 懒加载 lazy 惰性变量用法放在不可变变量之前； 只有在调用惰性变量时才会去实例化这个变量，类似于java中单例模式的懒汉模式； 作用：是将推迟复杂的计算，直到需要计算的时候才计算，而如果不使用，则完全不会进行计算。 通过反编译工具查看后发现 不带有 lazy 关键字： ** ** 带有lazy关键字 ** ** 总结： 对于这样一个表达式： lazy val t:T = expr 无论expr是什么东西，字面量也好，方法调用也好。Scala的编译器都会把这个expr包在一个方法中，并且生成一个flag来决定只在它第一次被访问时才调用该方法。 海汼部落原创文章，原文链接：(http://hainiubl.com/topics/75741)

徒徒了旅途涂涂秀他 他 土 土 你截图 他

使用String的 to* 方法可以讲字符串转换为Scala的数值类型，eg. 输出如下： 需要注意的是，这些方法可能会抛出Java的 NumberFormatException ，eg. 输出： BigInt和BigDecimal类型的数值也可以通过字符串创建，eg. 因为Scala的 toInt 等字符串转成数值的方法不支持传入进制，可以使用 java.lang.Integer 的 parseInt 方法，eg. 输出如下： 也可以用隐式转换，eg. 输出如下： 注意：隐式转换会影响当前作用域；

java是实用的基础，当然要学习了

数组： 可变与不可变 不可变数组是指数组的长度是不可变的，但是数组对应的元素是可变的 可变数组的长度和元素都可以改变 不可变数组 val arr=Array(1,2) 完成初始化，且限定长度为2 val arr=Array Int 长度为5的Int类型数组 val arr=arr ++ arr1 只是通过显示申明过类型的数组才可以进行该操作，不然报类型不匹配错误 可变数组 val c = scala.collection.mutable.ArrayBuffer Int c可以任意的插值和更新值 List: List是不可变的。长度无法再改变，但是对象可变。 val oneTwoThreeFour = oneTwo ::: threeFour list合并，与java.lang.String一样，返回的是一个新对象 1 :: twoThree 可以添加值，但只能向前添加 Tuple: 不可变多值对象，其特点是可以放入任意类型的数据 val pair = (99, "Luftballons") 内部生成一个Tuple2对象 println(pair._1) 访问是通过_N访问，N从1开始 println(pair._2) Set: 对可变set和不可变set的分析 对于可变set和不可变set都可以通过 set+="str" 来添加一个元素，但是机制不同 对于不可变set来说，想添加元素变量必须是var修饰，因为不可变set的机制和List相同 返回的是一个新的Set，如果元素是val不可变，就不能接受新的Set。相反，如果是一个 可变集合，即使变量是val修饰的，还是可以添加元素，因为集合本身没有改变 Map: 对象映射关系集合，也分可变不可变，但是原理一样 var myMap=Map(1->"s",2->2) 可以初始化，也可以不 myMap+=(3->"q") 添加或者修改元素 对于所有集合，在初始化时进行赋值操作，编译器会识别并给这个集合表明类型，如果全部是Int 那么这个集合就是Int类型，不可更改。如果插入时又有Int又有String,那么类型是any，可以 对任意类型操作。

从语法和库的角度来说，可以，写的脚本行数和ruby差不多 但是运行时需要java虚拟机还要安装scala，有点不方便 java虚拟机启动还是有点慢，运行scala 脚本文件名.scala 时会有一下卡顿的感觉，不是太爽

hadoop是大数据生态圈，scala是编程语言，完全不同的东西

Scala到底是什么?在目前众多的JVM语言当中，Scala无疑是最引人注意的语言之一。Scala是一个静态语言，更适合大型工程项目，Scala直接编译成Java字节码，性能接近Java。Scala是一个多范式的语言，你可以混合使用函数式和面向对象编程

2.9. Formatting Numbers and CurrencyProblemYou want to format numbers or currency to control decimal places and commas, typically for printed output.SolutionFor basic number formatting, use the f string interpolator shown in Recipe 1.4:scala> val pi = scala.math.Pipi: Double = 3.141592653589793scala> println(f"$pi%1.5f")3.14159A few more examples demonstrate the technique:scala> f"$pi%1.5f"res0: String = 3.14159scala> f"$pi%1.2f"res1: String = 3.14scala> f"$pi%06.2f"res2: String = 003.14If you"re using a version of Scala prior to 2.10, or prefer the explicit use of the formatmethod, you can write the code like this instead:scala> "%06.2f".format(pi)res3: String = 003.14A simple way to add commas is to use the getIntegerInstance method of thejava.text.NumberFormat class:scala> val formatter = java.text.NumberFormat.getIntegerInstanceformatter: java.text.NumberFormat = java.text.DecimalFormat@674dcscala> formatter.format(10000)res0: String = 10,000scala> formatter.format(1000000)res1: String = 1,000,000You can also set a locale with the getIntegerInstance method:scala> val locale = new java.util.Locale("de", "DE")locale: java.util.Locale = de_DEscala> val formatter = java.text.NumberFormat.getIntegerInstance(locale)formatter: java.text.NumberFormat = java.text.DecimalFormat@674dcscala> formatter.format(1000000)res2: String = 1.000.000You can handle floating-point values with a formatter returned by getInstance:scala> val formatter = java.text.NumberFormat.getInstance ...

import typestype(x) is types.IntType # 判断是否int 类型type(x) is types.StringType #是否string类型！

简单学习一下scala

（1）安装scala在官网上下载scala，本人下载scala-10.04 http://www.scala-lang.org/download/all.html其中windows下有两个版本。msi和exe，具体区别可百度查看。这边随便找了一个说明http://zhidao.baidu.com/link?url=7BRlyeFUYodktHwGCjLUmOBFtqrMX1x0D3y3VA_BvSVhRkWXFR3dMSmbw3JIkxUF7IljpW_YjGzeQ4sKejKt39zb-tnYDzx5cxLI09Ud8EK建议下载msi，比较方便。下载之后直接安装即可。记住安装目录，比如本人安装在 D:proSoftwarescala修改环境变量不同版本的windows界面不尽相同，进入环境变量之后，修改系统变量中的path变量，在最后加入D:proSoftwarescalain 注意，如果加入之前最后没有分号，记得手动加上分号，同时记得在scala目录之后加上in修改完环境变量之后，运行cmd 输入 scala -version 出现版本信息表示安装成功。（2）安装eclipse的scala插件在官网上下载IFE http://scala-ide.org/download/sdk.html下载完直接解压就可以运行，打开解压好的eclipse点击file->new ->scala project填写project name右击文件夹，new-->scala object填写名称 hello然后增加代码 def main(args :Array[String]){ println("Hello world!"); }选中Hello.scala，右击run as ->scala application控制台输出结果成功。

1. 当你说“型”我要去静态类型居多。但我会谈谈动态类型不久。 静态类型是可以静态地证明（“没有运行它”）中的程序的一部分的属性。在静态类型语言中，每个表达式都有一个类型无论你写与否。例如，在CISH“诠释x=A * B +C-D”，A，B，c和d具有类型，A * B有一个类型 CodeGo.net，一个* B +C有一个类型与A * B +C-D都有一个类型。但我们只注明x其中一个类型。在其他语言，比如Scala，C＃，Haskell中，SML，和F＃，即使这样，也没有必要。 究竟什么样的属性是可证明取决于类型检查。 Scala的样式类，而另一方面，仅仅是规范的一组对象。该规范包括，包括了很多，代表性的细节，例如机构和private领域等在Scala中的类还指定模块的border。 许多语言都有类型，但不具有类和许多语言都有课，但没有（静态）类型。 有类型和类之间的一些细微的差别。列表[字符串]是一种类型，但不是一类。在Scala中列出的是类，但通常不是一个类型（它实际上是一个更高的kinded型）。在C＃中列出的是不是一个类型的任何一种，并在Java中这是一个“原始类型”。 Scala提供结构类型。 {foo的高清：pubs}指可证明有一个返回pubs，不分阶级的任何对象。它是一个类型，但不是一个类。 类型可以是类型当你写DEF为foo [T]（X：T）=...，那么foo的体内T是一个类型。但T是不是一类。 类型可以是虚拟的scala（即“抽象类，但是，今天（不能是虚拟与scala虽然有一个样板沉重的方式来虚拟类编码 现在，动态类型。动态类型对象执行某些操作之前，会自动检查的性质。在动态类型的基于类的OO语言有类型和类之间有很强的相关性。事情发生在JVM语言比如Scala和Java具有只可以动态地检查，如反射和投射操作。在这些语言中，“类型擦除”更多的还是大多数对象的动态类型是因为他们的阶级。更多或更少。这不是真正的，例如，它们通常不被擦除，使之可以告诉数组[INT]和数组[字符串]之间的区别数组。但我的宽泛定义的“动态类型对象的自动检查的性质。”当反射也能够发送到的对象。如果对象支持则一切正常了。是有意义的谈话，可以嘎嘎如鱼得水作为一个动态类型的所有对象，即使它不是一个类。这是一个什么样的Python和调用的本质“鸭打字。”此外，通过我的宽泛定义，甚至“zeroness”是一个动态的类型在某种意义上说，在大多数语言中，会自动检查号码，以确保你不被零除。有一个非常，非常少的语言，可以证明，静态地使零（或不为零）的静态类型。 最后，其他的也有类型，例如int不具有一个类作为一个细节，类型，如Null和任何这是一个有点特殊，但可能有类和不和类型，如没有它甚至没有任何值更何况是一个类。 2. 好吧，我会咬...有一个很好的答案，所以我要去尝试不同的技巧和提供一个更下降到地球的观点。 广义地说，一类是可被实例化。单例对象（scala）性状（scala）和接口（scala）被认为是类。这是有道理的，因为单身仍然实例化（代码）和一个接口可以被实例化一个子类的一部分。 其中第二点.class是设计在大多数面向对象语言的基本单位（虽然不是基于原型的，如JavaScript）的。多态性与子类在类术语界定.class还提供了一个和可见性控制。 类型是一个非常不同的野兽，该系统能够表达每一个可能的值将具有一种或多种类型，并且这些可以等同于类，例如：(Int) => String // both the type and class are Function1[Int,String]"hello world" // class and type are String 您还可以得到scala和Java之间有趣差异：7 // both the class and type are Int in Scala// in Java there"s no class and the type is Integer.TYPEprintln("hello world") // the return type is Unit, of class Unit// Java has void as a type, but no corresponding classerror("oops") // the type and class are both "Nothing"而真正有趣的类型不属于类的。例如，this.type始终指的unique类型this。这是唯一的一个实例，是不是与类的其他实例。 也有抽象类型和类型，例如：type A // "A" is an undetermined abstract type// to be made concrete in a subclassclass Seq[T] { ... } // T is a type, but not a classSeq有趣的是，因为它是一个类，而不是一个类型。更准确地说，它是一个“类的构造函数”，这将构建一个有效的类型时，提供必要的类型提供的类型构造器的另一个术语是“高kinded类型”，我个人不喜欢这个词，因为“型构造”思在供应类型像任何其他表单的条款-模型，有良好的scala。 “高kinded”正确地暗示Seq有一个“种”，这是* => *，这个符号指出，Seq将采取单一的类型和产生一个单一的类型（这类似于用于描述函数柯里表示法）。通过这样的一种Map是* => * => *它需要两个类型 3. A型可通过本身，没有任何实例.a个例子这就是所谓的“幽灵式”。下面是Java的一个例子： 在这个例子中，我们有public static class Initializer<HA, HB>，其中HA和HB取类型（由抽象类代表TRUE和FALSE），而没有beeing实例化。 我希望这表明，类型和类是不同的，并且类型可以通过本身。 4. （仅限于Java），我会说，一类是一组对象。对象o是类型X如果o是集X.class型X是的子类型Y，如果设置X的一个子集Y。 对于每一个C类（不是接口）有一组对象，从创建new C(...)。有趣的是，我们很少在乎这一套。 （但每一个对象不属于一组这样的事实，这可能 对于每一个C类，有一种类型t(C)一般方称为“C型”，这是一组可从被创建的所有对象的new S(...)其中，S是C或C的子类 类似地，对于每一个接口I，有一种类型的t(I)，“I型”，这是一组可从被创建的所有对象的new S(...)其中S一 如果类S是的一个子类C，S型是C型的类似接口的子类型I有一个空值类型，它是空集。 NULL类型是每个类型的子类型。 有一组中的所有对象，这是Object类型。这是一个超类型每一种类型的。 到目前为止，这种表单主义是A型基本上是在一个类或接口，以及亚型的关系基本上是子类/子关系。在平凡是一件好事，语言是可以理解的！但进入仿制药，有型，而像类型的并，交运算.class型不再只类和接口，以及亚型关系更丰富，更难理解。

通常用Eclipse来搭建scala语言编程环境。方法如下：1.下载Scala IDE for Eclipse，然后解压就好了。2.运行Eclipse，右键选择新建scala project,新项目下，右键新建scala object。3.编写第一个demo。4.右键run as --> scala application，控制台打印显示结果。开发环境搭建初步完成。

Scala语言的起源Scala语言源自瑞士洛桑联邦理工学院，由奥德斯基教授2001年带领小组致力于Scala语言、标准库和编译器的开发。这里透露一个小花絮，奥德斯基教授创建Scala语言的一个主要原因是不满Java语言相对复杂的语法。Scala语言的发展现状Scala语言最直接的好处是兼容Java，这就意味着可以无缝使用所有Java的类库和框架。Scala程序会被编译成JVM可执行的字节码。Scala虽然是静态语言，但Scala支持函数式编程和类型推断(Type Inference)，它的哲学是结合面向对象和面向过程并保证代码的简洁。Scala开发工具非常成熟，初学者可以轻松学习ScalaEclipse插件的形式：Scala IDE v2.0已经发布。Scala官网推荐的工具独立IDE：评价最高的Scala IDE，IntelliJ IDEA。社区版已经可以集成Scala插件。Scala语言的发展路线可以总结为两点：第一，Scala语言旨在成为最为普及的JVM语言(这点已经做到)，并不断完善语言特性加强语言的生产力。第二，Scala语言会涉足其他非JVM平台，使得非Java程序员也可以体验Scala的优雅，比如Scala已经可以在.Net上运行。相信Scala语言会在未来给我们不断的惊喜！

http://segmentfault.com/q/1010000000671822

scala编译后的文件是以.class结尾。开头包含类似package声明的scala代码直接在scala命令行用:load指令加载会出错。如果在scala命令行想调用自己在ide写好的类时（大多数情况下你的类会用到外部包，比如spark之类的），有三种方法：将你在ide写好的project在scala下进行编译，之后通过Main调用。打包整个项目为jar，通过scala -classpath加载后，在scala中import进行调用。去掉package声明，并且将依赖包通过scala -classpath加载后，再使用：load 加载你的内容。

Scala挺不错的一个品牌值得去用呢，现在很火的

错误信息说的非常清楚啊，你main函数的声明不对，应该是 public static def main(String[] args)：Unit

scala> val l = List(5,4,3,6,2,1) l: List[Int] = List(5, 4, 3, 6, 2, 1) scala> l.sorted res2: List[Int] = List(1, 2, 3, 4, 5, 6) scala> l.sorted(Ordering.Int.reverse) res3: List[Int] = List(6, 5, 4, 3, 2, 1) 如果你需要特定的排序...

scala> val l = List(5,4,3,6,2,1)l: List[Int] = List(5, 4, 3, 6, 2, 1)scala> l.sortedres2: List[Int] = List(1, 2, 3, 4, 5, 6)scala> l.sorted(Ordering.Int.reverse)res3: List[Int] = List(6, 5, 4, 3, 2, 1)如果你需要特定的排序算法，那么请使用sortWith方法scala> l.sortWith((a,b)=>a>b)res4: List[Int] = List(6, 5, 4, 3, 2, 1)

我来分享下我的观点我是个java程序员，最近对spark的姿势有点学习，无论scala还是java，都是调用的spark的api，也谈不上什么效率问题，没有看到哪篇文章说scala调用spark比java调用快或者效率好之类的，完全看开发者自己的习惯了。另外有一点感觉scala不如java或者python，scala没有自己的web模块，如果要对外提供restful的接口的话，恐怕scala没法做到了

不可能取代的，scala语言是基于java的。虽然scala是用起来比java方便。当时大部分只是将scala做为一个中间组件使用。基本整个项目使用scala为主作为主要开发语言。而且绝大部分情况下java效率是要比scala要好的

我记得是可以的.

用在数据处理的工具比较多。功能编程比迭代程序开销少，更适合云平台计算。

按传统，程序语言分编译语言和解释语言。编译语言要把源程序编译成2进制可执行程序再运行。而解释性语言，即所谓脚本语言，不需预先编译，而可在解释器的解释下，直接解释执行。我不熟悉scala，看上去scala像似 是一种封装式的东西，例如，封装的 java 式的东西 要编译成 bytecode 后执行。 类似 ruby, python 之类的东西也许可以解释执行。scala 好像没有自己的虚拟机，对 scala 的争论 不少。

scala 下划线主要用法：一个类型数据的默认值，譬如var i： Int = _，这里是0。整形为0，浮点为0.0，引用类型为null。第二点，匿名函数的参数，一个匿名函数里第一个下划线代表第一个参数，第二个代表第二个参数第三点，import的通配符第四点，重命名import时隐藏某个名称时的用法第五点，模式匹配中代表会被丢弃的值