1. 创建并初始化一个String Array

    val strArr1 = new Array[String](3)
    strArr1(0) = "How"
    strArr1(1) = "are"
    strArr1(2) = "you!"

上述代码被transform 为

    val strArr1 = new Array[String](3)
    strArr1.update(0, "How")
    strArr1.update(1, "are")
    strArr1.update(2, "you!")

scala doc 中有一下描述：

  /** Update the element at given index.
   *
   *  Indices start at `0`; `xs.update(i, x)` replaces the i^th^ elemen t in the array.
   *  Note the syntax `xs(i) = x` is a shorthand for `xs.update(i, x)`.
   *
   *  @param    i   the index
   *  @param    x   the value to be written at index `i`
   *  @throws       ArrayIndexOutOfBoundsException if `i < 0` or `length <= i`
   */
  def update(i: Int, x: T) { throw new Error() }

2.  使用伴随对象(companion object)创建并初始化Array

   

val strArr2 = Array("Fine", "thank", "you")

这里Array是一个对象的名字，在Scala中对象出现在函数的位置的时候，比如这里，对象后面跟了括号，scala的编译器就会自动寻找这个对象的apply方法，所以这里调用的其实是Array.apply

在scala 源码中可以看到

  // Array(e0, ..., en) is translated to { val a = new Array(3); a(i) = ei; a }
  def apply[T: ClassTag](xs: T*): Array[T] = {
    val array = new Array[T](xs.length)
    var i = 0
    for (x <- xs.iterator) { array(i) = x; i += 1 }
    array
  }

apply方法为我们创建了类Array的一个对象，并初始化。这里的object Array就是class Array的伴随对象。


3. 同理

    val strArr = Array("Fine", "thank", "you")
	println(strArr(0))  // strArr(0) 本质上调用的是 strArr.apply

4. 在Array 是可变类型， List是不可变类型。 List的使用示例

    val twoThree = List(2, 3)
    val oneTwoThree = 1 :: twoThree  // 这里 ：： List的一个方法， 在Scala中所有的操作符（operator）都是方法，且以冒号结尾的操作符为右操作符（参数在左边，对象在右边） 
    println(oneTwoThree)  // List(1, 2, 3)

也可以这样

	  val oneTwoThree = 1 :: 2 :: 3 :: Nil
	  println(oneTwoThree) // List(1, 2, 3)


5. 为什么不往List的后面添加元素

Why not append to lists?

Class List does offer an “append” operation —it’s written :+ and is

explained in Chapter 24— but this operation is rarely used, because

the time it takes to append to a list grows linearly with the size of the

list, whereas prepending with :: takes constant time. Your options if

you want to build a list efficiently by appending elements is to prepend

them, then when you’re done call reverse; or use a ListBuffer, a

mutable list that does offer an append operation, and when you’re done

call toList. 

追加元素的时间复杂程度会随元素个数线性增长

可以先向前追加，然后reverse

或先使用ListBuffer 再toList

    val L12345 = 1 :: 2 :: 3 :: 4 :: 5 :: Nil
    val L54321 = L12345.reverse
    print(L54321)  // List(5, 4, 3, 2, 1)
import scala.collection.mutable.ListBuffer

object TestMain {
  def main(args: Array[String]) {
    
    val lb = new ListBuffer[Int]
    lb.append(1)
    lb.append(2)
    lb.append(3)
    
    var l = lb.toList
    println(l)  // List(1, 2, 3)
  }
}


6.最后解释一下 val 和 var

  两者都是scala中的变量修饰符，如java中的static ,final。 

  val 的作用是正是声明一个final的变量，即不可再被赋值的变量

  var 与val相反

  另外scala中没有类似java 的static关键字


7.浏览一下List的其它方法

List() or Nil
The empty List
List("apple", "banana", "pare")create a new List[String]
"apple" :: "banana" :: "pear" :: Nil同上
count(s => s.length == 4)
Counts the number of string elements that have length 4 
drop(2)Returns the list without its first 2 elements
dropRight(2)Returns the list without its rightmost 2 elements
exists(s => s=="until")Detemine whether a string element exists in the list
filter(s => s.length == 4)Return a list of all elements, in order, of the list that have lengh 4
forall(s => s.endWith("l"))Indiates whether all elements in  the list end with letter "l"
foreach(s => print(s))
Executes the print statement on each of the string in the list
foreach(print)Same as previous
headThe first element
inita list of all but the last element
isEmptyIndicates whether the list is empty
lastthe last element
lengthnumber of elements
map(s => s + "y")Return a list resulting from adding a "y" to each string element in the list
mkString(", ")Makes a string with the elements of the list
remove(s => s.length==4)Return a list containning al elements of the list except those that have length 4
reverseReturns a list in reverse order
sort 
Return a list in alpabetical order
tailReturns the list minus its first element