scala筆記,主要摘自網絡教程
阿新 • • 發佈:2018-06-20
結果 名稱 any 初始 存儲 一個 對象實例 單例對象 語句
1.scala是一種純面向對象的語言,每個值都是對象。對象的數據類型以及行為由類和特質描述
2.類的擴展有2種機制:繼承和混入機制
3.scala是一種函數式語言,其函數也能當成值來使用
==4.scala使用actor作為其並發模型,actor是類似線程的實體,通過郵箱發收消息。actor可以復用線程,因此在程序中可用數百萬個actor,而線程只能創建數千個==
5.scala與java語法最大的區別是:scala語句末尾的分號是可選的
6.所有類名首字母大寫,方法名首字母小寫,程序文件名與對象名稱可以不匹配,但建議保留匹配的習慣;def main(args: Array[String]),scala程序從main()方法開始處理
7.Unit表示無值,同void.Unit只有一個實例值,寫成()
8.Nothing類型在scala的類層級的最低端,它是任何其它類型的子類型
9.Any是所有其它類的超類
10.AnyRef類是scala裏所有引用類的基類
11.符號字面量‘<標識符>被映射成預定義類scala.Symbol的實例
如: 符號字面量 ‘x 是表達式 scala.Symbol("x") 的簡寫,符號字面量定義如下:
package scala final case class Symbol private (name: String) { override def toString: String = "'" + name }
12.多行字符串用三個雙引號來表示分割符,實例如下:
val foo = """菜鳥教程
www.runoob.com
www.w3cschool.cc
www.runnoob.com
以上三個地址都能訪問"""
13.var聲明變量,val聲明常量,修改常量時會在編譯時報錯
14.變量類型聲明一定要有初始值,否則會報錯
var VariableName : DataType [= Initial Value]
或
val VariableName : DataType [= Initial Value]
15.默認情況下訪問級別是==public==
16.scala中的函數其實就是繼承了trait的類對象,scala中使用val語句定義函數,def定義方法
def functionName ([參數列表]) : [return type]
17.scala在函數調用的時候,可以通過指定參數名,並且不按照順序向函數傳遞參數,實例如下:
object Test {
def main(args: Array[String]) {
printInt(b=5, a=7);
}
def printInt( a:Int, b:Int ) = {
println("Value of a : " + a );
println("Value of b : " + b );
}
}
18.for語法
18.1.Range風格的for循環
for( var x <- Range ){
statement(s);
}
以上語法中,Range 可以是一個數字區間表示 i ==to== j ,或者 i ==until== j。左箭頭 ==<-== 用於為變量 x 賦值。
i to j 包含j
i until j 不包含j
18.2.分號(;)風格的for循環,可以設置多個區間同時循環,即==多重循環==,實例:
object Test {
def main(args: Array[String]) {
var a = 0;
var b = 0;
// for 循環
for( a <- 1 to 3; b <- 1 to 3){
println( "Value of a: " + a );
println( "Value of b: " + b );
}
}
}
輸出結果:
Value of a: 1
Value of b: 1
Value of a: 1
Value of b: 2
Value of a: 1
Value of b: 3
Value of a: 2
Value of b: 1
Value of a: 2
Value of b: 2
Value of a: 2
Value of b: 3
Value of a: 3
Value of b: 1
Value of a: 3
Value of b: 2
Value of a: 3
Value of b: 3
18.3.for遍歷集合,語法:
for( var x <- List ){
statement(s);
}
實例:
object Test {
def main(args: Array[String]) {
var a = 0;
val numList = List(1,2,3,4,5,6);
// for 循環
for( a <- numList ){
println( "Value of a: " + a );
}
}
}
18.4.for循環過濾,語法:
for( var x <- List
if condition1; if condition2...
){
statement(s);
實例:
object Test {
def main(args: Array[String]) {
var a = 0;
val numList = List(1,2,3,4,5,6,7,8,9,10);
// for 循環
for( a <- numList
if a != 3; if a < 8 ){
println( "Value of a: " + a );
}
}
}
18.5.for循環使用yield將循環過濾的返回值用作變量存儲,語法:
var retVal = for{ var x <- List
if condition1; if condition2...
}yield x
大括號用於保存變量和條件,retVal是變量,循環中的yield會把當前的元素記下來,保存在集合中,循環結束後將返回該集合。實例:
object Test {
def main(args: Array[String]) {
var a = 0;
val numList = List(1,2,3,4,5,6,7,8,9,10);
// for 循環
var retVal = for{ a <- numList
if a != 3; if a < 8
}yield a
// 輸出返回值
for( a <- retVal){
println( "Value of a: " + a );
}
}
}
執行結果:
value of a: 1
value of a: 2
value of a: 4
value of a: 5
value of a: 6
value of a: 7
19.scala允許最後一個參數是可以重復的,通過在參數的類型之後放一個星號來設置可變參數,例如:
object Test {
def main(args: Array[String]) {
printStrings("Runoob", "Scala", "Python");
}
def printStrings( args:String* ) = {
var i : Int = 0;
for( arg <- args ){
println("Arg value[" + i + "] = " + arg );
i = i + 1;
}
}
}
執行結果為:
Arg value[0] = Runoob
Arg value[1] = Scala
Arg value[2] = Python
20. scala偏應用函數是一種表達式,你不需要提供函數所需要的所有參數,只需要提供部分參數,或不提供所需參數,例如:
import java.util.Date
object Test {
def main(args: Array[String]) {
val date = new Date
val logWithDateBound = log(date, _ : String)
logWithDateBound("message1" )
Thread.sleep(1000)
logWithDateBound("message2" )
Thread.sleep(1000)
logWithDateBound("message3" )
}
def log(date: Date, message: String) = {
println(date + "----" + message)
}
}
輸出結果為:
Mon Dec 02 12:53:56 CST 2013----message1
Mon Dec 02 12:53:56 CST 2013----message2
Mon Dec 02 12:53:56 CST 2013----message3
21. 在scala中無法直接操作方法,如果要操作方法,必須先將其轉換成函數。有兩種方法轉換成函數:
val f1 = m _
==在方法名稱m後面緊跟一個空格和下劃線告訴編譯器將方法m轉換成函數,而不是要調用這個方法。也可以顯示地告訴編譯器需要將方法轉換成函數:==
val f1:(Int) => Int = m
22.閉包是一個函數,返回值依賴於聲明在函數外部的一個或多個變量。如:
var factor = 3
val multiplier = (i:Int) => i * factor
這裏我們引入的一個自由變量factor,這個變量定義在函數外面,這樣定義的函數變量multiplier成為一個“閉包”,因為它引用到函數外面的定義的變量,定義這個函數的過程是將這個自由變量捕獲而構成一個封閉的函數。完整實例:
object Test {
def main(args: Array[String]) {
println( "muliplier(1) value = " + multiplier(1) )
println( "muliplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
}
輸出結果:
muliplier(1) value = 3
muliplier(2) value = 6
23.數組的定義與引用
一維數組創建
var z:Array[String] = new Array[String](3)
或
var z = new Array[String](3)
或
var z = Array("Runoob", "Baidu", "Google")
==引用第i元素,註意是(),而不是[]==
var myList = Array(1.9, 2.9, 3.4, 3.5)
println(myList(i))
多維數組定義
var myMatrix = ofDim[Int](3,3)
數組詳細介紹
24.scala集合分為可變集合和不可變集合,對可變集合本身可以進行增刪改操作,對不可變集合進行增刪改操作時,會返回一個新的集合,同時保證原有集合不發生改變。
集合詳細介紹
25.默認情況下scala使用不可變Map,如果你要使用可變集合,你需要顯式引入import scala.collection.mutable.Map類,在scala中你可以同時使用可變與不可變Map,可變的使用mutable.Map.
初始化不可變Map:
// 空哈希表,鍵為字符串,值為整型
var A:Map[Char,Int] = Map()
// Map 鍵值對演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
添加key-value對,使用+號,如下:
A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)
Map可以使用++運算符或者Map.++()方法來連接兩個Map,==Map合並時會移除重復的key==.
26.元組也是不可變的,但與列表不同的是元組可以包含不同類型的元素,元組的值是通過將單個的值包含在圓括號中構成的。例如:
val t = (1, 3.14, "Fred")
以上實例在元組中定義了三個元素,對應的類型分別為[Int, Double, java.lang.String]。也可以使用以上方式來定義:
val t = new Tuple3(1, 3.14, "Fred")
元組的實際類型取決於它的元素的類型,比如 (99, "runoob") 是 Tuple2[Int, String]。 (‘u‘, ‘r‘, "the", 1, 4, "me") 為 Tuple6[Char, Char, String, Int, Int, String]。
27.==目前scala支持的元組最大長度為22.對於更大長度可以使用集合,或者擴展元組。==
28.訪問元組的元素可以通過數字索引,如:
val t = (4,3,2,1)
我們可以使用t._1訪問第一個元素,t._2訪問第二個元素;
29.Scala Option(選項)類型用來表示一個值是可選的(有值或無值)。Option[T] 是一個類型為 T 的可選值的容器: 如果值存在, Option[T] 就是一個 Some[T] ,如果不存在, Option[T] 就是對象 None 。如:
// 雖然 Scala 可以不定義變量的類型,不過為了清楚些,我還是
// 把他顯示的定義上了
val myMap: Map[String, String] = Map("key1" -> "value")
val value1: Option[String] = myMap.get("key1")
val value2: Option[String] = myMap.get("key2")
println(value1) // Some("value1")
println(value2) // None
30.在類中重寫一個非抽象方法必須使用override修飾符;只有主構造函數才可以往基類的構造函數裏寫參數;在子類中重寫超類的抽象方法時,你不需要使用override關鍵字。
31.==在 Scala 中,是沒有 static 這個東西的,但是它也為我們提供了單例模式的實現方法,那就是使用關鍵字 object。Scala 中使用單例模式時,除了定義的類之外,還要定義一個同名的 object 對象,它和類的區別是,object對象不能帶參數。當單例對象與某個類共享同一個名稱時,他被稱作是這個類的伴生對象:companion object。你必須在同一個源文件裏定義類和它的伴生對象。類被稱為是這個單例對象的伴生類:companion class。類和它的伴生對象可以互相訪問其私有成員。==
單例對象實例:
/* 文件名:Marker.scala
* author:菜鳥教程
* url:www.runoob.com
*/
// 私有構造方法
class Marker private(val color:String) {
println("創建" + this)
override def toString(): String = "顏色標記:"+ color
}
// 伴生對象,與類共享名字,可以訪問類的私有屬性和方法
object Marker{
private val markers: Map[String, Marker] = Map(
"red" -> new Marker("red"),
"blue" -> new Marker("blue"),
"green" -> new Marker("green")
)
def apply(color:String) = {
if(markers.contains(color)) markers(color) else null
}
def getMarker(color:String) = {
if(markers.contains(color)) markers(color) else null
}
def main(args: Array[String]) {
println(Marker("red"))
// 單例函數調用,省略了.(點)符號
println(Marker getMarker "blue")
}
}
32.trait(特征)相當於Java的接口,與接口不同的是,它還可以定義屬性和方法的實現
scala筆記,主要摘自網絡教程