① 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對象的*方法已經合法化了。