在eclipse 中运行scala程序 报错如下：

　　Scala编程语言近来抓住了很多开发者的眼球 如果你粗略浏览Scala的网站 你会觉得Scala是一种纯粹的面向对象编程语言 而又无缝地结合了命令式和函数式的编程风格 Christopher Diggins认为 　　不太久之前编程语言还可以毫无疑义地归类成 命令式 或者 函数式 Scala代表了一个新的语言品种 它抹平了这些人为划分的界限 　　根据David Rupp在博客中的说法 Scala可能是下下一代Java 这么高的评价让人不禁想看看它到底是什么东西 　　Scala有几项关键特性表明了它的面向对象的本质 例如 Scala中的每个值都是一个对象 包括基本数据类型（即布尔值 数字等）在内 连函数也是对象 另外 类可以被子类化 而且Scala还提供了基于mixin的组合（mixin based position） 　　与只支持单继承的语言相比 Scala具有更广泛意义上的类重用 Scala允许定义新类的时候重用 一个类中新增的成员定义（即相较于其父类的差异之处） Scala称之为mixin类组合 　　Scala还包含了若干函数式语言的关键概念 包括高阶函数（Higher Order Function） 局部套用（Currying） 嵌套函数（Nested Function） 序列解读（Sequence Comprehensions）等等 　　Scala是静态类型的 这就允许它提供泛型类 内部类 甚至多态方法（Polymorphic Method） 另外值得一提的是 Scala被特意设计成能够与Java和 NET互操作 Scala当前版本还不能在 NET上运行（虽然上一版可以） 但按照计划将来可以在 NET上运行 　　Scala可以与Java互操作 它用scalac这个编译器把源文件编译成Java的class文件（即在JVM上运行的字节码） 你可以从Scala中调用所有的Java类库 也同样可以从Java应用程序中调用Scala的代码 用David Rupp的话来说 　　它也可以访问现存的数之不尽的Java类库 这让（潜在地）迁移到Scala更加容易 　　这让Scala得以使用为Java 或者 编写的巨量的Java类库和框架 Scala会经常性地针对这几个版本的Java进行测试 Scala可能也可以在更早版本的Java上运行 但没有经过正式的测试 Scala以BSD许可发布 并且数年前就已经被认为相当稳定了 　　说了这么多 我们还没有回答一个问题 为什么我要使用Scala？ Scala的设计始终贯穿着一个理念 　　创造一种更好地支持组件的语言 （《The Scala Programming Language》 Donna Malayeri） 　　也就是说软件应该由可重用的部件构造而成 Scala旨在提供一种编程语言 能够统一和一般化分别来自面向对象和函数式两种不同风格的关键概念 　　藉著这个目标与设计 Scala得以提供一些出众的特性 包括 　　* 面向对象风格 　　* 函数式风格 　　* 更高层的并发模型 　　Scala把Erlang风格的基于actor的并发带进了JVM 开发者现在可以利用Scala的actor模型在JVM上设计具伸缩性的并发应用程序 它会自动获得多核心处理器带来的优势 而不必依照复杂的Java线程模型来编写程序 　　* 轻量级的函数语法 　　o 高阶 　　o 嵌套 　　o 局部套用（Currying） 　　o 匿名 　　* 与XML集成 　　o 可在Scala程序中直接书写XML 　　o 可将XML转换成Scala类 　　* 与Java无缝地互操作 　　Scala的风格和特性已经吸引了大量的开发者 比如Debasish Ghosh就觉得 　　我已经把玩了Scala好一阵子 可以说我绝对享受这个语言的创新之处 lishixinzhi/Article/program/Java/hx/201311/26873

