Scala基礎教程（六）：字串、數組、集合_Scala

建立字串：

最直接的方法來建立一個字串的編寫方法是：

var greeting = "Hello world!";

or

var greeting:String = "Hello world!";

每當遇到一個字串在代碼中，編譯器建立String對象及其值，在這個樣本中使用：“Hello world!”，但如果你喜歡，可以給字串，因為這裡我已經在聲明中交替顯示。

object Test {

   val greeting: String = "Hello, world!"

   def main(args: Array[String]) {

      println( greeting )

   }

}

讓我們編譯和運行上面的程式，這將產生以下結果：

C:/>scalac Test.scala

C:/>scala Test

Hello, world!

C:/>

正如前面提到的，String類是不可變的，所以一旦它被建立,String對象不能改變。如果需要做大量修改字元的字串，那麼應該使用在Scala提供字串構建器類（ StringBuilder ）。 字串長度:

用於獲得關於對象的資訊的方法是已知的存取方法。可以使用字串使用一個存取方法是length()方法，它返回包含在字串對象中的字元數。

下面兩行代碼被執行之後，len 等於17：

object Test {

   def main(args: Array[String]) {

      var palindrome = "Dot saw I was Tod";

      var len = palindrome.length();

      println( "String Length is : " + len );

   }

}

讓我們編譯和運行上面的程式，這將產生以下結果：

C:/>scalac Test.scala

C:/>scala Test

String Length is : 17

C:/>

連接字串：

String類包括用於串連兩個字串的方法：

string1.concat(string2);

這返回一個string1將string2添加到它的末尾的一個新字串。也可以使用concat()方法用字串，如：

"My name is ".concat("Zara");

字串比較常用串連在一起，使用+運算子，如：

"Hello," + " world" + "!"

這將產生：

"Hello, world!"

讓我們來看看下面的例子：

object Test {

   def main(args: Array[String]) {

      var str1 = "Dot saw I was ";

      var str2 =  "Tod";

      println("Dot " + str1 + str2);

   }

}

讓我們編譯和運行上面的程式，這將產生以下結果：

C:/>scalac Test.scala

C:/>scala Test

Dot Dot saw I was Tod

C:/>

建立格式化字串：

已經有兩個方法：printf()和format()方法使用格式化數字列印輸出。 String類有一個等價類別的方法，format()，它返回一個String對象，而不是一個PrintStream對象。讓我們看看下面的例子，這是使用printf()方法：

object Test {

   def main(args: Array[String]) {

      var floatVar = 12.456

      var intVar = 2000

      var stringVar = "Hello, Scala!"

      var fs = printf("The value of the float variable is " +

                   "%f, while the value of the integer " +

                   "variable is %d, and the string " +

                   "is %s", floatVar, intVar, stringVar)

      println(fs)

   }

}

讓我們編譯和運行上面的程式，這將產生以下結果：

C:/>scalac Test.scala

C:/>scala Test

The value of the float variable is 12.456000, while the 

value of the integer var iable is 2000, and the 

string is Hello, Scala!()

C:/>

字串的方法：

以下是由java.lang.String類中定義，並且可以直接在Scala程式中使用方法列表：

SN

方法及描述

1

char charAt(int index) 
返回指定索引處的字元

2

int compareTo(Object o) 
該字串與另一個對象比較

3

int compareTo(String anotherString)
按字典順序比較兩個字串

4

int compareToIgnoreCase(String str) 
比較兩個字串字典順序，忽略大小寫差異

5

String concat(String str)
將指定字串添加這個字串的結尾處

6

boolean contentEquals(StringBuffer sb) 
返回true若且唯若此String表示的字元與指定的StringBuffer相同的序列

7

static String copyValueOf(char[] data) 
返回表示所指定的數組中的字元序列的字串

8

static String copyValueOf(char[] data, int offset, int count)
返回表示所指定的數組中的字元序列的字串。

9

boolean endsWith(String suffix) 
測試此字串是否以指定的尾碼結束。

10

boolean equals(Object anObject)
比較該字串和指定的對象。

11

boolean equalsIgnoreCase(String anotherString)
比較該字串到另一個字串，不考慮大小寫。

12

byte getBytes() 
將此String解碼使用平台的預設字元集的位元組序列，並將結果儲存到一個新的位元組數組。

13

