使用類型參數化數組（Array）

創建java.math.BigInteger實例：

var big = new java .math.BigInteget(“12345678”)

對數組進行訪問：圓括號形式

val greetingStrings :Array[String] = new Array[String] (3)

greetingStrings(0) = “hello”

注：val定義變量，變量不能被重新賦值，單變量內部指向的內部對象仍可以改變。

greetingStrings不能賦值成別的數組，但數組內部元素可以修改，因此數組本身是可變的。

Scala中所以操作符都是方法調用，任何對于對象的值參數應用將轉換為對apply方法的調用。

// 使用可變集合，用MAP得到可變的映射import scala.collection.mutable.Map class Test1 { }object Test1 extends App {def indexes ( s : String) :Map[Char ,List[Int]] ={var freq = Map [Char,List[Int]]()for (i <- 0 until s.length()){if (freq.contains(s(i))){var c =s(i)freq(c)=freq(c) ::: List(i)}elsefreq = freq + (s(i) -> List(i))}freq}println(indexes("abcabcdefg")) }// 使用可變集合，用MAP得到不可變的映射import scala.collection.immutable.Map import scala.collection.mutable.ArrayBuffer class Test1 { }object Test1 extends App {def indexes ( s : String) :Map[Char ,List[Int]] ={val freq = Map [Char,List[Int]]()val freq2 = Map [Char,List[Int]]()val charArray= new ArrayBuffer[Char]var numArray= new ArrayBuffer[List[Int]]for (i <- 0 until s.length()){if (charArray.contains(s(i))){numArray(charArray.indexOf(s(i)))=numArray(charArray.indexOf(s(i))):::List(i)}elsecharArray+=s(i)numArray+=List(i)}charArray.zip(numArray).toMap}println(indexes("abcabcdefg"))}

?

?

使用列表（List）

a)?定義： val onelist = List (1,2,3)

b)?疊加：val onetwo = onelist:::twolist

??Val three = 1::onelist

??Val fourlist = 1:: 2::3::4::Nil

注：列表是不可變的,不能通過賦值改變列表的元素。列表具有遞歸結構（如鏈接鏈表：linkedlist），而數組是連續的。

c)?插入排序：

?

def isort(xs:List[Int]) :List[Int]={if(xs.isEmpty) Nilelseinsert(xs.head,isort(xs.tail))}def insert(x:Int,xs:List[Int]):List[Int] ={if(xs.isEmpty||x<=xs.head) x::xselsexs.head::insert(x,xs.tail)}

?

d)?訪問列表尾部：init 方法和last方法

Last返回（非空）列表的最后一個元素，init返回除最后一個元素之外余下的列表。

e)?翻轉列表：reverse方法

Ancde.reverse

Reverse創建了新的列表而不是就地改變被操作的列表

f)?前綴與后綴：drop、take、splitAt

Drop和take操作范化了tail和init，可以返回任意長度的前綴或后綴

Xs take n 返回列表前n個元素、xs drop n返回列表除了前n個元素之外的所有元素

splitAt 在指定位置拆分列表，并返回對偶（pair）列表，避免了對列表的二次遍歷：

??????xs splitAt n 等價于 (xs take n,xs drop n)

g)?拉鏈操作：zip 把兩個列表組成一個對偶列表，兩列表長度不一致時，任何不能匹配的元素將被丟掉：

Val zipped = abcde zip List(1,2,3)

將列表元素與索引值鏈在一起：

Abcde.zipWithIndex

h)?顯示列表：toString方法和mkString方法

i)?toString操作返回列表的標準字符串表達形式

abcde.toString //String=List(a,b,c,d,e)

ii) abcde mkString(“[”,”,”,”]”) // String =[a,b,c,d,e]

3.1 ?List類的高階方法

a) 列表間映射：map、flatMap、foreach

Xs map f 以類型為List[T]的列表xs和類型為T=》U的函數f為操作元，返回把函數f應用在xs的每個列表元素之后由此組成的新列表。

