Scala学习之循环跟数组

 第五步：运行脚本

Scala是一个动态性很强的语言，所以它也像Ruby那样，能够写脚本运行。

新建一个hello.scala的文本文件，

hello.scala 写道

println("Hello, world, from a script!")

 

打开命令行，并到达hello.scala所在的目录，

cmd 写道

D:\>scala hello.scala
Hello, world, from a script!

D:\>

 

可以看到很简单，就运行了这个脚本。

 

 

第六步： 循环用while, 判断用if

Scala中使用while和java差不多。

写个把输入的参数字符逐个打印出来的小脚本，printargs.scala

 

printargs.scala 写道

var i = 0
while (i < args.length) {
println(args(i))
i += 1
}

 

这段脚本会把传入的参数逐个打印出来。

while循环体外定义一个可变的变量i,在循环体内每次加一，直到传入的参数全部打印完毕。

cmd 写道

D:\>scala printargs.scala Scala is fun
Scala
is
fun

D:\>

 

注意，Scala中不能用i++或++i

 

if在第一篇的max方法中演示过了，不再重复。

 

 

第七步：用foreach和for进行迭代

上面介绍了用while做循环，用过ruby或者喜欢java5新特性的人可能会说，hey,做个循环怎么这么丑？

ruby,java5有foreach，Scala当然也有！

 

接着上面的需求，用foreach实现把传入的参数打印出来。

建个文本文件，叫pa.scala，里面写上

pa.scala 写道

args.foreach(arg => println(arg))

 

运行pa.scala你会看到

cmd 写道

D:\>scala pa.scala Scala is easy
Scala
is
easy

D:\>

 

arg是迭代变量，不需要手工赋值，编译器会把传递给它。

同时编译器会认出arg的类型，所以这里不需要定义类型。

但我觉得如果类型不是一目了然的情况下，最好是定义一下类型，可以使阅读代码的人很轻松。

 

把arg定义上类型

pa.scala 写道

args.foreach((arg: String) => println(arg))

 注意当给变量定义类型的时候，必须要加括号！

 

这里传给foreach的实际上就是一个匿名方法！

匿名方法的定义是这样的：

 

 

方法参数 => 方法体

 

我们这个传入的匿名方法就是： (arg: String) => println(arg)

 

很懒的程序员会发现，这里arg好像没什么必要，唯一参数传给唯一的方法体。

在java这样的想法可能是空幻想，但Scala帮你实现了！

我们可以省略成：

pa.scala 写道

args.foreach(println)

 就这么少！

 

Scala还有一个for迭代，可以做更多的事情，但这里只介绍一下它的简单用法。

在ruby中实现上面的打印参数：

ruby 写道

for arg in ARGV # Remember, this is Ruby, not Scala
puts arg
end

 

用Scala的for来实现

scala 写道

for (arg <- args)
println(arg)

 感觉怎么样？这里左箭头<-可以读成in。

 

在Scala，如果一句话是一行，可以省略分号；如果多个语句放在一行，用分号隔开。

 

 

 

第八步： 数组

数组是定义数据类型很重要很基础的容器。

在Scala里如何使用数组呢？

 

这次我们的参数由程序定义，并把他们打印出来。

建个文本文件，叫paramswithvalues.scala

paramswithvalues.scala 写道

val greetStrings = new Array[String](3)

greetStrings(0) = "Hello"
greetStrings(1) = ", "
greetStrings(2) = "world!\n"

for (i <- 0 to 2)
print(greetStrings(i))

 

这里出现了很多Scala的新式武器！

1. 定义数组类型

Scala代码  

1. val greetStrings = new Array[String](3)  

 val已经介绍过了，表示greetStrings不能再被赋值。

这里Array[String]表示类型，可以读成字符串的数组，它是一个类型，也就是类，所以可以用new去实例化。

括号3表示数组容量是3

 

2. 数组元素赋值

Scala代码  

1. greetStrings(0) = "Hello"  

 虽然greetStrings是不可更改的，但数字元素可以。

Scala用小括号代替java的中括号，可能很多java工程师会说：呵，发明新轮子。

其实Scala是被冤枉的。

 

Scala里所以东西都是对象，数组也不例外。数组赋值其实也是一个方法完成的。

上面的代码会被编译器转换成两个参数的方法：

Scala代码  

1. greetStrings.update(0, "Hello")  

 当然你也直接这样写上面的赋值：

Scala代码  

1. greetStrings.update(0, "Hello")  
2. greetStrings.update(1, ", ")  
3. greetStrings.update(2, "world!\n")  

 

3. 数组元素读取

在for循环体里面有

Scala代码  

1. print(greetStrings(i))  

 为什么Scala不用中括号呢？是因为Scala有一套通用规则，会把小括号转换成apply。

所以编译器会得到这样的代码：

Scala代码  

1. print(greetStrings.apply(i))  

 

很魔术？其实只要知道Scala的一些通用规则，很多符号就变得非常简单易懂了。

 

如果不使用符号，我们的代码同样可以完成：

Scala代码  

1. val greetStrings = new Array[String](3)  
2.   
3. greetStrings.update(0, "Hello")  
4. greetStrings.update(1, ", ")  
5. greetStrings.update(2, "world!\n")  
6.   
7. for (i <- 0.to(2))  
8.   print(greetStrings.apply(i))  

 

 

这里for循环用了0 to 2,很容易理解，就是从0到2，默认步进1.

当方法参数只有一个的时候，可以不写括号和点，

所以第一循环是这样写就够了：

Scala代码  

1. for (i <- 0 to 2)  

 to是0的一个方法，

Scala代码  

1. for (i <- 0.to(2))   

 

数组就基本介绍到这里。

 

第九步：使用Lists和Tuples

函数式编程一个很大的特点就是方法不产生副作用(side effects),就是这个方法不改变任何东西。

参数传进去，经过加工输出这个过程中没有任何变量被改变。

 

像Java的String就是一个例子，是不可更改，它里面所有的方法都不会把对象里面任何东西做更改。

 

在上篇介绍了数组，它定义为val变量，定义了类型和容量，那么这个变量的类型和容量就不能修改了。

但他里面的元素还是可以重新赋值，产生了副作用，因此Array不是纯函数式的类。

 

Java的List和Scala数组那样可以随意修改里面的元素，但是Scala的List是函数式的，也就是一次定型，不可修改。