Scala

欢迎大家关注： scala工具库 ,里面包含各种库的测试用例和使用说明文档

##模式匹配使用用模式匹配实现斐波那契

1def fibonacci(in: Any): Int = in match {
2    case 0 => 0
3    case 1 => 1
4    case n: Int if(n > 1)=> fibonacci(n - 1) + fibonacci(n - 2)
5    case _ => 0
6}
7
8println(fibonacci(3))

##元组tuple 元组可以保存不同类型的值，不能通过名称获取字段，而是使用位置下标来读取对象；而且这个下标基于1，而不是基于0。

1val hostPort = ("localhost", 80)
2println("host:%s,port:%s".format(hostPort._1,hostPort._2))

执行结果：

host:localhost,port:80

##选项 Option Option 是一个表示有可能包含值的容器。 Option基本的接口是这样的：

1trait Option[T] {
2  def isDefined: Boolean
3  def get: T
4  def getOrElse(t: T): T
5}

##映射 Map Option本身是泛型的，并且有两个子类： Some[T] 或 None Map.get 使用 Option 作为其返回值，表示这个方法也许不会返回你请求的值。

1val map = Map(1 -> "one", 2 -> "two")
2println(map.get(2))
3println(map.get(3))

执行结果：

1Some(two)
2None

##函数组合子（Functional Combinators） ###map map对列表中的每个元素应用一个函数，返回应用后的元素所组成的列表。

1    val numbers = List(1, 2, 3)
2    val double = numbers.map((i: Int) => i * 2)
3    val squared = numbers.map((i: Int) => BigInt(i).pow(3))
4    println("%s".format(numbers))
5    println(double)
6    println(squared)
7    //传入一个部分应用函数
8    def timesTwo(i: Int): Int = i * 2
9    val doubleFunction = numbers.map(timesTwo _)
10    println(doubleFunction)

执行结果：

1List(1, 2, 3)
2List(2, 4, 6)
3List(1, 8, 27)
4List(2, 4, 6)

###foreach foreach很像map，但没有返回值。foreach仅用于有副作用[side-effects]的函数

1    //foreach返回值为Unit即void
2    val foreachResult = numbers.foreach { (i: Int) => i * 2 }
3    println(foreachResult)

执行结果：

()

###filter filter移除任何对传入函数计算结果为false的元素

1    val filterResult = numbers.filter { (i: Int) => i % 2 == 0 }
2    println(filterResult)

执行结果：

List(2)

###zip zip将两个列表的内容聚合到一个对偶列表中，多余的元素删除

1    val zipResult = numbers.zip(List('a', 'b', 'c', 'd'))
2    println(zipResult)

执行结果：

List((1,a), (2,b), (3,c))

###partition partition将使用给定的谓词函数分割列表。

1    val partitionResult = numbers.partition { _ % 2 == 0 }
2    println("partition result:%s".format(partitionResult))

执行结果：

partition result:(List(2),List(1, 3))

###find find返回集合中第一个匹配谓词函数的元素

1    var findResult = numbers.find(_ == 1)
2    println("find result:%s".format(findResult))
3    findResult = numbers.find(_ > 3)
4    println("find result:%s".format(findResult))

执行结果：

1find result:Some(1)
2find result:None

###drop&dropWhile drop删除前i个元素,dropWhile删除直到不满足谓词函数的元素

1    var dropResult = numbers.drop(2)
2    println("drop result:%s".format(dropResult))
3    dropResult = numbers.dropWhile(_ % 2 != 0)
4    println("dropWhile result:%s".format(dropResult))

执行结果：

1drop result:List(3)
2dropWhile result:List(2, 3)

###foldLeft&foldRight 0为初始值（记住numbers是List[Int]类型），m作为一个累加器,foldRight与foldLeft运行过程相反

1    var foldLeftResult = numbers.foldLeft(0) {
2      (m: Int, n: Int) => println("m:" + m + " n:" + n); m + n
3    }
4    println("foldLeft result:%s".format(foldLeftResult))
5    var foldRightResult = numbers.foldRight(0) {
6      (m: Int, n: Int) => println("m:" + m + " n:" + n); m + n
7    }
8    println("foldRight result:%s".format(foldRightResult))

执行结果：

1m:0 n:1
2m:1 n:2
3m:3 n:3
4foldLeft result:6
5m:3 n:0
6m:2 n:3
7m:1 n:5
8foldRight result:6

###flatten flatten将嵌套结构扁平化为一个层次的集合

1    var flattenResult = List(List(1, 2, 3), List(4, 5, 6)).flatten
2    println("flatten result:%s".format(flattenResult))

执行结果：

flatten result:List(1, 2, 3, 4, 5, 6)

###flatMap flatMap是一种常用的组合子，结合映射[mapping]和扁平化[flattening]。 flatMap需要一个处理嵌套列表的函数，然后将结果串连起来。flatMap是map和flatten的组合。

1    val nestedNumbers = List(List(1, 2), List(3, 4))
2    var flatMapResult = nestedNumbers.flatMap(x => x.map(_ * 2))
3    println("flatMap result:%s".format(flatMapResult))
4    flatMapResult = nestedNumbers.map(x => x.map(_ * 2)).flatten
5    println("flatMap result:%s".format(flatMapResult))

执行结果：

1flatMap result:List(2, 4, 6, 8)
2flatMap result:List(2, 4, 6, 8)

##广告点击Spark加入群Spark，分享更多Spark相关信息

评论区

相关推荐