用Scala计算1到100的和 在Scala中，计算1到100的和可以使用for循环和sum函数实现。首先，我们需要定义一个包含1到100的整数序列：val numbers = 1 to 100然后，我们可以使用sum函数计算序列中所有数字的和：val sum = numbers.sum现在，变量sum的值为5050，即1到100所有整数的和。Scala中的for循环 在Scala中，for循环可以用于迭代序列、集合和数组等类型。通常情况下，for循环与一些函数和操作符结合使用，能够实现功能强大的数据处理和转换操作。例如，下面的代码演示了如何使用for循环和过滤操作筛选出1到100中的偶数：val evenNumbers = for {num <- numbersif num % 2 == 0} yield num在这个示例中，我们使用yield关键字创建了一个新的序列evenNumbers，其中包含1到100中的所有偶数。Scala中的函数式编程 Scala是一门函数式编程语言，因此在Scala中，函数是一等公民。这意味着函数可以用作参数、返回值和变量的值。在函数式编程中，函数通常是纯函数，即不会修改任何状态或者产生任何副作用。纯函数更易于理解、测试和维护，也更容易并行化和优化。以下代码演示了如何使用Scala的高阶函数map和reduce来计算1到100中所有数字的平方和：val squares = numbers.map(n => n * n)val sumOfSquares = squares.reduce((a, b) => a + b)在这个示例中，我们使用map函数将序列中的每个元素映射为其平方值，并使用reduce函数将平方值序列中的所有数字相加。Scala中的模式匹配 Scala中的模式匹配是一种强大的语法特性，用于匹配值和类型的模式，并且可以将匹配结果绑定到变量中。以下代码演示了如何使用模式匹配来从一个字符串中提取其第一个字符：val str = "Hello, world!"val firstChar = str match {case s: String if s.length > 0 => s(0)case _ => "?"}在这个示例中，我们首先使用match关键字匹配字符串str的类型和长度。如果字符串非空，则将其第一个字符绑定到变量s中。否则，将变量赋值为问号字符。Scala中的类型推导 Scala中的类型推导是一种在编译时自动推断变量类型的机制。类型推导使Scala代码更加简洁和易于阅读，并且能够减少类型错误。以下代码演示了如何使用类型推导来定义函数柯里化（currying）：def add(x: Int)(y: Int) = x + yval add5 = add(5) _在这个示例中，我们首先定义了一个柯里化（currying）函数add，它将一个整数作为第一个参数x，另一个整数作为第二个参数y，并返回它们的和。然后，我们使用类型推导定义了一个新的函数add5，它是函数add的部分应用，其中第一个参数x的值被固定为5，返回值为一个新的函数对象。Scala中的并发编程 Scala中的并发编程通常使用Actor模型实现。Actor是一个能够处理消息的独立计算单元，能够并发执行、保持状态，并且不会与其他Actor产生互斥访问。以下代码演示了如何使用Akka库创建一个Actor，并向其发送一条消息：import akka.actor.{Actor, ActorSystem, Props}case class Greeting(message: String)class HelloActor extends Actor {def receive = {case Greeting(msg) => println(s"Received message: $msg")}}val system = ActorSystem("HelloSystem")val helloActor = system.actorOf(Props[HelloActor], "helloActor")helloActor ! Greeting("Hello, world!")在这个示例中，我们首先定义了一个包含一个消息的Actor类HelloActor。HelloActor类重写了receive方法，该方法用于处理Actor接收到的消息。然后，我们使用Akka库创建了一个ActorSystem，并使用Props对象创建了一个HelloActor实例。最后，我们向HelloActor实例发送了一条Greeting消息。结论 Scala是一门功能强大、灵活和易于学习的编程语言。它支持函数式编程、面向对象编程、并发编程和类型推导等特性，能够提高开发效率、减少代码量、同时保持代码的可读性和可维护性。在本文中，我们介绍了使用Scala计算1到100的和、Scala中的for循环、函数式编程、模式匹配和并发编程等方面的示例代码。我们希望这些示例能够帮助您更好地理解Scala的强大功能，并且为您的Scala开发项目提供有用的参考。

Scala的特性1.面向对象特性Scala是一种纯面向对象的语言，每一个值都是对象。对象的数据类型以及行为由类和特征（Trait）描述。类抽象机制的扩展有两种途径。一种途径是子类继承，另一种途径是灵活的混入（Mixin）机制。这两种途径能避免多重继承的种种问题。2.函数式编程Scala也是一种函数式语言，其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。Scala的CaseClass及其内置的模式匹配相当于函数式编程语言中常用的代数类型（AlgebraicType）。更进一步，程序员可以利用Scala的模式匹配，编写类似正则表达式的代码处理XML数据。在这些情形中，顺序容器的推导式（comprehension）功能对编写公式化查询非常有用。由于JVM不支持尾部递归，Scala也不能完全支持尾部递归优化。不过，在简单的情况下，Scala编译器可以把尾部递归优化成循环。4.静态类型Scala是具备类型系统，通过编译时的检查，保证代码的安全性和一致性。类型系统具体支持以下特性：泛型类，型变注释（VarianceAnnotation），类型继承结构的上限和下限，把类别和抽象类型作为对象成员，复合类型，引用自己时显式指定类型，视图，多态方法。5.扩展性Scala的设计承认一个事实，即在实践中，某个领域特定的应用程序开发往往需要特定于该领域的语言扩展。Scala提供了许多独特的语言机制，可以以库的形式轻易无缝添加新的语言结构：任何方法可用作前缀或后缀操作符，可以根据预期类型自动构造闭包。联合使用以上两个特性，使你可以定义新的语句而无须扩展语法也无须使用宏之类的元编程特性。5.使用Scala的框架Lift是一个开源的Web应用框架，旨在提供类似RubyonRails的东西。因为Lift使用了Scala，所以Lift应用程序可以使用所有的Java库和Web容器。scala语言主要应用领域cala运行于JVM之上，并且它可以访问任何的java类库并且与java框架进行互操作，scala也大量重用了java类型和类库。大数据的开发语言是Scala的原因：1：大数据的本身是计算数据，而Scala即有面向对象组织项目工程的能力，又有计算数据的功能。2：现在大数据事实上的计算标准框架Spark，它是用Scala开发的，因为计算数据，Scala它是函数式编程，它实现算法非常简洁优雅。例：kafka，它是一个消息中间件，如果外部数据要流进大数据中心，我们一般都要用kafka作适配器，那如果大数据中心的数据流到外部，也是用kafka（如Spark计算的数据要交给HBASE或MySql，期间我们都会用kafka），很多的大数据组件都是用的Scala编写的，所以，如果你想成为一个较高级的大数据开发高手，你一定要掌握Scala。

Scala是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。你可以使用Scala编写出更加精简的程序，也能用于构建大型复杂系统，还可以访问任何Java类库并且与Java框架进行交互。在大数据当中，Scala是非常重要的一门编程语言，主流的Spark，Kafka，Flink框架都是Scala编程的。

