la

打成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做springboot开发比较流畅一些 按道理来说根据打包模式 maven sbt gradle来说三种方式都可以 maven 是最简单的 gradle 也比较简单，但是我并没有尝试gradle sbt 其实也还可以 ，你要找到方向基本就直到套路了，经过参考别人的博客，自己搭建了个demo 验证是可以正常使用的，不过maven 版的打jar 使用还是有点问题，我尝试使用多种方式指定主函数还是有问题 两种方式的我都上传到了github上，大家如果想模仿学习 可以git clone 下来泡一泡 https://github.com/mullerhai/scala-springboot-sbt https://github.com/mullerhai/springboot-scala-maven 另外搭建逻辑 大家可以参考这篇博客 google搜出来的 https://afoo.me/posts/2015-07-21-scala-developers-springboot-guide.html 需要主要的，现在的springboot 的版本是2.0.5 release ，之前都是1.× ，不过大同小异， springboot 本身是支持 java 8 kotlin groovy，大家也可以尝试一下 kotlin ，kotlin 以后可能会崛起 说一下打包部署 正常来说我们做java 都会打个jar包 部署到生产环境上， springboot 据说他打包的文件生成方式和普通的 是有差别的，确实，我点击jar 解压看到的和普通有很大差别，所以才会有一个 springboot-maven-plugin 有了这个插件所以 springboot部署成jar包比较简单 但是吧 springboot对sbt 没有特殊支持 也没有这个插件，我耗费三体还是没有实现主就是报这个错 那我们说 springboot sbt scala 部署到底如何实现呢 其实在不打jar 包的情况下还是有多种实现的，比如 git 整个项目到生产环境，直接sbt run 就可以启动整个项目 ，另外还要说一下，springboot如果不启动web ，比如做定时任务，使用sbt-assembly插件 其实打成jar包也是可以使用的 还有一种就是是使用sbt-native-package插件，这个插件超级强大，简直可以用震惊！！！，他娘的，什么都可以打包，就是打不成jar包，rpm docker image zip tar.gz macos dmg win exe,这些他都可以 参考 https://stackoverflow.com/questions/45410630/spring-boot-how-can-i-build-a-runnable-jar-with-sbt I solved the issue by moving to sbt-native-packager plugins.sbt addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.2.0") build.sbt scriptClasspath := Seq("*") mainClass in Compile := Some("com.x.app.XETL") enablePlugins(JavaAppPackaging) Running: packaging sbt universal:stage starting the app: targetuniversalstageinx.bat 这个会生产一个脚本，直接执行这个脚本就可以，不过有时候也会失败，这个需要在 对于 maven scala springboot 项目来说，要想打成jar包运行，必须包含其中的两个maven 插件，缺一个也不行 完整的 在 IDEA 里面新建 SpringBoot 启动配置，运行后启动成功。 在 POM 目录 执行 mvn spring-boot:run 运行项目，启动成功； 线下环境 通过 java -jar jar_name.jar，运行成功； https://stackoverflow.com/questions/38792031/springboot-making-jar-files-no-auto-configuration-classes-found-in-meta-inf https://stackoverflow.com/questions/38792031/springboot-making-jar-files-no-auto-configuration-classes-found-in-meta-inf 用下面命令重新打包试试看 mvn clean package spring-boot:repackage -Dmaven.test.skip 在sbt 中 这两个是罪魁祸首 一引用就出问题

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 这样处理。

cos的命名源于cosplay这个词，翻译成中文是“角色扮演、动漫真人秀”的意思。cosplay起源是一个由Nov.Takahashi提出的，他的这一灵感源于在美国旧金山的国际化妆舞会，并且由于他在日本“MyAnime”杂志上发表的文章中表示了对cosplay的热情，引发了1982~83年日本的cosplay运动。扩展资料：详细内容以现今的cosplay而言，其形式及内容一般是指利用服装、小饰品、道具以及化装来扮演ACG（anime、comic、game）中的角色或是一些日本视觉系乐队以及电影中的某些人物，从这里可以看出在定位上cosplay包含了相当广阔的发挥空间，甚至可以说只要是有cosplayer在的地方，这一领域便绝对就是当今青少年流行文化的主流。cosplay伴随着日本ACG业中GAME业的急速成熟以及视觉系乐团的层出不穷而开始步入正轨，成为一个极具规模的ACG业界的附属文化；日本ACG业界每每举办动漫画展游戏展，各个展位的漫画商或游戏产商都会雇佣一些展台小姐cosplay成自己公司的ACG角色，以吸引观众。借由cosplay可以更接近自己所钟爱的动漫人物，从服装的制作到饰品的搭配，每一套扮相都是coser的心血之作；更重要的是化身成自己所钟爱的人物的一瞬间，那种成就感让每位coser都为之沉迷。

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)

game作为可数名词不可以零冠词以单数形式出现。play只有在和球类运动连用表示玩这类运动的时候才会有play (/) sth的情况。这个就属于一个固定用法。

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

COSPLAY是英文Costume Play的简略写法，日文写作「コスプレ」。一般指利用服装、饰品、道具以及化妆来扮演动漫作品、游戏中的角色。玩COSPLAY的人则一般被称为COSPLAYER。

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

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

Cosplay，是英文Costume Play的缩写，中文译为“角色扮演”，一般是指借由穿着特定服饰来扮演动漫、游戏以及影视中的某些人物，而扮演这些人物的人，我们则称为“Cosplayer”。Cosplay起源于日本，最初只是动漫商家和电玩公司的一种宣传策略，渐渐地，这种活动被动漫迷们所接受，成为一种展现自我独立性的展示活动。更多的人开始认识到，动漫游戏不止能看能玩，更是能够自己扮演的！ coser就是cosplay的人吧

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

使用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语言会在未来给我们不断的惊喜！

