scala 基础随手记

scala 中和java不同的数据类型： 

Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null 或空引用
Nothing	Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
Any	Any是所有其他类的超类
AnyRef	AnyRef类是Scala里所有引用类(reference class)的基类

scala没有java中的原生类型。在 scala 中是可以对数字等基础类型调用方法的。

多行字符串的表示方法

多行字符串用三个双引号来表示分隔符，格式为：""" ... """。

Scala 转义字符

下表列出了常见的转义字符：

转义字符	Unicode	描述
\b	\u0008	退格(BS) ，将当前位置移到前一列
\t	\u0009	水平制表(HT) （跳到下一个TAB位置）
\n	\u000a	换行(LF) ，将当前位置移到下一行开头
\f	\u000c	换页(FF)，将当前位置移到下页开头
\r	\u000d	回车(CR) ，将当前位置移到本行开头
\"	\u0022	代表一个双引号(")字符
\'	\u0027	代表一个单引号（'）字符
\\	\u005c	代表一个反斜线字符 '\'

变量声明

在学习如何声明变量与常量之前，我们先来了解一些变量与常量。

• 一、变量： 在程序运行过程中其值可能发生改变的量叫做变量。如：时间，年龄。
• 二、常量 在程序运行过程中其值不会发生变化的量叫做常量。如：数值 3，字符'A'。

在 Scala 中，使用关键词 "var" 声明变量，使用关键词 "val" 声明常量。

声明变量实例如下：

var myVar : String = "Foo"
var myVar : String = "Too"

以上定义了变量 myVar，我们可以修改它。

声明常量实例如下：

val myVal : String = "Foo"

以上定义了常量 myVal，它是不能修改的。如果程序尝试修改常量 myVal 的值，程序将会在编译时报错。

变量类型声明

变量的类型在变量名之后等号之前声明。

变量声明一定需要初始值，否则会报错。

变量类型引用

在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。

所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。

var myVar = 10;
val myVal = "Hello, Scala!";

以上实例中，myVar 会被推断为 Int 类型，myVal 会被推断为 String 类型。

Scala 多个变量声明

Scala 支持多个变量的声明：

val xmax, ymax = 100  // xmax, ymax都声明为100

如果方法返回值是元组，我们可以使用 val 来声明一个元组：

scala> val pa = (40,"Foo")
pa: (Int, String) = (40,Foo)

元组

Scala元组将固定数量的项目组合在一起，以便它们可以作为一个整体传递。 与数组或列表不同，元组可以容纳不同类型的对象，但它们也是不可变的。

以下是一个存有整数，字符串和控制台(console)的元组的示例。

val t = (1, "hello", Console)

上面是以下语法的简写 -

val t = new Tuple3(1, "hello", Console)

元组的实际类型取决于它包含的数量和元素以及这些元素的类型。 因此，(99，"Luftballons")的类型是Tuple2 [Int，String]。 ('u'，'r'，“the”，1,4，"me")是Tuple6 [Char，Char，String，Int，Int，String]。

元组是类型Tuple1，Tuple2，Tuple3等等。目前在Scala中只能有22个上限，如果您需要更多个元素，那么可以使用集合而不是元组。

Scala定义了许多元素访问方法。给定以下定义 -

val t = (4,3,2,1)

要访问元组t的元素，可以使用t._1方法访问第一个元素，t._2方法访问第二个元素，依此类推。 例如，以下表达式计算t的所有元素的总和 -

val sum = t._1 + t._2 + t._3 + t._4

私有(Private)成员

用 private 关键字修饰，带有此标记的成员仅在包含了成员定义的类或对象内部可见，同样的规则还适用内部类。

class Outer{
    class Inner{
    private def f(){println("f")}
    class InnerMost{
        f() // 正确
        }
    }
    (new Inner).f() //错误
}

(new Inner).f( ) 访问不合法是因为 f 在 Inner 中被声明为 private，而访问不在类 Inner 之内。

但在 InnerMost 里访问 f 就没有问题的，因为这个访问包含在 Inner 类之内。

Java中允许这两种访问，因为它允许外部类访问内部类的私有成员。

------------------------------------------------------------------------------------------------------------------------------------------------

保护(Protected)成员

在 scala 中，对保护（Protected）成员的访问比 java 更严格一些。因为它只允许保护成员在定义了该成员的的类的子类中被访问。而在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。

package p{
class Super{
    protected def f() {println("f")}
    }
    class Sub extends Super{
        f()
    }
    class Other{
        (new Super).f() //错误
    }
}