Scala有交互式命令行(REPL), 可以在上面快速的试各种语法和代码。这对学习新特性，或者实验新想法非常有用。(第1章)一致性: 尽管Scala融合了静态类型系统、面向对象、函数式编程等语言特性，但却很少能看出融合的痕迹。Scala是我见到融合最多语言特性而又不显得杂乱的编程语言之一。类型安全：Scala创始人是教授，他先带领创建了Java 5编译器，而后觉得Java有太多羁绊而发明了Scala。 Scala编译器和类型系统非常强大，它的目标是尽量把软件错误消灭在编写过程中。 Scala类型系统是图灵完备的，甚至可以在编译期间解决问题。面向对象: Scala是面向对象的编程语言，所有的变量和方法都封装在对象中，可以把信息封装起来供外部使用。(第2章)函数式编程：Scala同时又是函数式编程语言，函数可以独立存在，可以定义一个函数作为另一个函数的返回值，也可以接受函数作为函数的参数。这给组合函数带来了很大的便利。如何把面向对象编程形容成搭积木的话，函数式编程就像拼线条，更灵活和更有创意。(第3章)异步编程: 由于函数式编程提倡变量不可变，使异步编程变得非常容易。同时Scala提供的Future(第5章)， 和akka类库(第9-11章)，使得异步编程变得非常容易。基于JVM: Scala会被编译成为jvm bytecode,所以Scala能无缝集成已有的Java类库。你可以非常自然的使用已经存在的非常庞大且稳定的Java类库，比如小巧好用的apache.common.*, 或者Java上的各种工具类库。因为如此众多特性，用Scala可以优雅地编写简洁的代码，同时又能减少很多低级错误；能快速进行开发，又能保证系统性能、团队协作和长期维护。

Scala即可伸缩的语言。可伸缩的语言的英语翻译是：Scalable Language，简称为Scala。它是一门多范式的编程语言，一种类似java的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。

本篇博客中我们将采用类似的方法，并熟悉Scala编程语言的另一个重要特性— 模式匹配 。同样我们将通过编写一些简短的代码片段，一系列小步骤来逐步深入。 case 类的许多其他有用特性（例如结构化 equals、hashCode、copy 和 toString）中，Scala 编译器支持以下代码 请注意这里的一个很好的对称性：构造时me 在左侧，带有两个字符串参数的 FullName(...) 在赋值的右侧，解构时正好相反。 当谈到 Scala 模式匹配时，首先想到的是 match 语句（它类似于许多其他编程语言中的 switch / case，但是更强大）。可以在 Scala 中的很多地方可以使用模式匹配：你可以在定义 lambda 函数时使用它，也可以在 for-comprehension 生成器的左侧，甚至在上面例子中的赋值语句中。为简单起见，在本文的其余部分，我们将主要在赋值语句中使用模式匹配。 现在我们已经定义了case类以及一些使用它的代码，接着尝试了解 Scala case类的特别之处以及如何使用相关代码。有时理解某事物如何工作的一个非常好的方法是破坏它，然后尝试使其再次工作！先将 FullName 类定义的 case 关键字排除 如果尝试上述代码，会发现代码（value me 的构建和它的解构）编译报错。为了修复它，我们需要在事情开始崩溃之前手动实现 Scala 编译器之前提供给我们的功能，我们为 FullName 类添加一个伴随对象 Scala 中的伴生对象是一个单例，与它的伴生类同名且在同一个文件中。而且伴随对象和它的类可以访问彼此的私有成员。伴生对象是放置类的静态成员的地方（与 Java 不同，Scala 没有 static 修饰符），这提供了更清晰的静态/实例成员分离。 注意：我们必须稍微更改 FullName 类定义，以使 FullName.unapply 编译成功 如果不进行修改，first 和 last 只会作为构造函数的参数，无法通过 unapply 访问它们。在 first 和 last 之前添加 val 会将它们同时转换为构造函数参数和实例字段（默认为 public）。在我们删除 case 关键字之前Scala 编译器会自动为我们生成此功能以及伴随对象。 现在手动添加所有这些代码可以修复编译问题，继续让我们深入了解刚刚实现的两个方法的细节 apply 是 Scala 中的一个特殊方法名称，按照约定可以在代码中省略，所以 FullName(...) 等价于 FullName.apply(...) ，我们正在使用它来构造 FullName 的新实例，而无需 new 关键字。 unapply 正好相反——它解构了一个 FullName 的实例，并且是模式匹配的基础，接下来我们将重点介绍这种方法，在这种情况下，它将 FullName 解构为两个字符串值，并将它们包装在 Some 中，这意味着它可以匹配 FullName 的任何实例（稍后我们将探讨部分匹配partial matching）。 再次注意这两个方法的对称性： apply 将两个字符串作为参数，并返回一个 FullName 的实例。而 unapply 则恰好相反。 现在我们对什么是 unapply 以及它如何用于解构/模式匹配有了一个非常基本的了解。在大多数情况下，它已经由 Scala 处理—— unapply 的实现不仅为我们编写的所有case类提供，而且为几乎所有 Scala 标准库中的所有内容提供，包括集合（如果适用），事实上实现自己的 unapply 并不常见，除非你是某个有趣库的开发者，然而我们可以作弊—在Java中unapply 肯定不存在，让我们从 java.time 中获取一些类，并在它们上添加对 Scala 模式匹配的支持 能够将 Date 分解为年、月和日，将 Time 分解为小时、分钟和秒，这很自然。此外DateTime — 转换为日期和时间，根据我们已有的知识，这非常简单。但是我们不能使用名称 LocalDate、LocalDateTime 和 LocalTime 来创建合适的伴生对象，因为伴生对象需要与对应的类放在相同的文件，但由于这些类来自 Java 标准库，因此不可能。为了避免名称冲突，我们简单地将实现对象的名称中省略 Local 接着使用它们： LocalDate 和 LocalTime 都按照预期被解构为 3 个 Int 值。如果我们只需要一些解构的值而不需要其他值，可以使用下划线代替那些不需要的值 一个更有趣的例子是 LocalDateTime 的嵌套解构 这为我们提供了 6 个 Int 值（日期部分为 3，时间部分为 3）。 模式匹配的另一个非常有用的特性是整个值的赋值，这可以在解构之外完成。对于我们的 DateTime 示例，它可能如下所示 除了 6 个 Int 值，还得到一个 LocalDate 值，一个是 LocalTime 值，最后是 LocalDateTime 的整个值（以 dt 为单位）。 在上面的所有示例中，我们都解构为固定数量的值——（年、月、日）、或（时、分、秒）或（日期、时间）。在某些情况下我们需要处理一系列值，而不是某些固定数量的值，可以尝试通过将 LocalDateTime 解构为一系列 Int unapplySeq 是 unapply 的变体，它解构为一系列值而不是固定大小的元组。在这个例子中，序列的长度总是 6，但可以省略它的尾部，因为不需要它 _* 是 Scala varargs 的语法 到现在为止， unapply / unapplySeq 总是返回 Some。为此 unapply 将返回 Some 以防该值符合某些条件，而 None 则不符合。我们已经在处理 LocalTime 的值，将它们匹配到 AM 或 PM 时间将是一个自然的例子 其中 case _ => 是默认情况，如果没有其他匹配项，则会使用此进行匹配，此外我们刚刚介绍了另外两个用于部分匹配的功能 u2022守卫（guards），例如case Time(h, m, s) if h < 12u2022常量匹配，例如case Time(12, m, s) 现在已经看到 Scala 模式匹配的强大功能！ 我们自己实现一个可以很好地格式化当前时间的时钟，通过使用模式匹配和 AM / PM 提取器（加上一些看起来像表情符号流的老派 Java 字符串格式） 我们已经 探索 了 Scala 模式匹配的大部分特性。可以在这里 [1] 找到这篇博文的所有源代码，为了更好地理解可以在 IntelliJ IDEA中运行这些代码，最后如果 Scala 代码中有一些复杂的、嵌套的 ifs 和 elses，请尝试使用模式匹配来更好地重构它。 [1] 这里: https://gist.github.com/linasm/003eec9eacc641167227193f5879bbd9