现在越来越多的人加入到cosplay的行业中，大家穿着各种奇装异服成为了人群中的亮点。那么你知道cosplay的人叫做什么吗？一起来了解一下吧。 cosplay的人叫做什么 COSPLAY是英文CostumePlay的简写，指利用服装、饰品、道具以及化妆来扮演动漫作品、游戏中以及古代人物的角色。玩COSPLAY的人则一般被称为COSPLAYER，简称为coser。 Cosplay比较狭义的解释是模仿、装扮虚拟世界的角色，也被称为角色扮演。由此，在网络上衍生出了新的含义，往往被用来形容假扮某类人。coser被用来形容假扮某类人的人。 Coser即用语言来COS动漫、游戏等角色，用文字来描述角色的语言、动作、心理，是新起的一门COS艺术，成了动漫爱好者喜欢的一项活动。Cosplay行为的分类（以cosplay的对象来分类）可分为六大类：1、cos动漫类；2、cos游戏类；3、cos明星艺人累；4、cos影视剧人物类；5、cos小说类；6、cos原创角色类。 总的来说，玩COSPLAY的人一般被称为COSPLAYER，简称为coser。你了解了吗？

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挺不错的一个品牌值得去用呢，现在很火的

1、首先，需要先打开游戏《blackpinkthegame》，然后在游戏主界面点击“设置”按钮。2、其次，选择“更新游戏”，系统会自动检查当前版本是否最新，并且进行更新。3、最后，更新完成后，可以关闭游戏设置页面并重新进入游戏，即可享受最新版本的游戏内容。

错误信息说的非常清楚啊，你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时隐藏某个名称时的用法第五点，模式匹配中代表会被丢弃的值

