Open www1350 opened 7 years ago
scala> object plus extends Function1[Int,Int]{ | def apply(m:Int) =m+1 | } defined module plus scala> plus(0) res29: Int = 1
可以使用更直观快捷的extends (Int => Int)代替extends Function1[Int, Int]
class AddOne extends (Int => Int) { def apply(m: Int): Int = m + 1 }
这个Function特质集合下标从0开始一直到22。为什么是22？这是一个主观的魔幻数字(magic number)。我从来没有使用过多于22个参数的函数，所以这个数字似乎是合理的。
( x:Int ) => x+1 {x:Int => x = x+1 x * 2 }
scala> def sum(x:Int,y:Int,z:Int):Int=x+y+z sum: (x: Int, y: Int, z: Int)Int scala> sum(1,2,3) res8: Int = 6 scala> val sum2 = sum(1,_:Int,3) sum2: Int => Int = <function1> scala> sum2(4) res10: Int = 8
柯里化是指将原来接收两个参数的函数变成接收一个参数的函数的过程，新的函数返回一个以原有第二个参数作为参数的函数
scala> def mul(x:Int,y:Int):Int = x *y mul: (x: Int, y: Int)Int scala> mul(6,7) res12: Int = 42 scala> def mul2(x:Int)=(y:Int)=>x*y mul2: (x: Int)Int => Int scala> mul2(6)(7) res14: Int = 42 scala> def mul2(x:Int)(y:Int)=x*y mul2: (x: Int)(y: Int)Int scala> val mul3 = (mul _).curried mul3: Int => (Int => Int) = <function1> scala> mul3(2)(3) res17: Int = 6
隐式转换必须满足无歧义规则，在声明隐式参数的类型是最好使用特别的或自定义的数据类型，不要使用Int,String这些常用类型，避免碰巧匹配 隐式转换的前提： 1.不存在二义性 2.隐式操作不能嵌套使用（如 convert1(covert2(x))）+y 3.代码能够在不使用隐式转换的前提下能编译通过，就不会进行
scala> implicit val p="aaa" p: String = aaa
scala> def person(implicit name : String) = name person: (implicit name: String)String
scala> person res1: String = aaa
# 隐函数 **隐 函数**允许类型自动转换。更确切地说，在隐式函数可以帮助满足类型推断时，它们允许按需的函数应用。
scala> implicit def strToInt(x: String) = x.toInt strToInt: (x: String)Int
scala> "123" res0: java.lang.String = 123
scala> val y: Int = "123" y: Int = 123
scala> math.max("123", 111) res1: Int = 123
# 模式匹配
scala> val times =1 times: Int = 1
scala> times match{ | case 1 => "one" | case 2 => "two" | case _ => "ot" | } res31: String = one
匹配类成员 之前
def calcType(calc: Calculator) = calc match { case if calc.brand == "HP" && calc.model == "20B" => "financial" case if calc.brand == "HP" && calc.model == "48G" => "scientific" case if calc.brand == "HP" && calc.model == "30B" => "business" case => "unknown" }
样本类 Case Classes 使用样本类可以方便得存储和匹配类的内容。你不用new关键字就可以创建它们。 样本类基于构造函数的参数，自动地实现了相等性和易读的toString方法。
scala> val hp20b = Calculator("HP", "20b") hp20b: Calculator = Calculator(hp,20b)
scala> val hp20B = Calculator("HP", "20b") hp20B: Calculator = Calculator(hp,20b)
scala> hp20b == hp20B res6: Boolean = true
def calcType(calc: Calculator) = calc match { case Calculator("HP", "20B") => "financial" case Calculator("HP", "48G") => "scientific" case Calculator("HP", "30B") => "business" case c@Calculator(, ) => "Calculator: %s of unknown type".format(c) }
或 case _ => "Calculator of unknown type" # 函数组合子（Functional Combinators） map map对列表中的每个元素应用一个函数，返回应用后的元素所组成的列表。
scala> numbers.map((i: Int) => i * 2) res0: List[Int] = List(2, 4, 6, 8)
或传入一个部分应用函数
scala> def timesTwo(i: Int): Int = i * 2 timesTwo: (i: Int)Int
scala> numbers.map(timesTwo _) res0: List[Int] = List(2, 4, 6, 8)
foreach foreach很像map，但没有返回值。foreach仅用于有副作用[side-effects]的函数。 `scala> numbers.foreach((i: Int) => i * 2)` 什么也没有返回。 你可以尝试存储返回值，但它会是Unit类型（即void）
scala> val doubled = numbers.foreach((i: Int) => i * 2) doubled: Unit = ()
filter filter移除任何对传入函数计算结果为false的元素。返回一个布尔值的函数通常被称为谓词函数[或判定函数]。
scala> numbers.filter((i: Int) => i % 2 == 0) res0: List[Int] = List(2, 4) scala> def isEven(i: Int): Boolean = i % 2 == 0 isEven: (i: Int)Boolean
scala> numbers.filter(isEven _) res2: List[Int] = List(2, 4)
zip zip将两个列表的内容聚合到一个对偶列表中。
scala> List(1, 2, 3).zip(List("a", "b", "c")) res0: List[(Int, String)] = List((1,a), (2,b), (3,c))
partition partition将使用给定的谓词函数分割列表。
scala> val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> numbers.partition(_ % 2 == 0) res0: (List[Int], List[Int]) = (List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))
find find返回集合中第一个匹配谓词函数的元素。
scala> numbers.find((i: Int) => i > 5) res0: Option[Int] = Some(6)
drop & dropWhile drop 将删除前i个元素
scala> numbers.drop(5) res0: List[Int] = List(6, 7, 8, 9, 10)
dropWhile 将删除元素直到找到第一个匹配谓词函数的元素。例如，如果我们在numbers列表上使用dropWhile奇数的函数, 1将被丢弃（但3不会被丢弃，因为他被2“保护”了）。
scala> numbers.dropWhile(_ % 2 != 0) res0: List[Int] = List(2, 3, 4, 5, 6, 7, 8, 9, 10)
foldLeft
scala> numbers.foldLeft(0)((m: Int, n: Int) => m + n) res0: Int = 55
0为初始值（记住numbers是List[Int]类型），m作为一个累加器。 直接观察运行过程：
scala> numbers.foldLeft(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n } m: 0 n: 1 m: 1 n: 2 m: 3 n: 3 m: 6 n: 4 m: 10 n: 5 m: 15 n: 6 m: 21 n: 7 m: 28 n: 8 m: 36 n: 9 m: 45 n: 10 res0: Int = 55
foldRight 和foldLeft一样，只是运行过程相反。
scala> numbers.foldRight(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n } m: 10 n: 0 m: 9 n: 10 m: 8 n: 19 m: 7 n: 27 m: 6 n: 34 m: 5 n: 40 m: 4 n: 45 m: 3 n: 49 m: 2 n: 52 m: 1 n: 54 res0: Int = 55
flatten flatten将嵌套结构扁平化为一个层次的集合。
scala> List(List(1, 2), List(3, 4)).flatten res0: List[Int] = List(1, 2, 3, 4)
flatMap flatMap是一种常用的组合子，结合映射[mapping]和扁平化[flattening]。 flatMap需要一个处理嵌套列表的函数，然后将结果串连起来。
scala> val nestedNumbers = List(List(1, 2), List(3, 4)) nestedNumbers: List[List[Int]] = List(List(1, 2), List(3, 4))
scala> nestedNumbers.flatMap(x => x.map(_ * 2)) res0: List[Int] = List(2, 4, 6, 8)
可以把它看做是“先映射后扁平化”的快捷操作：
scala> nestedNumbers.map((x: List[Int]) => x.map(_ * 2)).flatten res1: List[Int] = List(2, 4, 6, 8)
这个例子先调用map，然后可以马上调用flatten，这就是“组合子”的特征，也是这些函数的本质。 参考 Effective Scala 对flatMap的意见。 # 扩展函数组合子 现在我们已经学过集合上的一些函数。 我们将尝试写自己的函数组合子。 有趣的是，上面所展示的每一个函数组合子都可以用fold方法实现。让我们看一些例子。
def ourMap(numbers: List[Int], fn: Int => Int): List[Int] = { numbers.foldRight(List[Int]()) { (x: Int, xs: List[Int]) => fn(x) :: xs } }
scala> ourMap(numbers, timesTwo(_)) res0: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
为什么是List[Int]()？Scala没有聪明到理解你的目的是将结果积聚在一个空的Int类型的列表中。 Map? 所有展示的函数组合子都可以在Map上使用。Map可以被看作是一个二元组的列表，所以你写的函数要处理一个键和值的二元组。
scala> val extensions = Map("steve" -> 100, "bob" -> 101, "joe" -> 201) extensions: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101), (joe,201))
现在筛选出电话分机号码低于200的条目。
scala> extensions.filter((namePhone: (String, Int)) => namePhone._2 < 200) res0: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101))
因为参数是元组，所以你必须使用位置获取器来读取它们的键和值。呃！ 幸运的是，我们其实可以使用模式匹配更优雅地提取键和值。
scala> extensions.filter({case (name, extension) => extension < 200}) res0: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101))
函数
可以使用更直观快捷的extends (Int => Int)代替extends Function1[Int, Int]
这个Function特质集合下标从0开始一直到22。为什么是22？这是一个主观的魔幻数字(magic number)。我从来没有使用过多于22个参数的函数，所以这个数字似乎是合理的。
匿名函数
部分应用（Partial application）
柯里化函数
柯里化是指将原来接收两个参数的函数变成接收一个参数的函数的过程，新的函数返回一个以原有第二个参数作为参数的函数
隐式值
scala> implicit val p="aaa" p: String = aaa
scala> def person(implicit name : String) = name person: (implicit name: String)String
scala> person res1: String = aaa
scala> implicit def strToInt(x: String) = x.toInt strToInt: (x: String)Int
scala> "123" res0: java.lang.String = 123
scala> val y: Int = "123" y: Int = 123
scala> math.max("123", 111) res1: Int = 123
scala> val times =1 times: Int = 1
scala> times match{ | case 1 => "one" | case 2 => "two" | case _ => "ot" | } res31: String = one
def calcType(calc: Calculator) = calc match { case if calc.brand == "HP" && calc.model == "20B" => "financial" case if calc.brand == "HP" && calc.model == "48G" => "scientific" case if calc.brand == "HP" && calc.model == "30B" => "business" case => "unknown" }
scala> val hp20b = Calculator("HP", "20b") hp20b: Calculator = Calculator(hp,20b)
scala> val hp20B = Calculator("HP", "20b") hp20B: Calculator = Calculator(hp,20b)
scala> hp20b == hp20B res6: Boolean = true
def calcType(calc: Calculator) = calc match { case Calculator("HP", "20B") => "financial" case Calculator("HP", "48G") => "scientific" case Calculator("HP", "30B") => "business" case c@Calculator(, ) => "Calculator: %s of unknown type".format(c) }
scala> numbers.map((i: Int) => i * 2) res0: List[Int] = List(2, 4, 6, 8)
scala> def timesTwo(i: Int): Int = i * 2 timesTwo: (i: Int)Int
scala> numbers.map(timesTwo _) res0: List[Int] = List(2, 4, 6, 8)
scala> val doubled = numbers.foreach((i: Int) => i * 2) doubled: Unit = ()
scala> numbers.filter((i: Int) => i % 2 == 0) res0: List[Int] = List(2, 4) scala> def isEven(i: Int): Boolean = i % 2 == 0 isEven: (i: Int)Boolean
scala> numbers.filter(isEven _) res2: List[Int] = List(2, 4)
scala> List(1, 2, 3).zip(List("a", "b", "c")) res0: List[(Int, String)] = List((1,a), (2,b), (3,c))
scala> val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> numbers.partition(_ % 2 == 0) res0: (List[Int], List[Int]) = (List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))
scala> numbers.find((i: Int) => i > 5) res0: Option[Int] = Some(6)
scala> numbers.drop(5) res0: List[Int] = List(6, 7, 8, 9, 10)
scala> numbers.dropWhile(_ % 2 != 0) res0: List[Int] = List(2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> numbers.foldLeft(0)((m: Int, n: Int) => m + n) res0: Int = 55
scala> numbers.foldLeft(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n } m: 0 n: 1 m: 1 n: 2 m: 3 n: 3 m: 6 n: 4 m: 10 n: 5 m: 15 n: 6 m: 21 n: 7 m: 28 n: 8 m: 36 n: 9 m: 45 n: 10 res0: Int = 55
scala> numbers.foldRight(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n } m: 10 n: 0 m: 9 n: 10 m: 8 n: 19 m: 7 n: 27 m: 6 n: 34 m: 5 n: 40 m: 4 n: 45 m: 3 n: 49 m: 2 n: 52 m: 1 n: 54 res0: Int = 55
scala> List(List(1, 2), List(3, 4)).flatten res0: List[Int] = List(1, 2, 3, 4)
scala> val nestedNumbers = List(List(1, 2), List(3, 4)) nestedNumbers: List[List[Int]] = List(List(1, 2), List(3, 4))
scala> nestedNumbers.flatMap(x => x.map(_ * 2)) res0: List[Int] = List(2, 4, 6, 8)
scala> nestedNumbers.map((x: List[Int]) => x.map(_ * 2)).flatten res1: List[Int] = List(2, 4, 6, 8)
def ourMap(numbers: List[Int], fn: Int => Int): List[Int] = { numbers.foldRight(List[Int]()) { (x: Int, xs: List[Int]) => fn(x) :: xs } }
scala> ourMap(numbers, timesTwo(_)) res0: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
scala> val extensions = Map("steve" -> 100, "bob" -> 101, "joe" -> 201) extensions: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101), (joe,201))
scala> extensions.filter((namePhone: (String, Int)) => namePhone._2 < 200) res0: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101))
scala> extensions.filter({case (name, extension) => extension < 200}) res0: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101))