List(1,2,3) map (_+1) ??// ??List[Int] = List(2,3,4)

flatMap操作符與map類似，不過它的右操作元是能夠返回元素列表的函數。它對列表的每個元素調用該方法，然后鏈接所有的方法結果并返回。

?

Words map (_.toList) ?

// List[List[Char]] = List(List(t,h,e),List(q,u,I,c,k))

Words flatMap (_.toList)

// List[Char] = List( t,h,e,q,u,I,c,k)

區別：map返回的是包含列表的列表，而flatMap返回的是把所有元素列表連接之后的單個列表。

Foreach:右操作元是過程（返回類型為Unit的函數），對每個元素都調用一遍過程，不返回結果列表

List (1,2,3,4,5) foreach (sum+=_)

b) 列表過濾：filter、partition、find、takeWhile、dropWhile、span

x filter p 把類型為Listp[T]的列表xs和類型為T=>Boolean的論斷函數作為操作元，產生xs中符合p（x）為true的所以元素x組成的列表。

List(1,2,3,4,5) filter ( _ % 2 == 0 )

Partition 與filter類似，但返回的是列表對。其中一個包含所以論斷為真的元素，另一個包含所以論斷為假的元素。

Xs partition p 等價于 （xs filter p ,xs filter(!p())）

List(1,2,3,4,5) partition (_%2 == 0)

// (List[Int],List[Int]) = (List(2,4),List(1,3,5))

Find方法返回第一個滿足給定論斷的元素，而非全部。若都不成立返回None

List(1,3,4) find (_%2==0)

//Option[Int] = Some(4)

xs takeWhile p 返回列表中xs最長的滿足p的前綴，drop移除最長能夠滿足p的前綴

span 方法把takeWhile和 dropWhile組合成一個操作，返回一堆列表。

c) 列表的推斷：forall 和 exists

xs forall p 如果列表所以元素滿足p 返回true

xs exists p 如果列表有一個元素滿足p 返回true

d) 列表的排序：

xs sortWith before 可以對列表的元素進行排序,before是比較的方法

List(1,3,2) sortWith (_<_)

Words sortWith (_.length >_.length)

e)List 對象的方法

List.apply(1,2,3)

List.range(1,5)

List.make(5,’a’) // ?List(a,a,a,a,a)

List.unzip(zipped)

f) 連接鏈表

????xs.flatten (a)

List.concat(a,xs,List(1,2,3))

歸并排序：

?

def msort[T](less : (T,T) => Boolean)(xs :List[T] ) :List[T] ={def merge(xs:List[T],ys:List[T]):List[T]=(xs,ys) match {case (Nil,_) => yscase (_,Nil) => xscase (x::xs1,y::ys1) =>if (less(x,y)) x::merge(xs1,ys)else y::merge(xs,ys1)}val n=xs.length / 2if(n==0) xselse{val(ys,zs) = xs splitAt nmerge(msort(less)(ys),msort(less)(zs))}}val less = (x:Int,y:Int) => if (x < y) true else false val mylist =List(1,3,5,6,0,2)println(msort(less)(mylist))

?

?

使用集（Set）和映射（Map）

a)?Scala 的集合（collection）庫區分可變類型和不可變類型，對于set 和map ，包含可變不可變版本，在不同包中。

b)?集（Set）是不重復元素的集合。嘗試將已有元素加入沒有效果，集并不保留元素的插入的順序，缺省情況下，集是以哈希集實現的，其元素根據hashCode方法的值進行組織。

c)?鏈式哈希集可以記住元素被插入的順序，它會維護一個鏈表來達到這個目的，如： ?????????val weekdays = scala.collection.mutable.LinkedHashSet(“Mo”,”Tu”,”We”,”Th”,”Fr”) ?????如果你想要按照已排序的順序來訪問集中的元素，用已排序的集： ??????????????????????????scala.collection.immutable.SortedSet(1,2,3,4,5,6),已排序的集是用紅黑樹實現的。