荷兰Scala以开发高水平的跨国商务软件而闻名于世。Scala集成的电子商务管理解决方案，具有财务及资源管理、市场营销管理、供应流程管理、服务及项目流程管理、制造及商务智能管理等方面。Scala的供需链是在当前具有先进管理思想的ERP的基础上又吸收了供需链管理的敏捷制造技术，适用于面向客户的管理模式和企业动态联盟企业。一般企业流程主要是在以下三个部门之间进行的： 主生产计划主生产计划（MasterProductionSchedule）模块可根据销售预测和销售定单对产成品制定一个长期的生产计划，同时企业也可根据自己的实际情况进行手工调整从而基本上满足企业的长期需求。在这里不会对原材料进行具体的需求分析。实际上，MPS是为管理部门提供一种手段，以授权和控制劳动力水平、库存投资、关键资源负荷（草拟生产能力计划）和支持客户服务的现金流量、获利能力及投资目标。同时，MPS程序还可以驱动物料需求计划，使业务计划与日常操作计划互连。除预测信息外，输入MPS的还有库存状态、客户订单和安全库存水平。有了主生产计划，就可以运行物料需求计划（MaterialRequirementsPlanning），它是建立在MRPII理论基础上的。根据主生产计划、库存情况及物料清单，MPR就能把主生产计划转换为生产和采购建议，其中包括前置期、批量大小、车间日程表、计划工程变更和库存状态等。系统不仅给出一个完整的有关整个生产过程的MRP报表，同时对生产车间、工序等做生产能力需求分析（CapacityRequirementsPlanning），它是把MRP程序产生的计划工作量和生产管理模块中发放的加工单加以结合处理，将结果以图形的形式表现出来，企业可通过改变利用率或增加另一班次，模拟每个加工中心改变生产能力后的状况。张先生所做的就是由销售订单模块的报价单功能向他的客户针对自行车生产提供一个详细的报价，只有等客户认为价钱合理，可以成交，并将信息反馈给张先生后，张先生只需在计算机上点击几下，报价单便自动转换为订单，同时张先生不用自己跑到库房查询存货情况，计算机会告诉他是否有足够的存货，是否还需组织生产。如果客户催货比较紧，张先生可通过批次管理制定该货出厂可以是第几批，然后系统会提交一份交货时间表。不过由于自行车生意的确不错，库存明显不够，需要组织生产。这时MPS根据本厂的实际情况会向张先生提供一个长期的生产计划。而MRP则将这个计划转换为具体的生产和采购建议。尤其它能将物料清单分解、细化，比如生产一辆自行车需要轴承、螺丝、螺母、铁丝等等，而这些原材料库存不足，需要采购，至于采购多少，生产多少，MRP会在建议中给出。生产作业在ERP的生产流程中，一旦确立了生产计划，并正确定义了人员、机器和工具等生产资源，Scala的订单计划/生产作业控制（OrderPlanning/Productionactivitycontrol）模块就能帮助企业计划、跟踪并分析加工单。当加工单发出后，构成该产品的物料将被扣留，并自动降低相关工作中心的有效工作能力。 在创建加工单（creatingaworkorder）后，加工单可以包含很多信息，如仓库、优先级、主管、客户和客户订单号、交货地址、附注以及会计核算明细表等。做完前置期计算（Lead），输入有关物料和操作程序的全部数据后，就可以发放加工单（Releasingaworkorder），发出的加工单将为订单预留出必要物料。除加工单的起始日期外，也可以有选择地将所需的物料预留到其它日期。这个过程就是物料预留（Reservationofmarerials）。每一种物料/产品都有一份MRP记录（MRPrecord），表明其在库存余额中的预期走势。此记录除了表明实际库存余额外，还能显示出该物料/产品有关的预期事项，如客户的预定、加工单或预期从生产部门收到的产品等。有了加工单，从库存领取物料以后，便进入了车间控制（ShopFloorControl）。生产设备的瓶颈矛盾一直是制约产量的重要因素。车间控制模块提供有关工具，使资源、原材料和各种组件的物流达到平衡，从而实现对加工单的有效执行。其主要功能包括：给每个加工单制定优先级、排程、打印加工单文件、提供在产品信息、为加工单计划更新加工单状态等。车间人员只要通过查看计算机屏幕，就可知道有关生产变化和特殊操作指令。这其中车间管理模块可以支持多个场地采用无纸生产（Paperlessproduction）的要求，企业可以为每个生产中心或操作者编制屏幕格式，操作者可以检查与每种加工单相关的全部数据，并对主要信息进行监控。而生产统计（Productionstatistics）模块可以提供有关生产过程状况的重要信息，是监控生产过程的一种工具。操作者可以通过这一功能查看生产能力、利用率、前置期、废品等数据，以及上述数据的生成原因等。有了这套软件，生产变得更加按部就班，并且效率高。自行车生产第一线的主管要做的就是在接到张先生的生产建议后将其转为生产加工单，然后根据加工单向仓库领料，不会产生不必要的浪费或材料短缺。由车间控制监控生产的每一个环节。由于全部通过计算机，所以也实现了无纸生产。等客户所需的自行车生产完毕后，入库，根据交货时间及时交货，张先生就可以和客户满意地握手了。 采购在Scala的采购模块（PurchaseOrdersModule）中，具备采购建设功能，企业根据自身情况加以调整，并根据供货商交货期、预算销售额、实际销售额、合理订购数量等，系统自动生成一个详细的采购计划（Purchaseplanning），并能对订单产生出默认的供货商。确定了采购计划后，企业就可以通过采购订单建议程序来自动生成采购订单（PurchaseOrdes），当然企业自己也可以手工输入订单。订单一旦生成，就被编入企业库存计划，并计入采购约定成本。订单打印出来后寄给供应商，供应商就可以发货了。接受货物（receivinggoods）仅以实际交货数量或以发票给出的数量为准。在这两种情况下，采购成本功能都会把库存价值和会计核算内容更新。接受到的货物可被分配到不同的仓库。企业可以通过批次管理（BatchControl）功能规定批号、供货商标记和有效期，以便日后识别。各批次直到通过了质量管理检验才能发出。当然，在采购订单及总分类帐模块中还会存在未交货的订购货物，称之为途中货物（Goodsintransit），对采购订单条目进行简单的查询，可以使企业对收货和发货有一个全面了解。因为Scala软件很好地把采购管理模块与应付分类帐模块良好地结合在一起，因此可以把所有与采购订单相对应的所有发票（Invoices）输入到这个模块中，这样企业就确保了采购成本的计算无误，使管理和授权程序更加简单。输完发票后，系统会生成应付帐款凭证。根据这条供需链，该凭证就会进入财务应付分类帐模块。有了这套软件，采购部主管就可根据张先生提供的采购建议，做适当调整，生成采购订单以组织采购自行车生产所必须的原材料，并入库做好记录。这一切都按照计划进行，所以不存在突然加班的问题。当然采购的发票可以自动生成，也可以人工输入，这些都会转入财务中去，节省了大量的时间。销售订单和计划 　由Scala供需链流程来看，根据市场需求（Marketdemand），企业向客户提交一个报价单，经过双方协商，最终形成一个销售订单反馈到企业。Scala的销售订单模块（SalesOrdermodule）广泛的功能可对销售和分销过程的各个阶段提供支持，由于销售订单模块与库存、采购和生产模块紧密结合，企业能够在销售的同时，制定生产或采购明细表，从而保证及时交货。企业可以通过该模块的报价单（Quotations）为客户提供报价，当客户接受报价时，企业自动把报价单转换为订单，同时报价报表可以提供一份有效的及过期的报价单总汇。在订单（Orders）功能中，由报价单转换过来的不同类型的订单和人工输入的订单，决定了后勤物资的流量。企业可以同时指定交货时间，如果不能在最后期限交货，交货计划系统会发出警告。通过批次管理（BatchControl），企业可以在订单输入时指定特定的批次。考虑库存的整体情况，根据先进先出的原则，系统可以提出一份交货时间表。于是，根据交货建议，Scala的销售定单模块（Salesordermodule）将提供所有必要的文件——订单确认书、取料清单、交货票据和发票等。在装运确认之后，定单就成为开票的依据。所售货物的成本和收入将自动记入Scala的定货分类帐模块（OrderLedgerModule）。库存管理产成品生产出来就要面临入库。从采购到交货，后勤流程全方位管理需要有良好的管理工具。Scala的库存管理（StockControl）模块可以单独使用，但当与采购订单和销售订单模块结合使用时，其功能会更强。库存管理模块的主要优点之一是能提供与每一库存项目相关的广泛数据。再订购水平、安全库存以及缺货报表功能有助于有效地管理库存和减少资金投入。用户可以通过库存管理模块管理货物系列号和物料清单，也能灵活进行批次管理，全面情况跟踪，并能支持广泛的服表程序。在库存项目管理主模块（Stockitemmaster）中可以对每一库存项目输入大量数据。每一库存项目都有自己的单位换算表。Scala按库存项给用户提供几十种价目表、特殊回扣以及定价有效期等。功能广泛的价格及成本计算程序使得对价格及成本的更改更加容易。通过产品的系列号（Serialnumber）和物料清单（BillofMaterial），用户可以灵活进行批次管理。同时，Scala还能进行库存评估（StockValuation），并在用户营业时也能进行全部库存盘点（Stocktaking）工作。 应付分类帐Scala应付分类帐（PurchaseLedger）模块为企业获得供应商信息和付款流程提供全面支持。它能协调采购和授权程序，为用户选择付款方式提供充分的灵活性，简化各种增值税和销售税率的会计核算过程，使法定申报程序变得更为简单。在供应商文件（Thesuppliermasterfile）中包含了用户所选定的供应商的一般信息。由于该模块会与Scala应收分类帐模块相互发生联系，因此可以显示用户应向供应商支付的净差额。在对细节管理不失控的情况下，集中采购功能（Centralizedpurchasingfunctions）能十分方便地进行集中采购。在发票管理（Invoiceprocessing）时，在报表中尚无发票的地方只有得到授权以后，发票才能登入会计核算明细帐。同时多样化的供应商借贷对照表和汇总表可以显示出各种未付的债务状况，并帮助处理预扣赋税。根据每张发票的到期信息，自动付款（Automaticpayments）将按照用户的选择提出付款建议。根据登帐日期或付款日期，系统计算出精确的税额，并定期打印出所需的增值税/销售税表。另外，为了帮助用户对企业财务状况进行评估，该模块还会提供付款预测（Paymentforecasting）。应收分类帐为改进企业现金流量，首先要建立一个有效的应收分类帐。Scala应收分类帐（SalesLeger）模块强大功能不仅能对收款程序起较好的作用，而且还能给销售业务和市场开发打下良好的基础。客户主文件（Thecustomermasterfile）包含企业客户群的一般信息，可帮助用户分析规划市场。在记录发票（Invoicing）时，Scala其它模块中的发票可自动传送到应收分类帐上，也可直接人工入帐。当用户打印发票日记帐时，总分类帐的各科目都将及时更新。同时利用发票合并功能可以实现几张发票的合并。作为应收分类帐中最重要的报表，余额汇总报表（BalanceSummaryReport）中列有于用户相关的全部来往项目。考虑到客户的付款习惯，该系统可为用户提供付款（Payment）预测功能。例外呈报（Exceptionreporting）功能可极大地帮助用户根据自己的要求处理日常付款托收业务。根据某一时期的业务交易额，Scala可及时编制所有必要的增值税表及其它报表，并本地化输出。总分类帐会计核算是每个公司业务的核心。在Scala业务软件中，总分类帐（GeneralLedger）的实用性和灵活性恰恰表明了其它Scala业务模块的多样性。全部模块均具有10构面会计结构，可用于法定的，以及分析性的会计核算。用户可以任意使用一种构面呈报或查询实际或预算数目。把这些用途与Scala内置的多货币、多语种能力相结合，就会发现Scala是当今全球和本地会计核算和业务管理软件中功能最强大的系统之一。尤其值得一提的是，Scala的科目明细帐(AccountScheduleSystem)非常灵活，可充分满足不同地区的需要。帐户余额按科目类别储存，使用户能够在任何给定期间迅速呈报。凭证按日期储存，财政年度可以覆盖多达18个周期。在连续进行下一个周期之前。不必结帐。用户可以呈报从凭证文件中选定的任何凭证。帐户类型中还包含统计帐户，它可以保存法定会计核算中未包括的数据。Scala财务系统使用10种会计构面（Accountstringwithtendimensions），可以为用户的每一家分公司定义法定会计核算体系，并定义不同的呈报层次。当用户需要在几个科目、成本中心或其它会计核算构面之间分摊费用时，Scala的自动分摊（Automaticallocation）提供了99种可能性。当输入一份凭证时，系统将自动执行分摊。当然，任何凭证也可在定期分摊（Periodization）功能下实现待摊费用按若干个周期的分摊，而且可以在下一个财政年度，延续分摊。在进行对帐（Reconciliation）时，系统提供一个手边现金帐簿以核对凭证。通过输入银行凭证文件，用户可以进行人工或自动核对。如果用户在选项中选择固定资产管理（FixedAssetManagement），就可以对用户的固定资产进行全面管理。其中Scala提供了两种方法来针对一种固定资产进行折旧或重新估价计算。在生产流程中，当产成品入库后可过度到财务模块。系统可以自动计算出产成品成本（Costing），一般以标准成本来控制产成本。同时计算出实际成本（ActuallyCost），并通过统计模块对标准成本和实际成本的差异进行分析。它针对每个加工单（必须是关闭加工单为准），分析出物料的差异、人工的差异，得出人工的成本、料的成本及其它制造费用的成本。由于企业可以通过销售定单知道产品价格，因此知道了成本后，企业就可以知道利润。在差异分析完成后，进行差异分摊（VarianceAllocate），最后就可以汇入总帐。 另外，在总分类帐系统中，Scala还提供了红冲凭证、冲转凭证等，而报表模块（ReportofGeneralLedger）具有的各种财务报表（BalanceSheet,ProfitStatment）功能在财务系统中也极为重要，报表中列有与此有关的全部项目，通过对十个会计构面及其它特定标准的选择，可迅速提取相关信息，让用户从繁琐的报表作业中解脱出来。以上应付分类帐（PurchaseLedger）、应收分类帐（SalesLeger）、总分类帐（GeneralLedger）可简称PL、SL、GL，它们有着十分密切的联系。PL能协调采购和授权程序，为获得供应商信息和选择付款方式提供了充分的灵活性。而SL提供了实现财务和业务目标的有力工具，可全面记录货币明细和帐面价值，同时有助于分析和规划市场。最后，PL和SL都将在功能强大的GL中得以汇总和体现。