byte[] getBytes(String charsetName
將此String解碼使用指定的字元集的位元組序列，並將結果儲存到一個新的位元組數組。

14

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
複製字元從這個字串到目標字元數組。

15

int hashCode()
返回此字串的雜湊碼。

16

int indexOf(int ch) 
返回此字串指定字元第一次出現處的索引。

17

int indexOf(int ch, int fromIndex) 
返回此字串指定的字元，開始搜尋指定索引處的第一次出現處的索引。

18

int indexOf(String str)
返回此字串的指定子第一次出現處的索引。

19

int indexOf(String str, int fromIndex)
返回此字串中第一次出現的指定子字串，開始在指定的索引處的索引。

20

String intern()
返回字串對象的規範表示。

21

int lastIndexOf(int ch) 
返回此字串指定字元最後一次出現處的索引。

22

int lastIndexOf(int ch, int fromIndex) 
返回此字串指定字元最後一次出現處的索引，搜尋開始向後指定索引處。

23

int lastIndexOf(String str)
返回此字串指定子的最右邊出現處的索引。

24

int lastIndexOf(String str, int fromIndex) 
返回此字串的指定子最後一次出現處的索引，搜尋開始向後指定索引處。

25

int length() 
返回此字串的長度。

26

boolean matches(String regex)
判斷此字串是否與給Regex匹配。

27

boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 
測試兩個字串地區是否相等。

28

boolean regionMatches(int toffset, String other, int ooffset, int len)
測試兩個字串地區是否相等。

29

String replace(char oldChar, char newChar)
返回通過用newChar更換oldChar中出現的所有該字串產生一個新的字串。

30

String replaceAll(String regex, String replacement
替換此字串匹配給定的Regex以給定替換的每個子字串。

31

String replaceFirst(String regex, String replacement) 
替換此字串匹配給定的Regex以給定替換的第一子字串。

32

String[] split(String regex) 
來此字串圍繞拆分給定的Regex的匹配。

33

String[] split(String regex, int limit) 
圍繞拆分給定的Regex的匹配來此字串。

34

boolean startsWith(String prefix)
測試此字串是否以指定的首碼開始。

35

boolean startsWith(String prefix, int toffset)
測試這個字串開頭是否以指定索引指定的首碼開始。

36

CharSequence subSequence(int beginIndex, int endIndex)
返回一個新的字元序列，它是此序列的子序列。

37

String substring(int beginIndex)
返回一個新字串，它是此字串的一個子字串。

38

String substring(int beginIndex, int endIndex)
返回一個新字串，它是此字串的一個子字串。

39

char[] toCharArray() 
這個字串到一個新的字元數群組轉換。

40

String toLowerCase()
將所有在這個字串的字元使用預設語言環境的規則轉換為小寫。

41

String toLowerCase(Locale locale)
將所有在此字串中的字元使用給定Locale的規則轉換為小寫。

42

String toString()
這個對象（這已經是一個字串。）本身被返回。

43

String toUpperCase() 
將所有的字元在這個字串使用預設語言環境的規則轉換為大寫。

44

String toUpperCase(Locale locale) 
將所有的字元在這個字串使用給定的Locale規則轉換為大寫。

45

String trim() 
返回字串的副本，以開頭和結尾的空白忽略。

46

static String valueOf(primitive data type x) 
返回傳遞的資料類型參數的字串表示。

 

 

Scala中提供了一種資料結構-數組，其中儲存相同類型的元素的固定大小的連續集合。數組用於儲存資料的集合，但它往往是更加有用認為數組作為相同類型的變數的集合。

取替聲明單個變數，如number0, number1, ..., 和number99，聲明一個陣列變數，如號碼和使用numbers[0]，numbers[1]，...，numbers[99]表示單個變數。本教程 介紹了如何聲明陣列變數，建立數組和使用索引的過程變數數組。數組的第一個元素的索引是數字0和最後一個元素的索引為元素的總數減去1。 聲明陣列變數：

要使用的程式的數組，必須聲明一個變數來引用數組，必須指定陣列變數可以引用的類型。下面是文法聲明陣列變數：

var z:Array[String] = new Array[String](3)

or

var z = new Array[String](3)

在這裡，z被聲明為字串數組，最多可容納三個元素。可以將值分配給獨立的元素或可以訪問單個元素，這是可以做到通過使用類似於以下命令：

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

在這裡，最後一個例子表明，在一般的索引可以是產生一個全數位運算式。定義數組還有另一種方式：

var z = Array("Zara", "Nuha", "Ayan")

下圖展示了數組myList。在這裡，myList中擁有10個double值,索引是從0到9。

處理數組：

當要處理數組元素，我們經常使用迴圈，因為所有的數組中的元素具有相同的類型，並且數組的大小是已知的。這裡是展示如何建立，初始化和處理數組的完整的例子：

object Test {

   def main(args: Array[String]) {

      var myList = Array(1.9, 2.9, 3.4, 3.5)

      // Print all the array elements

      for ( x <- myList ) {

         println( x )

      }

      // Summing all elements

      var total = 0.0;

      for ( i <- 0 to (myList.length - 1)) {

         total += myList(i);

      }

      println("Total is " + total);

      // Finding the largest element

      var max = myList(0);

      for ( i <- 1 to (myList.length - 1) ) {

         if (myList(i) > max) max = myList(i);

      }

      println("Max is " + max);

   }

}

讓我們編譯和運行上面的程式，這將產生以下結果：

C:/>scalac Test.scala

C:/>scala Test

1.9

2.9

3.4

3.5

Total is 11.7

Max is 3.5

C:/>

多維陣列：

有很多情況下，需要定義和使用多維陣列（即數組的元素數組）。例如，矩陣和表格結構的執行個體可以實現為二維數組。

Scala不直接支援多維陣列，並提供各種方法來處理任何尺寸數組。以下是定義的二維數組的執行個體：

var myMatrix = ofDim[Int](3,3)

這是一個具有每個都是整數，它有三個元素數組3元素的數組。下面的代碼展示了如何處理多維陣列：

import Array._

object Test {

   def main(args: Array[String]) {

      var myMatrix = ofDim[Int](3,3)

      // build a matrix

      for (i <- 0 to 2) {

         for ( j <- 0 to 2) {

            myMatrix(i)(j) = j;

         }

      }

      // Print two dimensional array

      for (i <- 0 to 2) {

         for ( j <- 0 to 2) {

            print(" " + myMatrix(i)(j));

         }

         println();

      }

   }

}

讓我們編譯和運行上面的程式，這將產生以下結果：

C:/>scalac Test.scala

C:/>scala Test

0 1 2

0 1 2

0 1 2

C:/>

聯結數組：

以下是使用concat()方法來串連兩個數組的例子。可以通過多個陣列作為參數傳遞給concat()方法。

import Array._

object Test {

   def main(args: Array[String]) {

      var myList1 = Array(1.9, 2.9, 3.4, 3.5)

      var myList2 = Array(8.9, 7.9, 0.4, 1.5)

      var myList3 =  concat( myList1, myList2)

      // Print all the array elements

      for ( x <- myList3 ) {

         println( x )

      }

   }

}

讓我們編譯和運行上面的程式，這將產生以下結果：

C:/>scalac Test.scala

C:/>scala Test

1.9

2.9

3.4

3.5

8.9

7.9

0.4

1.5

C:/>

建立具有範圍數組：

下面是樣本，這使得使用range() 方法來產生包含在給定的範圍內增加整數序列的數組。可以使用最後一個參數建立序列; 如果不使用最後一個參數，然後一步將被假定為1。

import Array._

object Test {

   def main(args: Array[String]) {

      var myList1 = range(10, 20, 2)

      var myList2 = range(10,20)

      // Print all the array elements

      for ( x <- myList1 ) {

         print( " " + x )

      }

      println()

      for ( x <- myList2 ) {

         print( " " + x )

      }

   }

}

讓我們編譯和運行上面的程式，這將產生以下結果：

C:/>scalac Test.scala

C:/>scala Test

10 12 14 16 18

10 11 12 13 14 15 16 17 18 19

C:/>

Scala中數組方法：

以下是重要的方法，可以同時使用數組。如上所示，則必須使用任何提及的方法之前，要匯入Array._包。有關可用方法的完整列表，請Scala中的官方檔案。

SN

方法及描述

1

def apply( x: T, xs: T* ): Array[T]
建立T對象，其中T可以是Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean數組。

2

def concat[T]( xss: Array[T]* ): Array[T]
串連所有陣列成一個數組。

3

def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
複製一個數組到另一個。相當於Java的System.arraycopy(src, srcPos, dest, destPos, length).

4

def empty[T]: Array[T]
返回長度為0的數組

5

def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]
返回一個包含一個函數的重複應用到初始值的數組。

6

def fill[T]( n: Int )(elem: => T): Array[T]
返回包含某些元素的計算的結果的次數的數組。

7

def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]
返回一個二維數組，其中包含某些元素的計算的結果的次數。