上例中，Sub 类对 f 的访问没有问题，因为 f 在 Super 中被声明为 protected，而 Sub 是 Super 的子类。相反，Other 对 f 的访问不被允许，因为 other 没有继承自 Super。而后者在 java 里同样被认可，因为 Other 与 Sub 在同一包里。

---------------------------------------------------------------------------------------------------------------------------------------------------------------

for循环

语法

Scala 语言中 for 循环的语法：

for( var x <- Range ){
   statement(s);
}

以上语法中，Range 可以是一个数字区间表示 i to j (包括j)，或者 i until j(不包括j)。左箭头 <- 用于为变量 x 赋值。

在 for 循环 中可以使用分号 (;) 来设置多个区间，它将迭代给定区间所有的可能值。以下实例演示了两个区间的循环实例：

object Practice {
  def main(args: Array[String]): Unit = {
    var a = 0
    var b = 0
    for(a <- 1 to 3 ; b <- 1 to 3){
      println("a = " + a)
      println("b = " + b)
      println("------------------")
    }
  }
}

a = 1
b = 1
------------------
a = 1
b = 2
------------------
a = 1
b = 3
------------------
a = 2
b = 1
------------------
a = 2
b = 2
------------------
a = 2
b = 3
------------------
a = 3
b = 1
------------------
a = 3
b = 2
------------------
a = 3
b = 3
------------------

for 循环集合

for 循环集合的语法如下：

for( var x <- List ){
   statement(s);
}

以上语法中， List 变量是一个集合，for 循环会迭代所有集合的元素。

object Practice {
  def main(args: Array[String]): Unit = {
    var a = 0
    val mylist = List(1,2,3,4,5)
    for(a <-  mylist){
      println("a = " + a)
    }
  }
}

a = 1
a = 2
a = 3
a = 4
a = 5

for 循环过滤

Scala 可以使用一个或多个 if 语句来过滤一些元素。

以下是在 for 循环中使用过滤器的语法。