下面是一系列对Scala中的Lists、Array进行排序的例子，数据结构的定义如下：// data structures working withval s = List( "a", "d", "F", "B", "e")val n = List(3, 7, 2, 1, 5)val m = Map( -2 -> 5, 2 -> 6, 5 -> 9, 1 -> 2, 0 -> -16, -1 -> -4)利用 Scala 内置的sorted方法进行排序s.sortedres0: List = List(B, F, a, d, e)n.sortedres1: List[Int] = List(1, 2, 3, 5, 7)为什么我们这里不对m也排序呢？这是因为map对象没有sorted方法！大小写敏感搜索我们可以用 Scala 中的sortWith来自定义我们的对大小写敏感的排序函数。代码如下：/* sort alphabetical and ignoring case */def compfn1(e1: String, e2: String) = (e1 compareToIgnoreCase e2) < 0/* sort alphabetical and ignoring case: alternate */def compfn2(e1: String, e2: String) = (e1.toLowerCase < e2.toLowerCase)s.sortWith(compfn1)res2: List = List(a, B, d, e, F)s.sortWith(compfn2)res3: List = List(a, B, d, e, F)/* Or you can do so using anonymous function (Thanks Rahul) */s.sortWith(_.toLowerCase < _.toLowerCase)res4: List = List(a, B, d, e, F)如何对Map中的Key或Value进行排序其实很简单代码如下：// sort by key can use sortedm.toList.sorted foreach { case (key, value) => println(key + " = " + value)}-2 = 5-1 = -40 = -161 = 22 = 65 = 9// sort by valuem.toList sortBy ( _._2 ) foreach { case (key, value) => println(key + " = " + value)}0 = -16-1 = -41 = 2-2 = 52 = 65 = 9对源数据排序上面的排序并不对原始的数据产生影响，排序的结果被存储到别的变量中，如果你的元素类型是数组，那么你还可以对数组本身进行排序，如下：scala> val a = Array(2,6,1,9,3,2,1,-23)a: Array[Int] = Array(2, 6, 1, 9, 3, 2, 1, -23)scala> scala.util.Sorting.quickSort(a)scala> a.mkString(",")res24: String = -23,1,1,2,2,3,6,9可以看到a数组内部的数据已经排好序了。如果你对上面的n进行排序，发现会报出如下的错误：scala> scala.util.Sorting.quickSort(n)<console>:14: error: overloaded method value quickSort with alternatives: (a: Array[Float])Unit <and> (a: Array[Int])Unit <and> [K](a: Array[K])(implicit evidence$1: scala.math.Ordering[K])Unit <and> (a: Array[Double])Unit cannot be applied to (List[Int]) scala.util.Sorting.quickSort(n)从上面的报错信息我们可以看出，只有Array才可以用scala.util.Sorting.quickSort方法。在scala.util.Sorting下面还有个stableSort函数，它可以对所有Seq进行排序，返回的结果为Array。比如我们对上面的n进行排序：scala> scala.util.Sorting.stableSort(n)res35: Array[Int] = Array(1, 2, 3, 5, 7)而对Array排序返回Unitscala> val a = Array(2,6,1,9,3,2,1,-23)a: Array[Int] = Array(2, 6, 1, 9, 3, 2, 1, -23)scala> scala.util.Sorting.stableSort(a)scala> a.mkString(",")res39: String = -23,1,1,2,2,3,6,9