在Scala中，可以使用关键字var或val来定义变量，具体区别如下：var定义的变量是可变的（mutable），可以被重新赋值；而val定义的变量是不可变的（immutable），一旦赋值就不能再次被改变。例如：lessCopy codevar a: Int = 10 // 定义一个可变变量a，初始值为10a = 20 // 可以重新赋值println(a) // 输出20val b: Int = 30 // 定义一个不可变变量b，初始值为30b = 40 // 会编译错误，不能重新赋值println(b)Scala中可以通过类型推断省略变量的类型声明，如下：javaCopy codevar a = 10 // 等价于 var a: Int = 10val b = "hello" // 等价于 val b: String = "hello"在Scala中，变量名可以使用任何Unicode字符（包括中文等），而Java中则只能使用ASCII字符。总体来说，Scala中的变量定义更加简洁灵活，并且支持不可变变量的定义，这可以帮助编写更加安全可靠的代码。

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

「型变(Variance)」是一个令人费解的概念，但它却是理解类型系统的重要基石。本文首先讨论型变的基本概念，深入理解型变的基本形态。然后以 List, Option 为例讲解型变在 Scala 中的应用；最后通过 ScalaHamcrest 的实战，加深对此概念的理解和运用。 其中， Mutable 常常意味着 Nonvariant ，但是 Noncovariant 与 Mutable 分别表示两个不同的范畴。 「型变(Variance)」拥有三种基本形态：协变(Covariant), 逆变(Contravariant), 不变(Nonconviant)，可以形式化地描述为： Scala 的类型参数使用 + 标识「协变」， - 标识「逆变」，而不带任何标识的表示「不变」(Nonvariable)。 事实上，判定一个类型是否拥有型变能力的准则非常简单。 Supplier 是一个生成者，它生产 T 类型的实例。 Consumer 是一个消费者，它消费 T 类型的实例。 Function1 是一个一元函数，它既是一个生产者，又是一个消费者，但它是不可变的(Immutable)。其中，入参类型为 -T ，返回值类型为 +R ；对于参数类型，函数是逆变的，而对于返回值类型，函数则是协变的。 与 Function1 不同，虽然数组类型既是一个生产者，又是一个消费者。但是，它是一个可变的(Mutable)类型，因此它是不变的(Nonvariant)。 综上述，可以得到 2 个简单的结论。 幸运的是， Scala 编译器能够完成这个约束的检查。例如， 编译器将检测到编译错误。 例如，给定两个函数 F1, F2 。 则 F1 <: F2 成立。 Option 是一个递归的数据结构，它要么是 Some ，要么是 None 。其中， None 表示为空，是递归结束的标识。 使用 Scala ，可以很直观地完成 Option 的递归定义。 因为 Option 是不可变的(Immutable)，因此 Option 应该设计为协变的，即 Option[+A] 。也就是说，对于任意的类型 A ， Option[Nothing] <: Option[A] ，即 None <: Option[A] 都成立。 与 Option 类似， List 也是一个递归的数据结构，它由头部和尾部组成。其中， Nil 表示为空，是递归结束的标识。 使用 Scala ，可以很直观地完成 List 的递归定义。 因为 List 是不可变的(Immutable)，因此 List 应该设计为协变的，即 List[+A] 。也就是说，对于任意的类型 A ， List[Nothing] <: List[A] ，即 Nil <: List[A] 都成立。 可以在 List 中定义了 cons 算子，用于在 List 头部追求元素。 此时，编译器将报告协变类型 A 出现在逆变的位置上的错误。因此，在遵循「里氏替换」的基本原则，使用「下界(Lower Bound)」对 A 进行界定，转变为「不变的(Nonvariable)」的类型参数 A1 。 至此，又可以得到一个重要的结论。 List 的 cons 算子就是通过使用「下界」界定协变类型参数 A ，将其转变为不变的(Nonvariable)类型参数 A1 的。而对于「上界」，通过实现 ScalaHamcrest 的基本功能进行讲述，并完成整个型变理论知识的回顾和应用。 对于任意的类型 A ， A => Boolean 常常称为「谓词」；如果该谓词用于匹配类型 A 的某个值，也常常称该谓词为「匹配器」。 ScalaHamcrest 首先定义一个 Matcher ，并添加了 &&， ||， ! 的基本操作，用于模拟谓词的基本功能。 对于函数 A => Boolean ，类型参数 A 是逆变的。因此，为了得到支持型变能力的 Matcher ，应该将类型参数 A 声明为逆变。 但是，此时 &&, || 将报告逆变类型 A 出现在协变的位置上。为此，可以使用「上界」对 A 进行界定，转变为不变的(Nonvariant)类型 A1 。 基于 Matcher ，可以定义特定的原子匹配器。例如： 也可以定义 EqualTo 的原子匹配器，用于比较对象间的相等性。 与 EqualTo 类似，可以定义原子匹配器 Same ，用于比较对象间的一致性。 其中， A <: AnyRef类型 对 A 进行界定，排除 AnyVal 的子类误操作 Same 。类似于类型上界，也可以使用其他的类型界定形式；例如，可以定义 InstanceOf ，对类型 A 进行上下文界定，用于匹配某个实例的类型。 有时候，基于既有的原子可以很方便地构造出新的原子。 也可以将各个原子或者组合器进行组装，形成威力更为强大的组合器。 特殊地，基于 AnyOf/AllOf ，可以构造很多特定的匹配器。 修饰也是一种特殊的组合行为，用于完成既有功能的增强和补充。 其中， Not, Is 是两个普遍的修饰器，可以修饰任意的匹配器；也可以定义针对特定类型的修饰器。例如，可以定义针对字符串操作的原子匹配器和修饰匹配器。 如果要忽略大小写，则可以通过定义 IgnoringCase ，修饰既有的字符串的原子匹配器。 有时候，可以通过定义语法糖，提升用户感受。例如，可以使用 Not 替换 Not(EqualTo) ， Is 替代 Is(EqualTo) ，不仅减轻用户的负担，而且还能提高表达力。 至此，还不知道 ScalaHamcrest 如何使用呢？可以定义一个实用方法 assertThat 。 其中， assert 定义于 Predef 之中。例如存在如下一个测试用例。 也可以使用 && 直接连接多个匹配器形成调用链，替代 AllOf 匹配器。 此处为了演示「型变」的作用， ScalaHamcrest 采用了 OO 与 FP 相结合的设计手法，在下一章讲解「Scala函数论」时， ScalaHamcrest 将采用纯函数式的设计手法实现，敬请关注。