8

def iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T]
返回一個包含一個函數的重複應用到初始值的數組。

9

def ofDim[T]( n1: Int ): Array[T]
建立數組給出的尺寸。

10

def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]
建立了一個2維數組

11

def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]
建立3維數組

12

def range( start: Int, end: Int, step: Int ): Array[Int]
返回包含一些整數間隔等間隔值的數組。

13

def range( start: Int, end: Int ): Array[Int]
返回包含的範圍內增加整數序列的數組。

14

def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]
返回包含一個給定的函數的值超過從0開始的範圍內的整數值的數組。

15

def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]
返回一個包含給定函數的值超過整數值從0開始範圍的二維數組。

 

 

Scala有一組豐富的集合庫。集合是對事物的容器。這些容器可被測序，線性集像List, Tuple, Option, Map等集合的項目可具有元素的任意數量或有界到零個或一個元素(例如，Option)。

集合可能是嚴格或懶惰。懶集合有可能不消耗記憶體，直到他們被訪問，就像範圍元素。此外，集合可以是可變的(引用的內容可以更改)或不變(一個引用的東西指從未改變)。需要注意的是不可變的集合可能包含可變項。

對於一些問題，可變集合更好地工作，並為不可變集合更好地工作。如果有疑問，最好是先從一個不變的集合，如果需要可變變更。