scala中执行外部命令(scala.sys.process) 发表回复 目前 scala.sys.process 已经封装的足够简单。参考： http://itang.iteye.com/blog/1126777 scala> import scala.sys.process._ // 只需在结尾用!号，就表示执行外部命令 scala> val list = "ls -l" ! 还可以重定向，甚至可以在java对象与命令之间： scala> new java.net.URL( " http://www.iteye.com ") #> new java.io.File("/tmp/iteye.html") ! 注意，重定向必须用 new java.io.File("") 封装，否则会当作命令，比如 scala> "ls" #> "/tmp/a" ! 将会出错，必须 scala> "ls" #> new java.io.File("/tmp/a") ! 管道的用法： scala> val list = "ls -l" #| "grep P" ! 不能在命令表达式中直接用管道， 比如 "ls | grep XXX" 这样不灵，必须用 #| 声明。 更多参考： https://github.com/harrah/xsbt/wiki/Process //2012.6.15 要把System.getProperties 里的内容重定向到一个文件如何实现？ 下面的方法不行，它会将第一个表达式的结果当作命令来执行 scala> System.getProperties.toString #> new java.io.File("/tmp/env") ! 直接将文字重定向到一个文件，我现在还不知道怎么做。只能变通用写文件的啰嗦方式。

在Scala中可以通过 == 判断字符串实例是否相等，eg. 在此，特别感谢 Z尽际 的提醒，增加了val s4 = Array("H", "e", "l", "l", "o").mkString("") 这个例子，s1，s2，s3编译之后会变成同一个对象的引用，比较字符串相等没有意义，增加s4更能说明上面的结论； == 在AnyRef中是一个函数，其定义如下： 其中 if (this eq null) that.asInstanceOf[AnyRef] eq null 会判断当前String对象是否为空，所以null也可以使用 == 来比较，并且两个null字符串比较会得到true的结果也不会抛出 NullPointerException ； eg. 但是，如果使用null字符串做一些函数操作，则会抛出 NullPointerException ，eg. 如果要忽略大小写比较字符串，可以使用java的equalsIgnoreCase方法，eg. <font color=#0099ff size=7 face="黑体">33[1q Scala不推荐使用null，可以使用Option代替 </font> <font color=red>Markdwon测试</font> "33[34mdanran33[0m" danran蓝色显示

scala是一门基于jvm的编程语言sbt是scala的一个构建工具，类似于maven，可以完成引入依赖库，编译，测试，打包，发布等工作ideaLU是一个编程软件，可以方便scala的开发，比如有好的代码提示等等。编程软件可以包含sbt的插件，当然sbt也是可以单独使用的

知名的社团像　白日公馆，花街，上海镜之人形，上海COSING，杭州304动漫社，杭州99度动漫，北京残血罗刹国，北京WearetheD，传媒那兰之候，广州的美萌……国内知名COSERKENN，灵新儿，AKASHI，ASATO，YOUNG，天狼，七叶，阿紫，十夜，小酷，CLEVER酷，刺猬，KETE，小梦，CASO，SOUJI，小小白，九泉，妖十一，猫空逝，ELFZERO，行歌宫主，飞宇，兰雅，绯村剑心，美歪，岚陵萧萧声……

有必要！就算你觉得以后工作中不会用到他，那学一学也还是很有用的。scala里沉淀着计算机学科理论的结晶，对了解一些理论知识很有帮助。会Scala对接触spring，spark等框架也有很大的帮助

COSER有很多喔！男的：黄山、小梦、丁伦、河童、天狼女的：木叶乌鸦、小美、水妖、美歪都是美人啊！！！XD大爱~~~~

奥德斯基（Martin Odersky），Scala语言的创始者。他是瑞士洛桑联邦理工学院（EPFL）教授，从2001年起他就带领小组致力于Scala语言、标准库和编译器的开发。他还是Java泛型的合作设计者及当前javac参考编译器的原作者。LexSpoon在EPFL为Scala工作了两年，现为Google软件工程师。Bill Venners Artima的总裁。撰写了许多关于、Java的文章，是《深入Java虚拟机》的作者，以及Scala Test测试框架的设计者。