变量是程序的基本组成单位 var|val 变量名 [: 变量类型] = 变量值 整形 scala整数类型有固定的表数范围和字面长度，不受OS影响 scala的整数默认为整形，如果想表示Long，后面加L 浮点型 不受OS影响 scala浮点型常数默认为Double，声明float后面要加F 浮点型有两种表示方式十进制型和科学计数型(0.12,0.12f,.12,5.12e2=5.12乘以10的2次方) 字符类型 常量用双引号(" ")括起来 允许使用转义符 直接给Char整数，会输出码表对应的字符 Char可以进行运算，字符都有对应的数值 存储：字符->码值->二进制->存储 读取：二进制->码值->字符->读取 布尔类型 只允许取值true和false 只占1个字节 适用于逻辑运算 Unit 只有1个实例null，可以赋值给任意的引用类型，但是不能赋值给值类型(Int等) 函数没有返回值 Nothing 方法不会正确返回 值类型隐式转换 高级隐式转换和隐式函数 略 强制类型转换 自动类型转换的逆过程 将容量大的数据类型转换成容量小的数据类型，使用时要加上强制转换函数，但 可能造成精度降低或溢出 ，要格外注意 强制符号只针对最近的操作数有效，使用括号提升优先级 Char类型可以保存Int常量值，但不能保存Int变量值，需要强转 Byte和Short在运算时当作Int来处理 值类型和字符串类型的转换 基本类型转string + "" string转基本数据类型 .toInt, .toDouble, …… 12.5转Int 报错！

