scala學習（一）

scala是純粹的面嚮對象語言，每一個操做都是方法調用。

scala也是函數式編程語言，它有兩種理念：一、函數式頭等值，在函數式語言中，函數也是值，與整數或字符串處於同一個地位。函數能夠被看成參數傳遞給其餘函數。二、程序的操做應該把輸入值映射爲輸出值而不是就地修改數據。

scala有不可變的列表、元組、映射表和集。

scala調用java中string對象中toInt方法是發現沒有，它會將java的String對象隱式轉換成Scala中的RichString對象，RichString有toInt方法。

1、變量定義

scala有兩種變量：var和val，val相似於java裏面的final變量。一但初始化了，val就不能再被賦值了。

*在java裏，返回的值得類型稱爲返回類型，在scala裏面稱爲結果類型。

*scala中的<-符號表明「其中」。若是要讀for(arg<-args)，就讀作「對於args中的arg」。

*不寫new List，由於「List.apply()」是定義在scala.List伴生對象中的工廠方法。

Nil是空列表的簡寫同List()

2、列表List的經常使用方法 

val t = "Will" :: "fill" :: "until" :: "Util" :: Nil

println(t(2))              //返回t列表上索引爲2（基於0）的元素，值爲until

println(t.count(s => s.length == 4))   //計算長度爲4的string元素個數爲3

println(t.take(2))   //返回前2個元素的t列表,值爲List("Will","fill")

println(t.takeRight(2))  //返回後2個元素的t列表,值List("until","Util")

println(t.drop(2))       // 返回去掉前兩個的t列表，值爲List("until","Util")

println(t.dropRight(2))      //去掉後兩個元素的t列表，值爲List("Will","fill" )

println(t.exists(s => s == "until"))    //判斷是否值爲"until"的字符串元素在t列表你,值爲：true

println(t.filter(s => s.length == 4))   //返回長度爲4的元素依次組成的新列表，值List("Will","fill","Util")

println(t.forall(s => s.endsWith("l")))  //判斷是否t列表裏面全部元素都一"l"結尾，值爲：true

t.foreach(s => print(s))    //對t列表每個元素執行print語句，值爲："WillfilluntilUtil"

t.foreach(print)     //於上相同，不過更簡潔(同上)

println(t.head)      //取第一個元素

println(t.last)        //取最後一個元素

println(t.tail)        //取除去列表第一個元素的其餘全部元素組成的列表

println(t.init)        //取除去列表最後一個元素的其餘全部元素組成的列表

println(t.isEmpty)     //判斷列表是否爲空，爲空true，不爲空false

println(t.length)        //返回列表元素數量

println(t.map(s => s + "y"))     //對列表中每一個元素都作一次表達式計算，並返回一個新的列表

println(t.mkString(","))            //將列表元素以，號隔開組成一個字符串

println(t.reverse)                     //倒轉這個列表的元素

//println(t.remove(s => s.length == 4))

println(t.filterNot ( s => s.length() == 4 ))      //過濾出元素長度不是4的，元素並返回，值爲：List("until")

//println(t.sort((s,t) => s.charAt(0).toLowerCase < t.charAt(0).toLowerCase))

println(t.sortWith((s,t) => s.charAt(0)< t.charAt(0)))   //將元素按默認排序。

println(t.partition(s=>s.length == 4))  //將元素分紅知足條件長度等於4的一個list與一個不知足條件的一個list

println(t.find(s=>s.length == 4 )) //將返回第一個知足條件的元素.幷包裝成option類型

println(t.span(s.startsWith("W")))  //span是遍歷每個元素是否知足傳入函數的條件,直到不知足的返回2個集合.(List("Will"),List("fill","until","Util")),這個函數太噁心了不知道有什麼用能夠自行測試

println(t.takeWhile(s.startsWith("W")))  //從第一開始直到返回false的那個元素.返回從第一個開始全部判斷爲true的元素

println(t.takeWhile(s.dropWith("W")))   //從第一開始直到返回false的那個元素.返回從第一個返回false的元素以後的全部元素

val  i = "SB" :: t   //加入一個元素返回一個新的列表

takeWhile (...)           等價於：while (...) { take }