scala 编写wordCount加载文件 scala> var f1=sc.textFile("/tmp/dataTest/followers.txt")scala> f1.flatMap(x=>x.split("-")).map((_,1)).collect //每个数字以"-"分割，并数字为key，给每个key赋值1res10: Array[(String, Int)] = Array((2,1), (1,1), (4,1), (1,1), (1,1), (2,1), (6,1), (3,1), (7,1), (3,1), (7,1), (6,1), (6,1), (7,1), (3,1), (7,1)reduceByKey(_+_).collect 将key相同元素合并（4出现一次，7出现4次，6出现3次，2出现2次，3出现3次，1出现3次）scala> f1.flatMap(x=>x.split("-")).map((_,1)).reduceByKey(_+_).collectres12: Array[(String, Int)] = Array((4,1), (7,4), (6,3), (2,2), (3,3), (1,3))这个方法也是同样效果scala> f1.flatMap(x=>x.split("-")).map((_,1)).reduceByKey((x,y)=>x+y).collectres18: Array[(String, Int)] = Array((4,1), (7,4), (6,3), (2,2), (3,3), (1,3))对出现的次数进行排序sortByKeyscala> var resText=f1.flatMap(x=>x.split("-")).map((_,1)).reduceByKey(_+_).map(x=>(x._2,x._1)).sortByKey(false).map(x=>(x._2,x._1))resText: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[39] at map at <console>:26

datatime.now.tostring()..........

《Scala编程思想第二版》百度网盘pdf最新全集下载:链接：https://pan.baidu.com/s/1evpCr8Rh1j49vF18Y7y0Pg?pwd=blt0 提取码：blt0简介：《Scala编程思想（原书第2版）》介绍了Scala的基础特性，采用短小精悍的“原子”解构Scala语言的元素和方法。一个“原子”即为一个小型知识点，通过代码示例引导读者逐步领悟Scala的要义

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

可以使用Scala的println函数输出姓名和学号，代码如下：```val name = "张三"val id = "12345678"println("姓名：" + name)println("学号：" + id)```注：在实际使用中，变量 name 和 id 的值应该根据具体情况进行修改。

区别 很大 Scala 是面向对象 面向函数式编程，多线程控制起来方便，可以把传递算法JAVA 是面向对象编程 多线程控制麻烦 不能传递算法

scala是意大利的品牌。

度受一下，乃就知道=u=

scala在web: playframework/lift/ scala actor实现: Akkascala在大数据: sparkscala和java可以一起用

如果是闪5的话，在游戏一开始的界面里（未点击开始游戏时），滑鼠点选“帮助”，向下翻页，直至出现输入秘籍的框框，在其中输入密码，点击确认，正确了就可以在游戏中点选滑鼠右键使用秘籍。（PS：不要留空格！）瞬间移动：Andy Law is a super hero! 加钱：I go to bbplayer.net everyday! 加血：I am Andy Law"s fans! 加同伴经验值：Andy Law is a super great game maker!闪4的话，就需要在正在游戏是输入，比如已经进入第一关的游戏内，在键盘中点击字母“M”，出现设置界面，点选“输入密码”，输入即可。（PS：不要留空格！）瞬移：I love crazy flasher forever! 生命+200：I love Andy Law forever! 金钱+5000：I love bbplayer.net forever!

下面我来谈谈我的看法。首先Scala现在是太阳系中唯一比c++更复杂的语言。但是和c++不同的是，他学了c++，你只是对代数有一点了解，你不知道类型系统的理论，你不知道。在可操作性方面，scala和c++一样通用，只要您完全了解它们，任何东西都可以封装。那为什么不学习scala呢?其次使用Java库，开发比Java更简单、更快。速度比python。比lisp更好的对象支持。简单地解决一些更繁琐的函数，比如字符串解析和XML。除非绝对必要，否则不要使用高级功能。写程序不是写作文，不需要炫的技巧。含蓄是为别人写书的好方法，也是让自己陷入麻烦的好方法。我不认为这很有意义。让它成为一个好的Java+Lisp。最后Scala的原因是基于两个因素的考虑:生态环境的发展和工具的便利性。公司原是一个Java部门，生态环境好，所以基本平台已经确定。至于工具，由于Java语言的不令人满意的表达，特别是标准库对集合操作的支持，您需要考虑JVM上的其他语言。Scala是OOP和FP的混合，这有助于团队转换。强表达能力(如类型推理、FP等)有助于提高开发效率;内置良好的集合操作库;这就是我的选择。Scala的优点是编译器保证可以尽早发现一些错误，而不是像Clojure那样从头到尾地反复使用。小结希望我的回答能够帮到你。

角色扮演