Scala是一门多范式的编程语言，一种类似java的编程语言，设计初衷是实现可伸缩的语言、并集成面向对象编程和函数式编程的各种特性。Python是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。scala与Python的区别：1、性能对比由于Scala是基于JVM的数据分析和处理，Scala比Python快10倍。当编写Python代码用且调用Spark库时，性能是平庸的，但如果程序涉及到比Python编码还要多的处理时，则要比Scala等效代码慢得多。Python解释器PyPy内置一个JIT（及时）编译器，它很快，但它不提供各种Python C扩展支持。在这样的情况下，对库的C扩展CPython解释器优于PyPy解释器。使用Python在Spark的性能开销超过Scala，但其重要性取决于您在做什么。当内核数量较少时，Scala比Python快。随着核数的增加，Scala的性能优势开始缩小。当大量的处理其工作时，性能不是选择编程语言的主要驱动因素。然而，当有重要的处理逻辑时，性能是一个主要因素，Scala绝对比Python提供更好的性能，用于针对Spark程序。相关推荐：《Python基础教程》2、学习曲线在用Scala语言编写Spark程序时有几个语法糖，所以大数据专业人员在学习Spark时需要非常小心。程序员可能会发现Scala语法有时会让人发疯。Scala中的一些库很难定义随机的符号运算符，而这些代码可以由没有经验的程序员理解。在使用Scala时，开发人员需要关注代码的可读性。与Scala相比，Java或Python是一个灵活的语法复杂的语言。对Scala开发人员的需求越来越大，因为大数据公司重视能在Spark中掌握数据分析和处理的高效而健壮的开发人员。Python是为Java程序员学习相对容易的因为它的语法和标准库。然而，Python是不是一个高度并行和可扩展的像SoundCloud或推特系统的理想选择。学习Scala丰富了程序员对类型系统中各种新抽象的认识，新的函数编程特性和不可变数据。3、并发性大数据系统的复杂多样的基础结构需要一种编程语言，它有能力集成多个数据库和服务。在大数据的生态系统中，Scala胜在Play框架提供了许多异步库和容易集成的各种并发原语，比如Akka。Scala使开发人员编写高效的、可读性和可维护性的服务而不是。相反，Python不支持的重量级进程并行在用uWSGI时，但它不支持真正的多线程。当使用Python写Spark程序时，不管进程有多少线程，每次只有一个CPU在Python进程中处于活动状态。这有助于每个CPU核心只处理一个进程，但糟糕的是，每当部署新代码时，需要重新启动更多的进程，还需要额外的内存开销。Scala在这些方面更高效，更容易共事。4、类型安全当用Spark编程时，开发人员需要根据变化的需求不断地重新编码代码。Scala是静态类型语言，尽管它看起来像一种动态类型语言，因为它具有优雅的类型推断机制。作为静态类型语言，Scala仍然提供编译器来捕获编译时错误。重构像Scala这样的静态类型语言的程序代码比重构像Python这样的动态语言代码要容易得多且简单。开发人员在修改Python程序代码后常常会遇到困难，因为它造成的bug比修复程序原有的bug要多。所以最好是缓慢而安全地使用Scala，而不是快速的、死地使用Python。对于小型的特殊实验，Python是一种有效的选择，但它并不像静态语言那样有效地扩展到大型软件工程中。5、易用性Scala和Python语言在Sparkcontext中有同样的表达，因此通过使用Scala或Python可以实现所需的功能。无论哪种方式，程序员都会创建一个Sparkcontext并调用函数。Python是一种比Scala更便于用户使用的语言。Python不那么冗长，开发人员很容易用Python编写脚本来调用Spark。易用性是一个主观因素，因为它取决于程序员的个人偏好。6、高级特性Scala编程语言有几个存在类型、宏和隐式。Scala的晦涩难懂的语法可能很难对开发人员可能无法理解的高级特性进行实验。然而，Scala的优势在于在重要的框架和库中使用这些强大的特性。话虽如此，Scala没有足够的数据科学工具和库，如Python用于机器学习和自然语言处理。Sparkmlib–机器学习库只有较少的ML算法但他们是理想的大数据处理。Scala缺乏良好的可视化和本地数据转换。Scala无疑是Spark streaming特性的最佳选择，因为Python 通过pySpark 调用Spark.streaming不像Scala那样先进和成熟。总结“Scala速度更快，使用方便 但上手难，而Python则较慢，但很容易使用。”Spark框架是用Scala编写的，所以了解Scala编程语言有助于大数据开发人员轻松地挖掘源代码，如果某些功能不能像预期的那样发挥作用。使用Python增加了更多问题和bug的可能性，因为2种不同语言之间的转换是困难的。为Spark使用Scala提供对Spark框架的最新特性的访问，因为它们首先在Scala中可用，然后移植到Python中。根据Spark决定Scala和Python取决于最适合项目需要的特性，因为每种语言都有自己的优点和缺点。在使用Apache Spark编程语言之前，开发者必须学习Scala和Python来熟悉它们的特性。学习了Python和Scala之后，决定何时使用Scala来Spark以及何时使用Python来调用Spark是相当容易的。Apache Spark编程语言的选择完全取决于要解决的问题。