d)?檢查集是否包含給定的值：val digits =Set(1,5,6,0) ;digits contains 0 //false

e)?檢查某個集元素是否被另一個集所包含 Set(1,0) subsetOf digits //true

f)?Digits union(++) primes聯合 digits diff(--) primes 移除primes中與digits相同的元素

g)?一般而言，+用于將元素添加到無先后次序的集合，而+： 和：+是將元素添加到有先后次序的集合的開頭或末尾。Vector(1,2):+5 ;1+:Vector（1，2，3）；val numbers =ArrayBuffer(1,2,3); numbers+=5

h)?對于不可變集合，你可以在var上使用+=或：+= ， ???????????????????????????????????????????var numbers=Set(1,2,3)

Numbers+= 6

i)?使用映射：

val map =scala.collection.mutable.Map.empty[String,Int]//> map : scala.collection.mutable.Map[String,Int] = Map() map("hello") =1//> Map(hello -> 1) j) 對單詞進行計數def countWords(text :String) ={val counts = scala.collection.mutable.Map.empty[String,Int]for (rawWord <- text.split("[ ,!.]+")){val word= rawWord.toLowerCaseval oldcount =if (counts.contains(word)) counts(word)else0counts +=(word -> (oldcount+1))}counts}

?

?

k)?映射的常用行為

?

?

將函數映射到集合

a)?Val ?names =List(“peter”,”sasdf”)

Name.map (_.toUpperCase)

Map方法將某個函數應用到集合的每個元素并產出其結果的集合

等同于 ?for(n<-names) yield n.toUpperCase

b)?如函數產出一個集合 而不是單個元素，使用flatMap將所有值串聯在一起。

c)?Collect方法用于偏函數---那些并沒有對所有可能的輸入值進行定義的函數，它產出被定義的所有參數的函數值的集合。

??????????“-3+4”.collect {case ‘+’?=>1 ;case’-’=>-1} ?//Vector(-1,1)

d)?應用函數到每個元素僅僅為了它的副作用而不關心函數值時使用foreach

Name.foreach(println)

?

從文件中讀取文本行

a)?引入包scala.io.Source

b)?Source.fromFile(args(0))嘗試打開制定的文件并返回Source對象，調用getLines函數，返回Iterator[String](返回枚舉器，一旦遍歷完枚舉器就失效，可通過調用toList轉換成List保存在內存中)

?

單例對象（Singleton對象）

a)?Scala不能定義靜態成員，而是代之定義單例對象。

b)?當單例對象與某個類共享一個名稱時，它被稱為這個類的伴生對象。不共享名稱為獨立對象。

c)?類和它的伴生對象必須定義在一個源文件里。

d)?類被稱為它的伴生對象的半生類，類和它的伴生對象可以相互訪問其私有成員。

e)?單例對象不帶參數，類可以。第一次被訪問的時候才被初始化。

Scala的基本類型

a)?整數類型：Byte,Short,Int,Long,Char

b)?數類型：整數類型+Float,Double

制造新集合（yield ）

a)?For{子句} yield {循環體}

b)?Def scalaFiles = {

For {

File<-fileshere

If file.getName.endWIth(“scala”)

}yield file

記住每次迭代，結果是包含所有產生值的集合對象。

object NQueens extends App{def isSafe(queen:(Int,Int),squeens: List[(Int,Int)]) : Boolean ={squeens forall (q => !inCheck(queen,q))}def inCheck(queen:(Int,Int),q :(Int,Int)) :Boolean={queen._1 ==q._1||queen._2==q._2||(queen._1 -q._1).abs ==( queen._2 - q._2).abs}def queens (n: Int):List[List [(Int,Int)]] ={def placeQueens (k: Int):List[List[(Int,Int)]] ={if( k==0 )List(List())elsefor {queens <- placeQueens(k-1)column <- 1 to nqueen =(k,column)if isSafe(queen,queens)} yield queen::queens}placeQueens(n)}println(queens(8))}

?

?

使用try表達式處理異常

a)?創建異常對象用throw拋出：

