val greetStrings=new Array[String](3)
greetStrings(0)="Hello"
greetStrings(1)=", "
greetStrings(2)="world!\n"val greetStrings = Array("Hello",", ","world!\n")
for(i<-0 to 2)print(greetString(i))

1、用[String]新建一个String型的数组；

2、数组用(index)引用其中的值；

3、若方法只有一个参数，调用时可以省略点及括号;

(0).to(2)  0 to 2       println(10)  Console println 10

4、Scala没有传统意义上的操作符，取而代之的是+-*/这样的字符作为方法名，1+2 是方法的调用：(1).+(2)

用括号访问数组：数组也是对象，实质为对象的值参数，调用的是apply方法。

用括号传递给变量一个或多个值参数时，scala会把它转换成对apply方法的调用。

任何对于对象的值参数应用都被转换为对apply方法的调用。前提是这个类型定义了apply方法。

arrayObject(i)被转换为arrayObject.apply(i)

当对带有括号并包括一到若干参数的变量赋值时，编译器将使用对象的update方法对括号里的参数和等号右边的对象执行调用。

greetStrings(0)=”Hello”

greetStrings.update(0,”Hello”)

val numNames = Array(“zero”,”one”,”two”)

val numNames = Array.apply(“zero”,”one”,”two”)

调用apply工厂方法，可以有不定个数的参数，定义在Array的伴生对象(companion object)中。

方法没有副作用是函数式编程的重要概念，计算并返回值应该是方法的唯一目的。

数组是可变的同类对象序列。

列表是不可变的同类对象序列，为的是方便函数式编程。

val oneTwo=List(1,2)
val threeFour=List(3,4)
val all=oneTwo::threeFour
val all=1::2::3::4::Nil

:::列表叠加，新建列表并返回

::前插    Nil是空列表    带冒号的方法调用者是后者，1::Nil   Nil.::(1)

如何append？

1、先::前插，再reverse;

2、ListBuffer支持append,在toList。

不可变，可包含不同类型的元素。

如果在方法里返回多个对象，java的做法是创建JavaBean以包含多个返回值，Scala里可以返回元组来达到目的。

val pair=(99,"Luftballons")
println(pair._1+" "+pair._2)

列表的apply方法始终返回同样的类型，所以可以用(index)访问，而元组中元素的类型都不同，所以用._index访问。

从1开始是依传统设定的。

scala.collection.immutable.Set

scala.collection.mutable.Set

scala.collection.imutable.HashMap

scala.collection.mutable.HashMap

默认为immutable。

如果包含var变量，可能是指令式风格；

如果仅含val变量，可能是函数式风格。

指令式风格

def printArgs(args :Array[String]):Unit={var i = 0while(i<args.length){println(args(i))i+=1}
}

函数式风格