我想大部分应用开发程序员，最关键是看有什么类库合适的方便特定领域的应用开发。就像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特性的优化。

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竞争。

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

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

scala是意大利的品牌。

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

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

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

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

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

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

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

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

在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蓝色显示

Building with 2.10 I get the following error. It"s a Maven build but I see people getting this error with SBT, so I don"t think it"s a Maven problem. I"ve tried including dependencies for scala-reflect and scala-library, Maven options -e and -X, scalac options -g:vars -verbose -explaintypes. Nothing gives me more clues about the zip file that failed to open. What is a compiler mirror? [INFO] Compiling 204 Scala sources and 9 Java sources to /Users/garystruthers/git/incubator-spark/core/target/scala-2.10/classes...[ERROR] error while loading , error in opening zip file[INFO] ------------------------------------------------------------------------[INFO] Reactor Summary:[INFO] [INFO] Spark Project Parent POM .......................... SUCCESS [1.120s][INFO] Spark Project Core ................................ FAILURE [15.817s]…..[ERROR] Failed to execute goal net.alchim31.maven:scala-maven-plugin:3.1.0:compile (scala-compile-first) on project Spark-core: wrap: scala.reflect.internal.MissingRequirementError: object scala.runtime in compiler mirror not found.

这个程序查询结果是不是可以理解为：先计算次数出现最多的，在出现次数相等的情况下，数值最大的？因为这个问题是有矛盾的，出现次数最多的不一定数值最大用c++写的，思路都在，vb很久没有用了。不想去看了。希望思路对你有用#includevoidmain(){inta[100],b[100]={0};//数组a中存放输入的整数，数组b中存放对应整数出现的次数(a[i]中整数出现的次数放在b[i]中intm=0,n,x,k,maxa,maxb;cout>n;for(inti=0;i>x;for(intj=0;jmaxa)maxa=a[i];if(b[i]>maxb){maxb=b[i];k=i;}}cout<<"n个数中出现次数最多的数是"<

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中的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集成的电子商务管理解决方案，具有财务及资源管理、市场营销管理、供应流程管理、服务及项目流程管理、制造及商务智能管理等方面。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 下划线主要用法：一个类型数据的默认值，譬如var i： Int = _，这里是0。整形为0，浮点为0.0，引用类型为null。第二点，匿名函数的参数，一个匿名函数里第一个下划线代表第一个参数，第二个代表第二个参数第三点，import的通配符第四点，重命名import时隐藏某个名称时的用法第五点，模式匹配中代表会被丢弃的值

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

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

我记得是可以的.

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

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

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)

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，哈尔滨有江鹏的Scala是什么意思？斯卡拉原本是意大利著名歌剧院的名字，现在中国南方一些大城市也开设了斯卡拉文化遗址。斯卡拉也逐渐演变成一个集娱乐、餐饮、休闲为一体的大众文化娱乐场所。和北京东方Scala一样，其演出CD早已成为影音市场的新宠。其风靡全国的奥秘在于节目独特的整体风格，主持人幽默风趣的主持风格，以及节目极强的互动性。哈尔滨鹏飞无限斯卡拉秀的主要演员都是高薪从全国各地聘请的。他们都有特殊的技能，就像一个男歌手。在短短十分钟内，他们模仿了许多歌手，如刘欢、孙楠和杨坤。不同于一般的综艺节目，Scala的主持人是舞台的核心。他不仅要会说话，还要会唱歌，会演戏，会煽情，样样精通。Scala最大的特点就是交互性强。观众可以获得在舞台上一起演唱和表演的机会。同时，演出中还安排了卖花、抽奖、友情祝贺等项目。现在我们常说的Scala这个词就是来源于ScalaOperaHouse:斯卡拉歌剧院，位于意大利米兰。大剧院于1778年8月3日正式开放，当时它被命名为NuovoRegioDucalTeatroallaScala。第二次世界大战期间，剧院遭到轰炸，整个演出大厅被彻底摧毁。战后，意大利政府拨出巨资，按照当时的最高标准进行重建。中国没有黑社会。今天，中国是一个繁荣、民主、文明、和谐、自由、平等、公正、法治、爱国、敬业、诚信、友好的发展中国家。全党为中国梦、为祖国崛起而努力奋斗。对西方的“和平演变”和各种外国分子制造的各种谣言，要保持谨慎。坚定不移地跟随中国共产党的脚步走向中华民族复兴之路。姜鹏，1971年4月18日出生于黑龙江哈尔滨，男歌手，音乐人，mainlandChina商人。1997年参加《飞图杯》全国青年歌手大赛获得银屏奖，随后进入乐坛。2004年，发行首支单曲《付出》。2007年发行首张音乐专辑《别无它求》。2009年8月，发行个人单曲《不爱我的女人让我流泪》；随后，我发行了我的第二张专辑《心爱的宝贝》。2010年发行个人音乐单曲《一秒钟》。2011年，发行单曲《有时候男人比女人更脆弱》在中央广播电台连续打榜，获得星海流行音乐奖榜首；11月，《有时候男人比女人更脆弱》专辑签售。2013年发行个人单曲《满身囔囔踹》。2014年，姜鹏执导并演出个人首部电影《夜色》；6月，友情出演音乐励志电影《我们是太阳》。2015年推出个人音乐单曲《抒情歌最美》；7月，发行佛教音乐专辑《问佛》。2016年2月，推出的个人音乐专辑《江湖大道》，荣登全球华语音乐榜榜首；12月，歌曲《江湖大道》MV。