for( var x <- List
      if condition1; if condition2...
   ){
   statement(s);

可以使用分号(;)来为表达式添加一个或多个的过滤条件。

object Practice {
  def main(args: Array[String]): Unit = {
    var a = 0
    val mylist = List(1,2,3,4,5,6,7,8,9,10)
    for(a <-  mylist
      if a != 3 ; if a < 8){
      println("a = " + a)
    }
  }
}

a = 1
a = 2
a = 4
a = 5
a = 6
a = 7

for 使用 yield

可以将 for 循环的返回值作为一个变量存储。语法格式如下：

var retVal = for{ var x <- List
     if condition1; if condition2...
}yield x

注意大括号中用于保存变量和条件，retVal 是变量， 循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。

object Practice {
  def main(args: Array[String]): Unit = {
    var a = 0
    val mylist = List(1,2,3,4,5,6,7,8,9,10)
    val ret = for{a <-  mylist//注意是大括号
      if a != 3 ; if a < 8
    }yield a

    //输出返回值
    for(a <- ret){
      println("a = " + a)
    }

  }

a = 1
a = 2
a = 4
a = 5
a = 6
a = 7

Scala 方法与函数

Scala 有方法与函数，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。

Scala 中的方法跟 Java 的类似，方法是组成类的一部分。

Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。

Scala 中使用 val 语句可以定义函数，def 语句定义方法。

class Test{
  def m(x: Int) = x + 3
  val f = (x: Int) => x + 3
}

方法声明

Scala 方法声明格式如下：

def functionName ([参数列表]) : [return type]

如果不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型于是也是一个抽象类型。

方法定义

方法定义由一个 def 关键字开始，紧接着是可选的参数列表，一个冒号 : 和方法的返回类型，一个等于号 = ，最后是方法的主体。

Scala 方法定义格式如下：

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

以上代码中 return type 可以是任意合法的 Scala 数据类型。参数列表中的参数可以使用逗号分隔。

以下方法的功能是将两个传入的参数相加并求和：

object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

如果方法没有返回值，可以返回为 Unit，这个类似于 Java 的 void, 实例如下：

object Hello{
   def printMe( ) : Unit = {
      println("Hello, Scala!")
   }
}

方法调用

Scala 提供了多种不同的方法调用方式：

以下是调用方法的标准格式：

functionName( 参数列表 )

如果方法使用了实例的对象来调用，我们可以使用类似java的格式 (使用 . 号)：

[instance.]functionName( 参数列表 )

以上实例演示了定义与调用方法的实例:

object Practice {
  def main(args: Array[String]): Unit = {
    println("a+b=" + addInt(5,6))
    }
  def addInt (a:Int, b:Int): Int = {
    var sum: Int = 0
    sum = a + b
    return sum



  }
}

a+b=11

Scala 函数 - 可变参数

Scala 允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。

Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。例如：

object Practice {
  def main(args: Array[String]): Unit = {
    printStrings("abc","def","ghi")
  }
  def printStrings(args: String*)={
    var i = 0
    for(arg <- args){
      println("Arg value[" + i +"]:" + arg)
      i = i +1
    }



  }

Arg value[0]:abc
Arg value[1]:def
Arg value[2]:ghi

Scala 递归函数

递归函数在函数式编程的语言中起着重要的作用。

Scala 同样支持递归函数。

递归函数意味着函数可以调用它本身。

以上实例使用递归函数来计算阶乘：

object Practice {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 5){
      println(i + "的阶乘：" + factorial(i))
    }

  }
  def factorial(n: Int) : BigInt={
    if (n <= 1){
      return 1
    }
    else
      return n * factorial(n-1)
  }
}

1的阶乘：1
2的阶乘：2
3的阶乘：6
4的阶乘：24
5的阶乘：120

Scala 函数 - 默认参数值

Scala 可以为函数参数指定默认参数值，使用了默认参数，在调用函数的过程中可以不需要传递参数，这时函数就会调用它的默认参数值，如果传递了参数，则传递值会取代默认值。实例如下：

object Practice {
  def main(args: Array[String]): Unit = {
    println("返回值" + addInt())
    println("------------------------------------")
    println("返回值" + addInt(5,7))

  }
  def addInt(a:Int=8,b:Int=6) : Int={
    var sum = 0
    sum = a+b
    return sum
  }
}

返回值14
------------------------------------
返回值12

Scala 匿名函数

Scala 中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。

使用匿名函数后，我们的代码变得更简洁了。

下面的表达式就定义了一个接受一个Int类型输入参数的匿名函数:

var inc = (x:Int) => x+1

上述定义的匿名函数，其实是下面这种写法的简写：

def add2 = new Function1[Int,Int]{  
    def apply(x:Int):Int = x+1;  
} 

以上实例的 inc 现在可作为一个函数，使用方式如下：

var x = inc(7)-1

同样可以在匿名函数中定义多个参数：

var mul = (x: Int, y: Int) => x*y

mul 现在可作为一个函数，使用方式如下：

println(mul(3, 4))

我们也可以不给匿名函数设置参数，如下所示：

var userDir = () => { System.getProperty("user.dir") }

userDir 现在可作为一个函数，使用方式如下：

println( userDir() )

实例：

object Practice {
  def main(args: Array[String]): Unit = {
    println("返回值" + addInt(5,8))

  }
  //定义匿名函数
  def addInt = (a:Int,b:Int) => a + b

}

返回值13

Scala 函数柯里化(Currying)

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。

实例

首先我们定义一个函数:

def add(x:Int,y:Int)=x+y

那么我们应用的时候，应该是这样用：add(1,2)

现在我们把这个函数变一下形：

def add(x:Int)(y:Int) = x + y

那么我们应用的时候，应该是这样用：add(1)(2),最后结果都一样是3，这种方式（过程）就叫柯里化。

实现过程

add(1)(2) 实际上是依次调用两个普通函数（非柯里化函数），第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。

实质上最先演变成这样一个方法：

def add(x:Int)=(y:Int)=>x+y

那么这个函数是什么意思呢？ 接收一个x为参数，返回一个匿名函数，该匿名函数的定义是：接收一个Int型参数y，函数体为x+y。现在我们来对这个方法进行调用。

val result = add(1) 

返回一个result，那result的值应该是一个匿名函数：(y:Int)=>1+y

所以为了得到结果，我们继续调用result。

val sum = result(2)

最后打印出来的结果就是3。

object Practice {
  def main(args: Array[String]): Unit = {
    val str1 = "hello,"
    val str2 = "world"
    println(strcat(str1)(str2))

  }
  def strcat(str1:String)(str2:String) = {
    str1 + str2
  }

}

hello,world

Scala 闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

如下面这段匿名的函数：

val multiplier = (i:Int) => i * 10  

函数体内有一个变量 i，它作为函数的一个参数。如下面的另一段代码：

val multiplier = (i:Int) => i * factor

在 multiplier 中有两个变量：i 和 factor。其中的一个 i 是函数的形式参数，在 multiplier 函数被调用时，i 被赋予一个新的值。然而，factor不是形式参数，而是自由变量，考虑下面代码：

var factor = 3  
val multiplier = (i:Int) => i * factor  

这里我们引入一个自由变量 factor，这个变量定义在函数外面。

这样定义的函数变量 multiplier 成为一个"闭包"，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。

实例

object Practice {
  def main(args: Array[String]): Unit = {
    println("mult(2)= " + mult(2))
    println("mult(3)= " + mult(3))

  }
  val factor = 2
//  def mult(i:Int):Int={
//    i * factor
//  }
  //也可用匿名函数
  var mult = (i:Int)=>i*factor

}

mult(2)= 4
mult(3)= 6

Scala 字符串

在 Scala 中，字符串的类型实际上是 Java String，它本身没有 String 类。

在 Scala 中，String 是一个不可变的对象，所以该对象不可被修改。这就意味着如果修改字符串就会产生一个新的字符串对象。

如果需要创建一个可以修改的字符串，可以使用 String Builder 类，如下实例:

object Practice {
  def main(args: Array[String]): Unit = {
   var buf = new StringBuilder
    buf += 'a'
    buf ++= "bcd"
    println("buf is " + buf.toString())

  }
}

buf is abcd

字符串连接

String 类中使用 concat() 方法来连接两个字符串：

string1.concat(string2);

实例

object Practice {
  def main(args: Array[String]): Unit = {
    val str1 = "abc"
    val str2 = str1.concat("def")
    println(str2)

  }
}

abcdef

同样也可以使用加号(+)来连接：

object Practice {
  def main(args: Array[String]): Unit = {
    val str1 = "scala 教程，"
    val str2 = "大数据必备"
    println(str1 + str2)

  }
}

scala 教程，大数据必备

String 方法

下表列出了 java.lang.String 中常用的方法，可以在 Scala 中使用：

序号	方法及描述
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) 将此字符串与指定的 StringBuffer 比较。
7	static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String
8	static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String
9	boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束
10	boolean equals(Object anObject) 将此字符串与指定的对象比较
11	boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写
12	byte getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
13	byte[] getBytes(String charsetName 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
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 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
31	String replaceFirst(String regex, String replacement) 使用给定的 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() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写
41	String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写
42	String toString() 返回此对象本身（它已经是一个字符串！）
43	String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写
44	String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写
45	String trim() 删除指定字符串的首尾空白符
46	static String valueOf(primitive data type x) 返回指定类型参数的字符串表示形式

Scala 数组

Scala 语言中提供的数组是用来存储固定大小的同类型元素，数组对于每一门编辑应语言来说都是重要的数据结构之一。

声明数组

以下是 Scala 数组声明的语法格式：

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

或

var z = new Array[String](3)

以上语法中，z 声明一个字符串类型的数组，数组长度为 3 ，可存储 3 个元素。我们可以为每个元素设置值，并通过索引来访问每个元素，如下所示：

z(0) = "Runoob"; z(1) = "Baidu"; z(4/2) = "Google"

我们也可以使用以下方式来定义一个数组：

var z = Array("Runoob", "Baidu", "Google")

处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本的 for 循环。

以下实例演示了数组的创建，初始化等处理过程：

object Practice {
  def main(args: Array[String]): Unit = {
    val mylist = Array(2.3,4.7,3.6,7.1,5.5)
    println("打印元素")
    for(a <- mylist){
      println(a)
    }
    var sum = 0.0
    for(i <- 0 until mylist.length){
      sum += mylist(i)
    }
    println("和为 " + sum)
    var max = 0.0
    for(i <- 0 until mylist.length){
      if (mylist(i) > max){
        max = mylist(i)
      }
    }
    println("最大值为 " + max )

  }
}

打印元素
2.3
4.7
3.6
7.1
5.5
和为 23.2
最大值为 7.1

多维数组

多维数组一个数组中的值可以是另一个数组，另一个数组的值也可以是一个数组。矩阵与表格是我们常见的二维数组。

以上是一个定义了二维数组的实例：

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

实例中数组中包含三个数组元素，每个数组元素又含有三个值。

合并数组

以下实例中，我们使用 concat() 方法来合并两个数组，concat() 方法中接受多个数组参数：

import Array._
object Practice {
  def main(args: Array[String]): Unit = {
    val list1 = Array(1,2,3,4,5)
    val list2 = Array(6,7,8,9,10)
    val mylist = concat(list1,list2)
    for(i <- 0 until mylist.length){
      print(mylist(i) + " ")
    }

  }
}

1 2 3 4 5 6 7 8 9 10 

创建区间数组

以下实例中，使用了 range() 方法来生成一个区间范围内的数组。range() 方法最后一个参数为步长，默认为 1：

import Array._
object Practice {
  def main(args: Array[String]): Unit = {
    var arr1 = range(10,20,2)
    var arr2 = range(10,20)
    println("数组1：")
    for (i <- 0 until arr1.length){
      print(arr1(i) + " ")
    }
    println()
    println("数组2：")
    for (i <- 0 until arr2.length){
      print(arr2(i) + " ")
    }

  }
}

数组1：
10 12 14 16 18 
数组2：
10 11 12 13 14 15 16 17 18 19 

Scala 数组方法

下表中为 Scala 语言中处理数组的重要方法，使用它前需要使用 import Array._ 引入包。

序号	方法和描述
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's 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] 返回指定长度数组，每个数组元素为指定函数的返回值。 以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1： scala> Array.iterate(0,3)(a=>a+1) res1: Array[Int] = Array(0, 1, 2)
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 ofDim[T]( n1: Int ): Array[T] 创建指定长度的数组
9	def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] 创建二维数组
10	def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] 创建三维数组
11	def range( start: Int, end: Int, step: Int ): Array[Int] 创建指定区间内的数组，step 为每个元素间的步长
12	def range( start: Int, end: Int ): Array[Int] 创建指定区间内的数组
13	def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] 返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。 以上实例返回 3 个元素： scala> Array.tabulate(3)(a => a + 5) res0: Array[Int] = Array(5, 6, 7)
14	def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] 返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。