dropWhile (...)           等價於：while (...) { drop }

span (...)          等價於：while (...) { take; drop }

3、集Set經常使用方法

var jetSet = Set("SB","MB")

jetSet += "NB"  //加入一個元素返回一個新的集

println(jetSet.contains("NB"))  //true

4、元組（Tuple）

var pair = (99,"test")

println(pair._1)//訪問索引爲一的元素。元組的索引從1開始

println(pair _2)

5、Map

var treasureMap = Map[Int,String]()

treasureMap += (1->"test") //添加一個key爲1，value爲"test"的值

treasureMap(1) //獲取key爲1的，value的值："test"

treasureMap.getOrElse("key",0)  //若是存在着返回這個key的value，若是不存在這個key返回一個給定默認值0

可變map：val map = new collection.mutable.HashMap[String,Int] 

                 新增一個鍵值對：map("key") = 1 或 map += ( "key" -> 1)

不可變map：var map = new collection.mutable.HashMap[String,Int] //必須的var的

                 新增一個鍵值對： map += ( "key" -> 1)

已排序map：var map = collection.SortedMap[String,Int]()    //不能夠new它是一個抽象的

                  新增一個鍵值對： map += ( "key" -> 1)

Option類型的值一般做爲Scala集合類型（List,Map等）操做的返回類型。 好比Map的get方法

6、Array、List、Set、Map、Tuple的異同

Array、List索引都是基於0的，Tuple索引是基於1的。

Array、List、Set、Map他們只能放入指定類型，Tuple能夠放入任意類型。

 

隨機生成字符串：BigInt.probablePrime(100,util.Random).toString(36)

import StringOps

charAt(0)下標爲0的字符變成char類型(基於0)

take(n)               從左到右取n個

takeRight(n)      從右到左取n個

drop(n)              除去前n個返回剩餘的String

dropRight(n)     除去後n個返回剩餘的String

 

7、ArrayBuffer或Array

import scala.collection.mutable.ArrayBuffer

val a = ArrayBuffer[Int]()

a.updte(0,0) 或者 a(0) = 0   //修改下標爲0的元素

a += 1                      //向數組中添加元素

a ++= Array(1,2,3)   //++=操做符能夠添加任何集合

a.trimEnd(2)             // 移除最後2個元素

a.insert(2,4)              //在下標爲2的位置插入4

a.insert(2,5,6,7)        //在下標爲2的位置插入多個元素5,6,7

a.remove(2)             //移除下標爲2的上的元素

a.remove(1,2)             //移除索引從1開始,刪除2個元素

a.count( _ > 0 )       //清點有多少的正元素 

a.sum  //計算元素的和

a.max  //取出最大值

a.min   //取出最小值

a.toArray                  //轉換成Array

ArrayBuffer(1,2,3).copyToArray(Array(4,5))   //左邊會覆蓋又遍的對應下標的元素。而且左邊要是右邊Array的超類

 1>Array

val a = Array[Int](10)         //這樣建立時建立一個長度爲1的定長數組，這個數組裏面發的是10

val a = new Array[Int](10)      //new是建立一個長度爲10的定長數組，默認值所有是0

val  arrayToMap = Array(("1",1),("2",2)).toMap

a.toBuffer          //轉換成ArrayBuffer

scala.util.Sorting.quickSort(a)            //a要是Array，它會修改a自己。

a.sortWith(_ < _)   //對a進行從小到大排序，返回一個新的Array，不會修改原有的Array

a mkString(",")    //一","號分割每一個元素返回這個逗號鏈接的字符串

a mkString("<",",",">")    //重載的方法，給先後加上指定開始符號和結束符號

8、多維數組

val arrays = Array.ofDim[Double](x,y)  //x行，y列

建立一規則多維數組

val arrays = new Array[Array[Int]](10)

for(i <- 0 until arrays.length){

    arrays(i) = new Array[Int](i+1)

}

**拉鍊操做

StringOps中的zip定義以下 

abstract def zip[B](that: GenIterable[B]): StringOps[(A, B)] 

GenIterable是可遍歷對象須要包含的trait，對於String來講，它是可遍歷的。可是它的遍歷是遍歷單個字母。 所

以拉鍊就針對每一個字母來進行。