大数据需要学什么1.Java编程技术Java编程技术是大数据学习的基础，Java是一种强类型语言，拥有极高的跨平台能力，可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等，是大数据工程师最喜欢的编程工具，因此，想学好大数据，掌握Java基础是必不可少的!2.Linux命令对于大数据开发通常是在Linux环境下进行的，相比Linux操作系统，Windows操作系统是封闭的操作系统，开源的大数据软件很受限制，因此，想从事大数据开发相关工作，还需掌握Linux基础操作命令。3.HadoopHadoop是大数据开发的重要框架，其核心是HDFS和MapReduce，HDFS为海量的数据提供了存储，MapReduce为海量的数据提供了计算，因此，需要重点掌握，除此之外，还需要掌握Hadoop集群、Hadoop集群管理、YARN以及Hadoop高级管理等相关技术与操作!4.HiveHive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的sql查询功能，可以将sql语句转换为MapReduce任务进行运行，十分适合数据仓库的统计分析。对于Hive需掌握其安装、应用及高级操作等。5.Avro与ProtobufAvro与Protobuf均是数据序列化系统，可以提供丰富的数据结构类型，十分适合做数据存储，还可进行不同语言之间相互通信的数据交换格式，学习大数据，需掌握其具体用法。6.ZooKeeperZooKeeper是Hadoop和Hbase的重要组件，是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组件服务等，在大数据开发中要掌握ZooKeeper的常用命令及功能的实现方法。7.HBaseHBase是一个分布式的、面向列的开源数据库，它不同于一般的关系数据库，更适合于非结构化数据存储的数据库，是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，大数据开发需掌握HBase基础知识、应用、架构以及高级用法等。8.phoenixphoenix是用Java编写的基于JDBCAPI操作HBase的开源SQL引擎，其具有动态列、散列加载、查询服务器、追踪、事务、用户自定义函数、二级索引、命名空间映射、数据收集、行时间戳列、分页查询、跳跃查询、视图以及多租户的特性，大数据开发需掌握其原理和使用方法。9.RedisRedis是一个key-value存储系统，其出现很大程度补偿了memcached这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用，它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便，大数据开发需掌握Redis的安装、配置及相关使用方法。10.FlumeFlume是一款高可用、高可靠、分布式的海量日志采集、聚合和传输的系统，Flume支持在日志系统中定制各类数据发送方，用于收集数据;同时，Flume提供对数据进行简单处理，并写到各种数据接受方(可定制)的能力。大数据开发需掌握其安装、配置以及相关使用方法。11.SSMSSM框架是由Spring、SpringMVC、MyBatis三个开源框架整合而成，常作为数据源较简单的web项目的框架。大数据开发需分别掌握Spring、SpringMVC、MyBatis三种框架的同时，再使用SSM进行整合操作。12.KafkaKafka是一种高吞吐量的分布式发布订阅消息系统，其在大数据开发应用上的目的是通过Hadoop的并行加载机制来统一线上和离线的消息处理，也是为了通过集群来提供实时的消息。大数据开发需掌握Kafka架构原理及各组件的作用和使用方法及相关功能的实现!13.ScalaScala是一门多范式的编程语言，大数据开发重要框架Spark是采用Scala语言设计的，想要学好Spark框架，拥有Scala基础是必不可少的，因此，大数据开发需掌握Scala编程基础知识!14.SparkSpark是专为大规模数据处理而设计的快速通用的计算引擎，其提供了一个全面、统一的框架用于管理各种不同性质的数据集和数据源的大数据处理的需求，大数据开发需掌握Spark基础、SparkJob、SparkRDD、sparkjob部署与资源分配、Sparkshuffle、Spark内存管理、Spark广播变量、SparkSQL、SparkStreaming以及SparkML等相关知识。15.AzkabanAzkaban是一个批量工作流任务调度器，可用于在一个工作流内以一个特定的顺序运行一组工作和流程，可以利用Azkaban来完成大数据的任务调度，大数据开发需掌握Azkaban的相关配置及语法规则。16.Python与数据分析Python是面向对象的编程语言，拥有丰富的库，使用简单，应用广泛，在大数据领域也有所应用，主要可用于数据采集、数据分析以及数据可视化等，因此，大数据开发需学习一定的Python知识。

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

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

http://segmentfault.com/q/1010000000671822

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

通常用Eclipse来搭建scala语言编程环境。方法如下：1.下载Scala IDE for Eclipse，然后解压就好了。2.运行Eclipse，右键选择新建scala project,新项目下，右键新建scala object。3.编写第一个demo。4.右键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型不再只类和接口，以及亚型关系更丰富，更难理解。

（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控制台输出结果成功。

简单学习一下scala