以前在这个版块也答过关于Scala的问题，但那更多的是知识普及，而没有谈Scala是什么，做什么，以及有怎样的特点。Scala可怕的地方在于人人都能对它说上一二，但是不一定每个人都能明白。查看这个版块的帖子，有人把它当做Java的延伸版（一个UPenn宾大的学生Justin Kim ——此人目前在沃顿混得风生水起，当着我的面说Scala是在JVM上的脚本语言），有人把它当做JVM上的C++，有人觉得这是面对对象语言和函数语言的简单混合，有人觉得这就是Haskell，而且也还不如Haskell强。对Scala的偏见（或者是错误的见地）达到了很高的地步，Martin Odersky马丁·奥德斯基（Scala的发明者，EPFL教授）在今年夏天的Scala Day旧金山大会上发出了这张著名的玩笑照片：gt;这个图片上的翻译是：“Scala唯一的作用是将人引向Haskell”（原谅我没法完全直译）。马丁·奥德斯基以此作为一个笑话，说他该把Scala改一下名字，叫做Hascalator，还请人设计了一个Logo。不同的语言有不同的特点，同时也带来不同的优势。如果不能理解Scala的特点，就不可能知道如何运用Scala，以及发挥其最大的优势。一些语言有很显而易见的优势，也很容易理解，比如Python，Python的哲学（Zen of Python PEP 20 -- The Zen of Python），我很早的时候曾经觉得有道理，尤其是One way to do it（一种方法做一件事情），理由是对任何任务，虽然可以采用很多方法，但总有最好的一种方法，通过在语言或者哲学层面这样定义后，能简化程序员的任务，从而达到提高效率的方法。但经过一段时间的思考后，我突然发现Python其实并不是“一种方法做一件事”的哲学，而是“一种方法做一百万件事情”的哲学：极其有限的数据结构（只有四个: List, Tuple, Dictionary, Sets），以及不能查看时间复杂度的访问方法，比如鼓励人们使用for x in list。这种处理方式能达到Python最初的打算：发明一种每个人都能使用的简易语言，但是对于追求速度和效率的程序员而言，这几乎是略带噩梦性质的。当然，这不是说Python很慢，通过各种优化（比如NumPy/SciPy中的），以及Cython这样的将Python直接翻译为C/C++语言又重新通过C_Module方式读回Python环境的编译器，性能可以得到不少提升，但是仍旧，Python并不追求快。再举一个语言的例子：Java。Java的特性或者优势何在？Java的第一个优势在于它是第一个系统提供模块化（module）设计的语言（在此之前有Smalltalk存在，该货是OOP的鼻祖）。在Java之前，炒程序员鱿鱼是很困难的事情，那些C/C++程序员，以及而且尤其是那些Lisp程序员，一旦炒掉他们，新来的人没有十天半个月，甚至半年，是不可能搞懂前任人士的代码的。每个人的代码有自己的逻辑，自己的思路，写上个数万行任谁来看都头疼。这也是为什么Paul Graham保罗·格雷厄姆（写了《黑客与画家》）讲他给雅虎做了一个用Lisp写成的在线商店的案例，在他离开后，雅虎根本没法维护他写的代码，因为数万行Lisp没人能弄得很清楚。Java的模块化，给企业、大公司带来了第一道曙光，模块化之后，这些公司不再给程序员一整个任务，而是一大块任务的一小块。接口一定义，虚拟类一定义，换谁上都可以，管你是保罗·格雷厄姆这样的明星程序员，还是一个新来的大学生，程序员不听话就直接开除，反正模块化之后，开除程序员的成本大大降低，这也是为什么谷歌、甲骨文（这货最后收购了Java）一类的公司大规模的推崇Java，还一度提出了模块化人事管理的理念（把人当模块化的积木一样随时移进移出）。过度企业化后，这延展出了Java的第二个特性，束缚手脚。保罗·格雷厄姆在《黑客与画家》中写道，Java属于B&D（捆绑与束缚）类型的语言。为何束缚手脚？因为要让新手和明星程序员写出类似质量的代码，尽可能的抹消人的才华对程序的影响。不同于C/C++，老手和新手写出的Java代码不会有上百倍的耗时差距。但同样也导致了Java的一个弱点——不容易优化。很多优化Java代码的程序员必须要对JVM（虚拟机）进行优化，实际上增大了很多任务难度。通过Python和Java这两个语言的优缺点，返回来看Scala，就能瞬间明白Scala的定位了。首先，Scala不把程序员当傻子。当马丁·奥德斯基宣布Scala 2.12将要简化语法，推出Scala "Don Giovanni"项目的时候，在视频中说的很清楚：“Scala现在是为聪明人创造的，以后也是为聪明人服务的。”所以不同于Python让程序员用一种方法做所有事情，Scala提供一整套工具，让程序员自由选择，无论是mutable数据结构，immutable数据结构，并行（parallel）数据结构。然后在这些选择中，Scala再针对他们进行算法层面的特殊优化。Scala相信程序员的聪明才智，让程序员自行选择合适的结构，以针对变化万千的任务需求，这点是Scala做得极好的地方。再者，有人会说immutable数据结构占用内存，或者速度很慢。这是真的，但这不是Scala的错，而是这些结构就是这样定义的。这里讲的是Scala集合的运行速度，是一个来自Goldman Sachs的程序员讲他们为Java写的集合库（GSCollection）速度和内存消耗，但同时比较了gs-collection（goldmansachs/gs-collections · GitHub），Java，和Scala库的速度。最后Scala的可变集合mutable原生库完爆Java，和gs-collection基本持平。Scala的第二个优势，相较于Java而言，则是相信程序员的优化能力。在Scala with Style讲话中（），马丁·奥德斯基说：“很多程序员会告诉我，他们一般会重构他们的Scala代码两三次，甚至三四次。”这听起来似乎非常的没有效率，但Scala就是这样的语言，每一次重构，代码的性能或者是可读性都会有极高的提升。之前就有人提到过，Scala新手和老手写出来的代码完全会呈现两种不同的风格，甚至新人根本不能读懂有经验的Scala程序员所写的代码，有人于是戏称：“太好了，这样的话我们部门的实习生就不能乱碰我写的代码啦！”但其实不仅风格不同，执行效率差距也一定是巨大的。Scala提供一整套工具，但是要明白什么时候用拿一种工具，哪些算法能够随意调用，哪些算法不能，这一定要依靠经验、研究和学习以及对源代码的理解才能得知。最简单的例子，Scala的foreach()方法是高度优化过了的（尤其针对Range结构和Vector结构），但是fold()就不一定了。或者当受到诱惑想用zipWithIndex()的时候，一定要明白这是两次循环，最好改用Vector(...).indices.foreach()的方法，或者用.view来推迟执行。像这样的地方还有很多。所以在这个层面上来讲，简直和C++非常的相似。从另外一个层面来讲，不仅仅是要理解语言层面的优化，Scala作为一个社区而言，是非常追求运行速度的。Ruby社区就完全不同了，Ruby曾经是推特的主要语言。推特的团队找到了Ruby团队，说，你们能不能让Ruby运行的快一点，我们有这个这个和这个建议。Ruby直接把这些建议拒绝了，因为它们会增加语言复杂度，让Ruby不能继续做一个“fun”（好玩）的语言。而Python直接就立志做一个“Simple”（简单）的语言了。于是推特只好将后台换做Scala和Java的结合。有一位在推特工作的知乎友人在我的一个回答下留言说推特换用Scala后，TypeSafe（Scala的母公司）还送去了一个蛋糕。为了追求速度，Scala社区是绝对不会管所谓的“简单”或者是“好玩”，怎样有效率就怎样弄。与其专注于JVM的改进，Scala社区大部分在编译器上下功夫，比如很著名的Miniboxing（Miniboxing），这是一个编译器增进器。Miniboxing做的是什么呢？只做一件事：防止auto-boxing和auto-unboxing。所有的泛型，尤其是原生类泛型（Primitive Types），诸如Int、Double等等，在进行各种操作的时候会自动取出和装回它们所属的类中去——这个我解释的不太好，但是可以看这里（Java 自动装箱与拆箱(Autoboxing and unboxing)）。Miniboxing这样的插件可以让所有的原生类泛型再也不用自动装拆箱，从而将Scala的运行速度提升1.5倍到22倍（）。当然这样的东西可不是白来的，这是马丁·奥德斯基的PhD博士学生做的一个研究项目，然后为OOPSLA写了一篇论文（），所以怪不得这玩意Scala可以有，但其他语言想要有都没有。另一个Scala的很大优势就是所谓的Macro——宏。宏本身作为元编程而言，其实和运行速度是没有什么太大关系的，反而，因为对反射（Reflect）的利用，可能会影响到速度。但Scala社区对宏的理解显然和最初的设计理念有偏差。因为Scala本身是没有传统意义的循环的（for-loop），所以很多时候循环必须利用while或者foreach。但是部分追求效率的Scala程序员们利用宏为Scala写了一个传统循环，叫做cfor，被收录在Spire（non/spire · GitHub）数学计算库中。cfor的写法如下：import spire.syntax.cfor._// print numbers 1 through 10cfor(0)(_ < 10, _ + 1) { i =>println(i)}而这玩意运行效率如何呢？文章中做了一次测评，将cfor和zip写的一个算法作比较——在公布结果之前，我想说的是，zip并不是一个高度优化的方法，所以本身就慢很多，cfor用了26.1毫秒运行，zip方法用了7.4 秒运行，这几乎是284倍的速度差距。通过这两点，Scala的一个优势就很明显了——多样化。当需要写简单的代码，像Python一样当脚本语言使用时，Scala提供大量的原生方法和数据结构，可以很轻松的写出比较复杂的操作。但当需要速度的时候，又可以通过重构来获取数十倍或者上百倍的速度提升。通过Miniboxing一类的编译器增强器，Scala在某些操作的速度是必定超过Java的。Scala的第二个优势就是——一帮勤劳勇敢的PhD博士生。二十一世纪的程序语言和二十世纪的程序语言已经不能比拟了。那个年代的普通人（甚至是学生）还能任意发明一下语言，稍微把编译器优化几次就能上得了厅堂（比如那一大堆Lisp方言），到了这个年代，编译技术已经达到了很复杂的程度（虚拟机技术也是如此），优化和语义理解，程序语言的定义与延展，再也不是随便任何人都能搞定的工作了。作为编程语言方面的教授，马丁·奥德斯基不断的将最前沿的学术界成果转移到Scala这个语言中，还让他的博士学生发展出新的，让语言运行得更快的方法，这些都是其他语言，尤其是Python、Ruby、甚至是Go都没有的优势。当然，说了这么多，总会有人说了，Scala如果像C++一样难，又追求速度的话，为什么不直接去学C++，原因很简单——现在有很多在JVM上面写成的软件啊！大家又不是Haskell程序员，压根不打算一切自己写呐。