def printArgs(args:Array[String]):Unit={for(arg<-args)println(args) //args.foreach(println)

每个有用的程序都会有某种形式的副作用，否则就不可能向程序之外提供什么有价值的东西。

无副作用的代码使测试变得容易：

def formatArgs(args:Array[String])=args.mkString("\n")
val res=formatArgs(Array("zero","one","two"))
assert(res=="zero\none\ntwo")

Scala的assert方法检查传入的Boolean表达式，如果为假，抛出AssertionError。

Scala程序员的平衡感：

崇尚val、不可变对象、无副作用的方法；

只有在特定需要和加以权衡之后才选择var、可变对象、有副作用的方法。

import scala.io.Source
def widthOfLength(s:String)=s.length.toString.length
if(args.length>0){val lines=Source.fromFile(args(0)).getLines.toListval longestLine=lines.reduceLeft((a,b)=>if(a.length>b.length)a else b)val maxWidth=widthOfLength(longestLine)for(line<-lines){val numSpaces=maxWidth-widthOfLength(line)val padding=" "*numSpacesprint(padding+ling.length+"|"+line)
}
elseConsole.err.println("Please enter filename")

Source.fromFile(args(0)).getLines方法返回一个迭代器Iterator[String]。

getLines方法返回的是迭代器，一旦遍历完成就失效了，所以要toList。

语句末尾的分号通常可选，如果一行包含多条语句，必须加分号。

如val s = “hello”; println(s)

除非以下情况之一成立，否则行尾被认为是一个分号。

1、疑问行由一个不能合法作为语句结尾的字结束，如句点或中缀操作符；

2、下一行开始于不能作为语句开始的词；

3、行结束于()或[]内部，因为这些符号不能容纳多个语句。

Scala不能定义静态成员，取而代之的是定义单例对象（singleton object）。

用object关键字替换class关键字。

import scala.collection.mutable.Map
object ChecksumAccumulator{private val cache=Map[String,Int]()def calculate(s:String):Int=if(cache.contains(s))cache(s) //返回键s对应的值else{val acc=new ChecksumAccumulaterfor(c<-s)acc.add(c.toByte)val cs=acc.checksum()cache+=(s->cs)cs}
}

单例对象，对应于java的静态方法工具类。

当单例对象与某个类共享同一个名称时，被称为这个类的伴生对象（companion object）。

同名类的伴生对象，与伴生类（companion class）在一个源文件中。

类和其伴生对象可以互相访问其私有成员。

单例对象名.方法名  CheckSumAccumulator.calculate(“Every value is an object”)

单例对象不是类型，它扩展了伴生类的父类并可以混入特质。

可以使用类型调用单例对象，或者类型的实例变量指代单例对象，并把它传递给需要类型参数的方法。

单例对象不带参数，而类可以。因为单例对象不是new实例化的，没机会传递给它实例化参数。

每个单例对象都被实现为虚构类（synthetic class）的实例，并指向静态的变量。

虚构类的名称是对象名后加一个美元符，单例对象ChecksumAccumulator的虚构类是ChecksumAccumulator$。

单例对象在第一次访问时被初始化。

没有伴生类的单例对象被称为独立对象（standalone object），可用于相关功能方法的工具类，或者定义Scala应用的入口点。

能独立运行的Scala程序，必须创建有main方法的单例对象——仅一个参数Array[String]，且结果类型为Unit。

以定义结尾的都不是脚本。

脚本：以结果表达式结束。

$ scalac ChecksumAccumulator.scala Summer.scala  或者

快速Scala编译器，fast Scala compiler，将编译程序加载入后台

$ fsc ChecksumAccumulator.scala Summer.scala

$ fsc -shutdown

import ChechsumAcculator.calculate
object Summer{def main(args:Array[String]){for(arg<-grgs)println(arg+":"+calculate(arg))}
}

Scala源文件默认引用java.lang、scala、单例对象Predef。

println语句即为Predef单例对象的println（Predef.println转而调用Console.println）。

assert实际调用Predef.assert。

import ChecksumAcculator.calculate
object FallWinterSpringSummer extends Application{for(season<-List("fall","winter","spring","summer"))println(season+":"+calculate(season))
}

特质Application声明了带有合适签名的main方法，并被单例对象继承。

大括号之间的代码被收集进了单例对象的主构造器（primary constructor），并在类初始化时执行。

Scala提供scala.Application特质，可以减少输入工作。

但无法访问命令行参数，无法应用于多线程。

数组Array 可变同类对象序列

列表List 不可变同类对象序列

元组Tuple 不可变非同类对象序列

集合Set  映射Map 有可变和不可变

整数类型 integral type

Byte

Short

Int

Long

Char

数类型 numeric type

Float

Double

String  属于java.lang包

Boolean

字面量literal——直接写在代码里的常量值。

原始字符串：raw string 三个双引号对之间的字符串，字符串中可以包含任意字符，不用转义。

 “””|line1

    |line2”””.stripMargin 此方法使结果符合预期

符号字面量——除了显示名字，什么都不能做。

符号字面量被写成’<标识符>

被映射成预定义类scala.Symbol的实例，即被编译器扩展为工厂方法调用：Symbol(“标识符”)。

应用场景：动态类型语言中使用一个标识符。

>val s = ‘aSymbol

>s.name  #aSymbol

如果同一个符号字面量出现两次，那么两个字面量指向的是同一个Symbol对象。

操作符实际只是普通方法调用的另一种表现形式。

值类型对象调用方法的简写形式。

任何方法都可以被当做操作符来标注。

>val s=”hello, world”

>s.indexof(‘o’)

>s indexof ‘o’

中缀标注

前缀标注  -2.0 实际为 (2.0).unary_-    + - ! ~四种操作符可被用作前缀标注

后缀标注  s toLowerCase  不用点号或括号调用不带任何参数的方法

中缀是二元的，前缀和后缀是一元的。

在Scala中，方法调用的空括号，有副作用就加上，没副作用就省略。

首先检查左侧是否为null，如果不是，调用左操作数的equals方法。

精确比较取决于左操作数的equals方法定义。

Java中的==对基本类型，比较的是值相等性；对于引用类型，比较的是引用相等性，即是否指向JVM堆里的同一个对象。

任何以:字符结尾的方法，右操作数调用方法，传入左操作数 a:::b   b.:::(a)

其余相反。

Scala基本类型的方法很多。

Scala基本类型都隐式转换（implicit conversion）为富包装器类型，可对外提供多种额外的方法。

想要看到基本类型的所有可用方法，可以查看基本类型的富包装器的API文档。