map操作和flatMap操作 

map操作

map操作是针对集合的典型变换操作，它将某个函数应用到集合中的每个元素，并产生一个结果集合。
比如，给定一个字符串列表，我们可以通过map操作对列表的中每个字符串进行变换，让每个字符串都变成大写字母，这样变换后就可以得到一个新的集合。下面我们在Scala命令解释器中，演示这个过程：

scala> val books = List("Hadoop", "Hive", "HDFS")
books: List[String] = List(Hadoop, Hive, HDFS)
scala> books.map(s => s.toUpperCase)
res0: List[String] = List(HADOOP, HIVE, HDFS)

至于下面的表达式：

s => s.toUpperCase

这种表达式被称为“Lamda表达式”，在Java8以后有引入这种新的特性，Scala也拥有该特性。（备注：前面的“函数式编程”内容有讲到Lambda表达式）
“Lambda表达式”的形式如下：

(参数) => 表达式 //如果参数只有一个，参数的圆括号可以省略

可以看出，Lambda表达式实际上是一种匿名函数，大大简化代码编写工作。s => s.toUpperCase，它的含义是，对于输入s，都都执行s.toUpperCase操作。

flatMap操作

flatMap是map的一种扩展。在flatMap中，我们会传入一个函数，该函数对每个输入都会返回一个集合（而不是一个元素），然后，flatMap把生成的多个集合“拍扁”成为一个集合。
下面我们在Scala解释器中执行下面代码（下面同时包含了解释器运行代码的反馈结果）：