scala中的自增运算是一般它会有一个上标和下标的，下标表示开始 加 的起始数，上标表示终止数。不过，第一种写法更好，因为它可以用来初始化一个val。而在第二种写法当中，s必须是var。Java和C++有一个?:操作符用于同样目的。如下表达式：x > 0 ? 1 : -1 // Java或C++。等同于Scala表达式 if (x > 0) 1 else u22121。不过，你不能在?:表达式中插入语句。Scala的if/else将在Java和C++中分开的两个语法结构if/else和?:结合在了一起。scala技巧：1、scala不要陷入C++一样的、不断膨胀的问题里，留下太多的选择，且没有清晰的最佳实践。这导致每个人都在选择不同的子集。要提供适应的指导。2、scala记住，反对不良的设计功能与增加新功能同等重要——这很残酷。3、scala考虑拆分语言为生产环境创建可行的标准。为学术世界节省成本是一个明智的选择。迎合企业的需要，获得更大的采用。4、scala库的编写者应该看看Java API，确认是否应该有功能调用或结构化功能，为了更好的阅读。不要为了流动性在跳跃太大来与Ruby竞争。

我想大部分应用开发程序员，最关键是看有什么类库合适的方便特定领域的应用开发。就像ruby有rails做web开发，你可以去论证ruby优缺点，但实际上应用开发效率提升很大程度上依靠类库。现在Spark是大数据领域的杀手级应用框架，BAT，我们现在几个领域巨头的客户(有保密协议不方便透露)都全面使用Spark了，这个时候再谈Scala适不适合大数据开发其实意义不大。因为大家比的不只是编程语言，而是构建在这个编程语言之上的类库、社区和生态圈(包括文档和数据、衍生类库、商业技术支持、成熟产品等等)。那么反过来问，为什么Spark会选择Scala可能更有意义一点。Spark主创Matei在不同场合回答两次这个问题，思考的点稍微不一样，但重点是一样的，很适合回答题主的问题。总结来说最主要有三点：1.API能做得优雅;这是框架设计师第一个要考虑的问题，框架的用户是应用开发程序员，API是否优雅直接影响用户体验。2.能融合到Hadoop生态圈，要用JVM语言;Hadoop现在是大数据事实标准，Spark并不是要取代Hadoop，而是要完善Hadoop生态。JVM语言大部分可能会想到Java，但Java做出来的API太丑，或者想实现一个优雅的API太费劲。3.速度要快;Scala是静态编译的，所以和JRuby,Groovy比起来速度会快很多，非常接近Java。1.Scala的基准性能很接近Java，但确实没有Java好。但很多任务的单次执行的，性能损失在毫秒级不是什么问题；2.在大数据计算次数很多的情况下，我们全部写成命令式，而且还要考虑GC，JIT等基于JVM特性的优化。