① scala编译后的文件是以什么结尾
scala编译后的文件是以.class结尾。
开头包含类似package声明的scala代码直接在scala命令行用:load指令加载会出错。如果在scala命令行想调用自己在ide写好的类时（大多数情况下你的类会用到外部包，比如spark之类的），有三种方法：
将你在ide写好的project在scala下进行编译，之后通过Main调用。
打包整个项目为jar，通过scala -classpath加载后，在scala中import进行调用。
去掉package声明，并且将依赖包通过scala -classpath加载后，再使用：load 加载你的内容。
② Hadoop和Scala什么关系
Scala是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于java平台（Java虚拟机），并兼容现有的Java程序。
③ 详解 Scala 模式匹配
本篇博客中我们将采用类似的方法，并熟悉Scala编程语言的另一个重要特性— 模式匹配 。同样我们将通过编写一些简短的代码片段，一系列小步骤来逐步深入。
case 类的许多其他有用特性（例如结构化 equals、hashCode、 和 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 _ => 是默认情况，如果没有其他匹配项，则会使用此进行匹配，此外我们刚刚介绍了另外两个用于部分匹配的功能
•守卫（guards），例如case Time(h, m, s) if h < 12•常量匹配，例如case Time(12, m, s)
现在已经看到 Scala 模式匹配的强大功能！
我们自己实现一个可以很好地格式化当前时间的时钟，通过使用模式匹配和 AM / PM 提取器（加上一些看起来像表情符号流的老派 Java 字符串格式）
我们已经 探索 了 Scala 模式匹配的大部分特性。可以在这里 [1] 找到这篇博文的所有源代码，为了更好地理解可以在 IntelliJ IDEA中运行这些代码，最后如果 Scala 代码中有一些复杂的、嵌套的 ifs 和 elses，请尝试使用模式匹配来更好地重构它。
[1] 这里: https://gist.github.com/linasm/
④ Scala 是一门怎样的语言，具有哪些优势
曾经有人问Java的创始人高斯林这样一个问题，“除了Java语言以外，您现在还使用JVM平台上的哪种编程语言?”他毫不犹豫的说是Scala。
Scala到底是什么?在目前众多的JVM语言当中，Scala无疑是最引人注意的语言之一。Scala是一个静态语言，更适合大型工程项目，Scala直接编译成Java字节码，性能接近Java。Scala是一个多范式的语言，你可以混合使用函数式和面向对象编程，混合使用可变类和不变类，混合使用Actor和传统的Java并发库。
短短一个月的时间，Scala于本月冲进了TIOBE的前五十名。一个 Twitter 的开发人员说过，Scala 将会成为现代 Web2.0 的发起语言。LinkedIn 也用这种语言。同样许多其他大的公司如 Sony Picture, EDF, SAP 也开始使用这种语言。为什么Scala发展这么迅猛，可以获得如此热烈的社区支持。
曾冠东还表示，Scala不是Java的杀手，它无法取代Java的地位，也突破不了JVM的限制、Java实现不了的功能它也实现不了。我们可以将Scala形象的理解成大量语法糖的Java。
Scala 开发团队发布了最新的2.9.2稳定版本，Scala 语言的特性有许多，例如高阶函数和对象、抽象类型绑定，actor 使得函数在 Scala 中能是一个子类成为可能，Scala 中的设计模式使得面向对象和函数编程无缝结合。Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。它已经成功运用在电信行业。Spark 是一种可扩展的数据分析平台，它整合了内存计算的基元，因此，相对于 Hadoop 的集群存储方法，它在性能方面更具优势。Spark 是在 Scala 语言中实现的，并且利用了该语言，为数据处理提供了独一无二的环境。Scala 编译器可以生成字节码，直接运行在使用JVM上。该语言(它实际上代表了可扩展语言)被定义为可直接集成到语言中的简单扩展。
Scala作为一门静态语言，它的主要特性有哪些?
· Scala是面向对象的
Scala是一个纯面向对象语言，在某种意义上来讲所有数值都是对象。对象的类型和行为是由class和trait来描述的。Class的抽象可由子类化和一种灵活的基于mixin的组合机制(它可作为多重继承的简单替代方案)来扩展。
· Scala是函数式的
Scala还是一个函数式语言，在某种意义上来讲所有函数都是数值。Scala为定义匿名函数提供了一种轻量级的语法，它支持高阶(higher-order)函数、允许函数嵌套、支持局部套用(currying)。Scala的case类及其内置支持的模式匹配模型代数类型在许多函数式编程语言中都被使用。
· Scala是静态类型的
Scala配备了一套富有表现力的类型系统，该抽象概念以一种安全的和一致的方式被使用。
· Scala是可扩展的
Scala的设计承认了实践事实，领域特定应用开发通常需要领域特定语言扩展。Scala提供了一个独特的语言组合机制，这可以更加容易地以类库的形式增加新的语言结构：
任何方式可以被用作中缀(infix)或后缀(postfix)操作符闭包按照所期望的类型(目标类型)自动地被构造
两者结合使用可方便地定义新语句，无需扩展语法，也无需使用类似宏的元编程工具。
· Scala可与Java和.NET进行互操作
Scala设计时就考虑了与流行编程环境良好交互，如Java 2运行时环境(JRE)和 .NET框架(CLR)。特别是与主流面向对象语言，如Java和C#尽量无缝交互。Scala有像Java和C#一样的编译模型(独立编译，动态装载类)，允许访问成千上万的高质量类库。
在并发性方面，与 Scala 在 .NET 领域中的姐妹语言 F# 相似，Scala 是针对 “并发性问题” 的解决方案之一，让开发人员能够更加轻松地专注于问题的实质，而不用考虑并发编程的低级细节。Actor 编程模式让高度并行应用程序的开发更加简单。Scala把Erlang风格的基于actor的并发带进了JVM。我们可以利用Scala的actor模型在JVM上设计具伸缩性的并发应用程序，以自动获得多核心处理器带来的优势，而不必依照复杂的Java线程模型来编写程序。Scala 为并发性提供了两种级别的支持，这与其他与 Java 相关的主题极为类似：
首先，对底层库的完全访问(比如说 java.util.concurrent)以及对 “传统” Java 并发性语义的支持(比如说监控程序和wait()/notifyAll())。其次，这些基本机制上面有一个抽象层
Scala 提供了在稳定的高性能平台(Java 虚拟机)上生成的能力同时也是一门敏捷性语言。这一类型的语言也有其他的选择，例如 Jython, JRuby, Groovy 和 Clojure, 但是这些都是运行在 JVM 上的动态类型语言。Open Class 的效果让大家会觉得Scala是动态语言，但它是选择隐式转换来实现的，这也正好证明了Scala是静态语言。隐式转换(Implicit conversion)使 Scala 具有类型安全性，正如扩展方法(extension method)之于 C#，开放类(open class)之于 ruby。即：向未曾定义的类型添加方法(如字符串、列表、整数)。这是使得 Scala 符合 DSL(特定领域语言)模型的特性之一。
Scala结合了面向对象和函数编程的优势，函数编程的一个好处就是你能够像运用一个数据那样运用函数，可以用来定义真正高层级的库，或者去定义新的领域特殊语言(DSL)。
在谈及Java与Scala的对比时，曾冠东表示，Scala能调用绝大部分的Java，而Java调用Scala独有的东西会比较难。Java 拥有非常强的概念规范，因此任何一个 Java 程序之间具有非常多的相似之处，并且这样能够方便的进行程序员交替。但是 Scala 并没有这样的统一性，因为这是一门很有表现力的语言。现场曾冠东为我们演示了实际案例，如下图所示：
正所谓，金无足赤，人无完人。Scala对二进制不兼容，语法也越来越复杂，不能突破Bytecode的限制、编译速度有所缓慢。当它被广泛用于单元测试、开发工具、Socket开发、以及面对多核挑战的并发应用。总而言之，Scala是一种函数式面向对象语言，它融汇了许多前所未有的特性，而同时又运行于JVM之上。正如JRuby 创建者之一Charles Nutter 所宣称的那样Scala就是 Java 王位的合法继承人。随着开发者对Scala的兴趣日增，以及越来越多的工具支持，无疑Scala语言将成为广大软件工程师手上一件必不可少的工具。更多精彩内容，请关注专题：http://www.it168.com/remen/qcon/
⑤ 编译后生成的scala文件扩展名为
Java 源程序文件编译后产生的文件称为(字节码)文件,其扩展名为(.class)。
⑥ 如何让Scala编译出来的class文件能够直接在jvm运行
scalac Hello.scala
scala Hello
java -cp .;scala-library.jar Hello
⑦ Scala类型之AnyRef Object
语法上scala的AnyRef与java的Object对应，但是，Object定义在scala类里和java类里是不同的，定义在scala里，等价AnyRef，但是定义在java里，等价Any。具体例子：java里Object类型的方法参数，在scala里调用可以传Int等基本类型，但scala里Object类型的方法参数，传Int编译就通不过。
⑧ linux 怎么运行scala
切换到scala环境中存放test.scala文件的文件夹下
先编译：
scalac test.scala
再执行：
scala -classpath . HelloWorld (这里HelloWorld为代码中的对象名称)
⑨ scala manifest和classmanifest的区别
Manifest是scala2.8引入的一个特质，用于编译器在运行时也能获取泛型类型的信息。在JVM上，泛型参数类型T在运行时是被“擦拭”掉的，编译器把T当作Object来对待，所以T的具体信息是无法得到的；为了使得在运行时得到T的信息，scala需要额外通过Manifest来存储T的信息，并作为参数用在方法的运行时上下文。
def test[T] (x:T, m:Manifest[T]) { ... }
有了Manifest[T]这个记录T类型信息的参数m，在运行时就可以根据m来更准确的判断T了。但如果每个方法都这么写，让方法的调用者要额外传入m参数，非常不友好，且对方法的设计是一道伤疤。好在scala中有隐式转换、隐式参数的功能，在这个地方可以用隐式参数来减轻调用者的麻烦。
获取class manifests的两种基本方式:
1 def classOf[T <: Any](implicit m: scala.reflect.Manifest[T]): Class[T] = m.erasure.asInstanceOf[Class[T］
通过implicit m: scala.reflect.Manifest[T]声明一个隐式参数，这样scala编译器能在编译时提供T的类型信息了
2 def classOf[T <: Any : Manifest] : Class[T] = manifest[T].erasure.asInstanceOf[Class[T］
其中 T <: Any : Manifest，拆分成两部分来看
T <: Any
T 是Any的子类型（即可以是任意基本类型scala.AnyVal 和引用类型 scala.AnyRef)
T : Manifest 相当于对classOf 方法currying
隐式增加参数列表如下：(implicit evidence$1: Manifest[T])，
通过manifest[T] 方法即可获取Manifest实例
可见形式1 和形式2实质是一样的。
应用：
1最常见的是获取类型参数的Class，形如someMethod[Type]
如akka中源码： def actorOf[T <: Actor : Manifest]: ActorRef = actorOf(manifest[T].erasure.asInstanceOf[Class[_ <: Actor］)
class Worker extends Actor {
def receive = {
case Work(start, nrOfElements) =>
self reply Result(calculatePiFor(start, nrOfElements)) // perform the work
}
}
就可以如此使用了： val workerActorRef = actorOf[Worker]
2 编程方式创建范型数组
def evenElems[T: ClassManifest](xs: Vector[T]): Array[T] = {
val arr = new Array[T]((xs.length + 1) / 2)
for (i <- 0 until xs.length by 2)
arr(i / 2) = xs(i)
arr
}
scala> evenElems(Vector("a","b","c"))
res: Array[java.lang.String] = Array(a, c)
⑩ java反编译后是scala吗
javap是JDK提供的一个反编译工具。常用的选项有-c -l -s。如果仅仅是想查看编译的得到的字节码文件中函数与变量，不需要带选项。使用javap很容易发现源文件与编译后得到的字节码文件有什么不同，可以加深对编译器的理解。
javap -help
Usage: javap <options> <classes>...
where options include:
-c Disassemble the code
-classpath <pathlist> Specify where to find user class files
-extdirs <dirs> Override location of installed extensions
-help Print this usage message
-J<flag> Pass <flag> directly to the runtime system
-l Print line number and local variable tables
-public Show only public classes and members
-protected Show protected/public classes and members
-package Show package/protected/public classes and members (default)
-private Show all classes and members
-s Print internal type signatures
-bootclasspath <pathlist> Override location of class files loaded by the bootstrap class loader
-verbose Print stack size, number of locals and args for methods If verifying, print reasons for failure
Scala是基于JVM的，所有其字节码和Java编译得到的字节码应该是一致的。首先从Hello World开始
object Main {
def main(args: Array[String]) = {
println("Hello, " + args(0))
}
}
使用scalac编译都得到两个字节码文件：Main.class和Main$.class。
在class文件所在的目录分别运行javap Main和javap Main$得到如下结果：
Compiled from "Main.scala"
public final class Main extends java.lang.Object{
public static final void main(java.lang.String[]);
}
Compiled from "Main.scala"
public final class Main$ extends java.lang.Object implements scala.ScalaObject{
public static final Main$ MODULE$;
public static {};
public void main(java.lang.String[]);
}
Scala的object是单例模式。上面的反编译结果给了我们Scala实现原理的提示。MODULE$指向类的实例，相当于this。而方法也是被声明为静态的。做了一个测试，更加直观。http://stackoverflow.com/questions/2347107/what-is-scala-equivalent-of-javas-static-block说如果不是去发射火箭，Object的代码跟Java的静态代码可以认为是等价的。
把上面的代码稍作修改：
case class Main {
def main(args: Array[String]) = {
println("Hello, " + args(0))
}
}
在class文件所在的目录分别运行javap Main和javap Main$得到如下结果：
Compiled from "Main.scala"
public class Main extends java.lang.Object implements scala.ScalaObject,scala.Proct,scala.Serializable{
public scala.collection.Iterator proctIterator();
public scala.collection.Iterator proctElements();
public void main(java.lang.String[]);
public int hashCode();
public java.lang.String toString();
public boolean equals(java.lang.Object);
public java.lang.String proctPrefix();
public int proctArity();
public java.lang.Object proctElement(int);
public boolean canEqual(java.lang.Object);
public Main();
}
Compiled from "Main.scala"
public final class Main$ extends scala.runtime.AbstractFunction0 implements scala.ScalaObject,scala.Serializable{
public static final Main$ MODULE$;
public static {};
public final java.lang.String toString();
public boolean unapply(Main);
public Main apply();
public java.lang.Object readResolve();
public java.lang.Object apply();
}
与输入的文件相比，Scala添加了许多东西：
1. Scala自动帮助Case类生成toString， equals，hashCode等方法。
2. Scala自动帮助Case类生成apply方法，不需要new就可以直接创建类的实例或引用。
3. 对于类的成员，Scala自动生成成员的Getter和Setter。
4. Case类提供对模式匹配的支持。
下面来看Scala对类和隐式转换的处理，有一个Rational类：
class Rational(n: Int, d: Int) {
require(d != 0)
private val g = gcd(n.abs, d.abs)
val numer = n / g
val denom = d / g
def this(n: Int) = this(n, 1)
def +(that: Rational): Rational =
new Rational(numer * that.denom + that.numer * denom, denom * that.denom)
def +(i: Int): Rational = new Rational(numer + i * denom, denom)
def -(that: Rational): Rational =
new Rational(numer * that.denom - that.numer * denom, denom * that.denom)
def -(i: Int): Rational = new Rational(numer - i * denom, denom)
def *(that: Rational): Rational = new Rational(numer * that.numer, denom * that.denom)
def *(i: Int): Rational = new Rational(numer * i, denom)
def /(that: Rational): Rational = new Rational(numer * that.denom, denom * that.numer)
def /(i: Int): Rational = new Rational(numer, denom * i)
override def toString = numer + "/" + denom
private def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)
}
object Rational{
implicit def intToRational(x: Int) = new Rational(x)
}
javap得到：
Compiled from "Rational.scala"
public class Rational extends java.lang.Object implements scala.ScalaObject{
public static final Rational intToRational(int);
public int numer();
public int denom();
public Rational(int);
public Rational $plus(Rational);
public Rational $plus(int);
public Rational $minus(Rational);
public Rational $minus(int);
public Rational $times(Rational);
public Rational $times(int);
public Rational $div(Rational);
public Rational $div(int);
public java.lang.String toString();
public Rational(int, int);
}
Compiled from "Rational.scala"
public final class Rational$ extends java.lang.Object implements scala.ScalaObje
ct{
public static final Rational$ MODULE$;
public static {};
public Rational intToRational(int);
}
对于普通类，Scala自动添加的东西稍微少一些。一直出现的还有一个特别的函数：public static {};通过带参数-c的javap可以看到其汇编代码：
public static {};
Code:
0: new #9; //class Rational$
3: invokespecial #12; //Method "<init>":()V
6: return
new创建一个对象并将其引用值压入栈顶，invokespecial调用父类的构造方法，return从当前方法返回void。该方法实际上就是一个创建自身的静态方法。Java虚拟机指令参考http://blog.csdn.net/noonlyandroid/article/details/6117470
Rational$中的intToRational是我们提供的隐式类型转换，将一个Int转换为Rational。其汇编代码如下：
public Rational intToRational(int);
Code:
0: new #16; //class Rational
3: p
4: iload_1
5: invokespecial #20; //Method Rational."<init>":(I)V
8: areturn
new首先创建一个Rational对象并将其引用值压入栈顶，p复制栈顶数值并将复制值压入栈顶，iload_1将第二个int型本地变量推送至栈顶，invokespecial调用Rational的构造方法，最后areturn从当前方法返回对象引用。
我们用如下代码来测试隐式类型转换：
import Rational._
object RationalTest {
def main(args: Array[String]) {
val r = new Rational(2,3)
println(2 * r)
}
}
2 * r本身不合法的，因为Int不存在*(Rational)的方法，由于隐式转换的存在，Scala将做一些转换工作。上面程序的汇编代码如下：
Compiled from "RationalTest.scala"
public final class RationalTest$ extends java.lang.Object implements scala.Scala
Object{
public static final RationalTest$ MODULE$;
public static {};
Code:
0: new #9; //class RationalTest$
3: invokespecial #12; //Method "<init>":()V
6: return
public void main(java.lang.String[]);
Code:
0: new #16; //class Rational
3: p
4: iconst_2
5: iconst_3
6: invokespecial #20; //Method Rational."<init>":(II)V
9: astore_2
10: getstatic #25; //Field Rational$.MODULE$:LRational$;
13: iconst_2
14: invokevirtual #29; //Method Rational$.intToRational:(I)LRational;
17: aload_2
18: invokevirtual #33; //Method Rational.$times:(LRational;)LRational;
21: astore_3
22: getstatic #38; //Field scala/Console$.MODULE$:Lscala/Console$;
25: aload_3
26: invokevirtual #42; //Method scala/Console$.println:(Ljava/lang/Object;
)V
29: return
}
在做乘法（$times）之前调用了 intToRational，返回一个Rational对象， 调用Rational对象的*方法已经合法化了。