scala> val books = List("Hadoop","Hive","HDFS")
books: List[String] = List(Hadoop, Hive, HDFS)
scala> books flatMap (s => s.toList)
res0: List[Char] = List(H, a, o, o, p, H, i, v, e, H, D, F, S)

上面的flatMap执行时，会把books中的每个元素都调用toList，生成List[Char]，最终，多个Char的集合被“拍扁”成一个集合。

这里再补充说明一下：上面代码中books flatMap (s => s.toList)这种形式的代码，可以参考之前介绍过的：

a 方法 b

a.方法(b)

上面二者是等价的。所以：

books flatMap (s => s.toList)

books.flatMap(s => s.toList)

上面这二者也是等价的。
对于Lambda表达式“s => s.toList”，左侧的s就是输入参数，右侧的s.toList表示对该参数要执行的操作。
所以：

books flatMap (s => s.toList)

这条语句的含义就是：对于列表books中的每个元素，都执行Lambda表达式定义的匿名函数“s => s.toList”，把一个books元素转换成一个字符集合，比如说，把“Hadoop”这个字符串转换成字符集合List(‘H’,’a’,’d’,’o’,’o’,’p’)，把“Hive”字符串转换成字符集合List(‘H’,’i’,’v’,’e’)。最后，flatMap把这些集合中的元素“拍扁”得到一个集合List(‘H’, ‘a’,’d’, ‘o’, ‘o’, ‘p’, ‘H’, ‘i’, ‘v’, ‘e’, ‘H’, ‘D’, ‘F’, ‘S’)。