一、星号

1.变长参数
定义一个变长参数的方法sum，然后计算1-5的和。

// 定义函数
scala>  def sum(args: Int*) = {
     | var result = 0
     | for (arg <- args) result += arg
     | result
     | }
sum: (args: Int*)Int
// 函数调用
scala> val s = sum(1,2,3,4,5)
s: Int = 15

// 但是如果使用这种方式就会报错
scala> val s = sum(1 to 5)
<console>:25: error: type mismatch;
 found   : scala.collection.immutable.Range.Inclusive
 required: Int
       val s = sum(1 to 5)

// 必须在后面写上: _*将1 to 5转化为参数序列
scala> val s = sum(1 to 5: _*)
s: Int = 15

2. 变量声明中的模式
   可以通过模式匹配获取元组的元素，当不需要某个值的时候可以使用_替代。
   分别将arr中的第一个和第二个值赋给first和second

scala> val arr = Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

scala> val Array(1, 2, _*) = arr

scala> val Array(first, second, _*) = arr
first: Int = 1
second: Int = 2

二、下划线

1. 通配符
   作为“通配符”，类似Java中的*。

import scala.math._

2. 参数序列
   :*作为一个整体，告诉编译器你希望将某个参数当作参数序列处理！例如val s = sum(1 to 5:*)就是将1 to 5当作参数序列处理。

3. 指代一个集合中的每个元素。
   要在一个Array 中筛出偶数，并乘以2，可以用以下办法：

// 每个偶数乘以2
scala> (1 to 9).filter(_%2==0).map(2*_)
res8: scala.collection.immutable.IndexedSeq[Int] = Vector(4, 8, 12, 16)

访问元组成员
在元组中，可以用方法_1, _2, _3访问组员。如a._2。其中句点可以用空格替代。

// 定义一个tuple
scala> val t = (1, 3.14, "red")
t: (Int, Double, String) = (1,3.14,red)
// 用_1，_2，_3访问这个元组
scala> t._1
res9: Int = 1

scala> t._2
res10: Double = 3.14

scala> t._3
res11: String = red

4. 下划线_代表的是某一类型的默认值
   对于Int来说，它是0。
   对于Double来说，它是0.0
   对于引用类型，它是null。

5. 方法转化成函数

6. 函数中使用
   代表一个参数。

scala> def setFunction(parm1:Double,parm2:Double): Double = parm1+parm2
setFunction: (parm1: Double, parm2: Double)Double

scala>  val set=setFunction(3.0,_:Double)
set: Double => Double = <function1>

scala>  println(set(7.1))
10.1

7. map中的使得
   map(_._n)表示任意元组tuple对象,后面的数字n表示取第几个数.(n>=1的整数)

scala> val p=List(("hello",35,1.50),("nihao",36,1.78))
p: List[(String, Int, Double)] = List((hello,35,1.5), (nihao,36,1.78))

scala> p.map(_._1)
res18: List[String] = List(hello, nihao)

scala> p.map(_._2)
res19: List[Int] = List(35, 36)