您的位置：首页 > 其它

Scala基础教程（六）：字符串、数组、集合

2015-12-10 12:32 585 查看

创建字符串：

最直接的方法来创建一个字符串的编写方法是：

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)
判断此字符串是否与给正则表达式匹配。

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
替换此字符串匹配给定的正则表达式以给定替换的每个子字符串。

31

String replaceFirst(String regex, String replacement) 
替换此字符串匹配给定的正则表达式以给定替换的第一子字符串。

32

String[] split(String regex) 
来此字符串围绕拆分给定的正则表达式的匹配。

33

String[] split(String regex, int limit) 
围绕拆分给定的正则表达式的匹配来此字符串。

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
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签：  Scala 基础教程 字符串 数组 集合
相关文章推荐
新的分享
章节导航