本章給出最常用的集合類型對這些集合的資訊和使用最頻繁的操作。

SN

集合使用說明

1

Scala Lists
Scala的List[T]是T類型的鏈表

2

Scala Sets
集是相同類型的配對的不同元素的集合。

3

Scala Maps
映射是鍵/值對的集合。任何值可以根據它的鍵進行檢索。

4

Scala Tuples
不像數組或列表，元組可以容納不同類型的對象。

5

Scala Options
Option[T] 提供了一種容器，用於給定類型的零個或一個元素。

6

Scala Iterators
迭代不是集合，而是一種由一個訪問的集合之一的元素。 樣本:

下面的程式碼片段是一個簡單的例子來定義所有上述集合類型：

// Define List of integers.

val x = List(1,2,3,4)

// Define a set.

var x = Set(1,3,5,7)

// Define a map.

val x = Map("one" -> 1, "two" -> 2, "three" -> 3)

// Create a tuple of two elements.

val x = (10, "Scala")

// Define an option

val x:Option[Int] = Some(5)

 

 

類是一個對象的藍圖。一旦定義一個類可以建立從類藍圖使用關鍵字new建立對象。下面是一個簡單的文法在Scala中定義一個類：

class Yiibai(xc: Int, yc: Int) {

   var x: Int = xc

   var y: Int = yc

   def move(dx: Int, dy: Int) {

      x = x + dx

      y = y + dy

      println ("Yiibai x location : " + x);

      println ("Yiibai y location : " + y);

   }

}

這個類定義了兩個變數x和y和方法：move，沒有傳回值。類變數被調用，類的欄位和方法被稱為類方法。

類名可以作為一個類的建構函式，可以採取一些參數。上面的代碼定義了兩個建構函式的參數：xc和yc;它們都在類的主體內可見。

正如前面提到的，可以使用關鍵字new建立對象，然後可以按照下面的例子所示訪問類的欄位和方法：

import java.io._

class Yiibai(val xc: Int, val yc: Int) {

   var x: Int = xc

   var y: Int = yc

   def move(dx: Int, dy: Int) {

      x = x + dx

      y = y + dy

      println ("Yiibai x location : " + x);

      println ("Yiibai y location : " + y);

   }

}

object Test {

   def main(args: Array[String]) {

      val pt = new Yiibai(10, 20);

      // Move to a new location

      pt.move(10, 10);

   }

}

當上述代碼被編譯和執行時，它產生了以下結果：

C:/>scalac Test.scala

C:/>scala Test

Yiibai x location : 20

Yiibai y location : 30

C:/>from: http://www.yiibai.com/scala/scala_basic_syntax.html