Throw new IllegalArgumentException

b)?捕獲異常

try?

???{

?????val?f?= new?FileReader("input.txt") ??//使用并關閉文件 ?

???}

???catch

???{

?????case?ex?:FileNotFoundException => new?FileReader("my.txt")

?????case?ex: IOException => throw?ex

?}

對象

a)?有狀態的對象

特質

a)?特質封裝方法和字段的定義，并可以通過混入類中重用它們，每個類只能繼承唯一的超類，類可以混入任意多個特質。

特質被定義后：

Trait P {

Def ph() {

Println(“hello,te”) } }

可以使用extends或with關鍵字，把它混入類中。

Extends ：隱式的繼承了特質的超類，如果想把特質混入顯式擴展超類的類里，可以用extends指明待擴展的超類，用with混入特質。

Class Animal

Clss Frog extends Animal with philosophical {

Override def toString =”green”

}

特質：像帶有具體方法的接口，但可以聲明字段和維持狀態值，可以用特質的定義做任何用類定義能做的事。

注：1）特質不能有任何“類”參數，即傳遞給類的主構造器的參數

2）不論類在哪個角落，super的調用是靜態綁定，特質中動態綁定?；烊氲骄唧w類中才被決定。

?

?

?

?

?

?

?

?

?

?

文件

a)?讀取行

調用scala.io.Source對象的getLines方法

import scala.io.Source

val?source = Source.fromFile("my.txt","UTF-8")

// 缺省字符編碼 ，可以省略編碼參數

Val lineIterator = source.getLines

//結果是一個迭代器，可以逐條處理這些行

for(l<-lineIterator) = 處理 l

將行放到數組或數組緩沖中：

Val lines = source.getLines.toArray

將整個文件讀取成一個字符串

Val contents = source.mkString

注：使用完Source對象后調用close : source.close

讀取詞法單元和數字

讀取源文件中所有以空格隔開的詞法單元：

a)?Val tokens = source.mkString.split(“\\S+”)

b)?用toInt或toDouble把字符串轉換成數字，讀取到數組中：

Val numbers = for (w<- tokens) yields w.toDouble

或 val numbers = tokens.map(_.toDouble)

b)?從URL或其他源讀取

Source 對象有讀取非文件源的方法：

Val source1 = Source.fromURL(http://hwisnf.com,”UTF-8”)

Val source2 = Source.fromString(“hello,world”) //從給定字符串讀取 –?調試

Val source3 = Source.stdin //從標準輸入讀取

讀取二進制文件

Scala沒有提供讀取二進制文件的方法，需要使用Java類庫：

import?java.io.File

import?java.io.FileInputStream

val?filename="myx.txt"

? ?val?file?= new?File(filename)

? ?val?in?= new?FileInputStream(file)

val?bytes?= new?Array[Byte](file.length.toInt)

in.read(bytes)

in.close

Scala 沒有內建的對寫入文件的支持。要寫入文本文件，可使用java.io.PrintWriter

?

a)??import?java.io.PrintWriter

?? val?out?= new?PrintWriter("myx.txt")

?? for?(i<- 1?to?100) out.println(i)

?? out.close

遍歷某目錄下所以子目錄

import?java.io.File

?? def?subdirs?(dir?:File) : Iterator[File]= {

???? val?children?= dir.listFiles.filter(_.isDirectory)

???? children.toIterator?++children.toIterator.flatMap(subdirs?_)

?? }

?? // 利用這個函數，你可以像這樣訪問所有子目錄

?? for?(d<- subdirs(dir)) 處理?d

?

轉載于:https://www.cnblogs.com/namhwik/p/5967885.html

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的Scala笔记整理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。