scala 知识点1

windows下，在 cmd命令窗口 运行 scala 程序：
scala HelloWorld
即可

<- 运算符
<-用于for循环中，如下所示
for (A <- B) {
println(A)
}

Scala需要使用 java.io.PrintWriter 实现把数据写入到文本文件。

可以使用Scala.io.Source的getLines方法实现对文件中所有行的读取。

for 语句
for (i <- 1 to 5 if i%2==0; j <- 1 to 3 if j!=i) println(i*j)

定长数组
val intValueArr = new ArrayInt
intValueArr(0) = 12

val myStrArr = new Array[String](3)
myStrArr(0) = "BigData"

val intValueArr = Array(12,45,33)
val myStrArr = Array("BigData","Hadoop","Spark")

列表：
val intList = List(1,2,3)

函数字面量、Lambda表达式
val myNumFunc: Int=>Int = (num: Int) => num * 2
val myNumFunc1 = (num: Int) => num * 2
val myNumFunc2: Int=>Int = num => num * 2

下面这种是错误的：因为解释器不能推断出 num 的类型
    val myNumFunc = num => num * 2

函数字面量：
函数的值，称为函数字面量

def counter(value: Int): Int = {value += 1}

函数的类型：
(Int) => Int

Int => Int

函数的值：
(value) => {value += 1} //只有一条语句时，大括号可省略

定义一个变量：
val num: Int = 5
照葫芦画瓢，定义一个函数：
val counter: Int => Int = {(value) => value += 1}

lambda：（参数） => 表达式
(num: Int) => num * 2

按照 lambda 来定义上面的函数：
val counter: = (value: Int) => value += 1

闭包的概念

高阶函数：
函数作为参数或返回值

占位符语法：
为了让函数字面量更加简洁，我们可以使用下划线作为一个或多个参数的占位符，只要每个参数在函数字面量内仅出现一次。

map操作：
将函数应用到集合中的每个元素，每个元素产生一个对应的结果元素， 这些结果元素形成一个新的集合

val books = List("Hadoop", "Hive", "HDFS")
books.map(s => s.toUpperCase) //改为大写

flatMap操作：
将函数应用到集合中的每个元素，每个元素产生一个对应的结果集合，
然后把多个集合 放到一个集合中

val books = List("Hadoop","Hive","HDFS")
books.flatMap(s => s.toList)

filter操作：
遍历一个集合，从中获取满足指定条件的元素，组成一个新的集合

val books = List("Hadoop", "Hive", "HDFS")
val books1 = books.filter(s => s.contains("d"))
books1 foreach {s => println(s)}

reduce操作：
是一种二元操作就，对集合中的元素进行归约
包含reduceLeft和reduceRight两种操作，前者从集合的头部开始操作，后者从集合的尾部开始操作。

val list = List(1,2,3,4,5)
list.reduceLeft(_ + _)
reduceLeft(_ + _)表示从列表头部开始，对两两元素进行求和操作，
下划线是占位符，用来表示当前获取的两个元素

执行过程：
    1+2 = 3
    3+3 = 6
    6+4 = 10
    10+5 = 15

直接使用reduce，默认采用的是reduceLeft

fold操作：
折叠(fold)操作和reduce（归约）操作比较类似
fold操作需要从一个初始的“种子”值开始
并以该值作为上下文，处理集合中的每个元素。

val list = List(1,2,3,4,5)
list.fold(10)(_*_)

执行过程：
    10 * 1 = 10
    10 * 2 = 20
    20 * 3 = 60
    ...
    
old有两个变体：foldLeft()和foldRight()，其中，foldLeft()，第一个参数为累计值，集合遍历的方向是从左到右。foldRight()，第二个参数为累计值，集合遍历的方向是从右到左

用 scala 写一个 WordCount 例子：

import java.io.File
import scala.io.Source
object WordCount {
    def main(args: Array[String]): Unit = {
        val dirfile=new File("/usr/local/scala/mycode/wordcount")
        val files=dirfile.listFiles
        for(file <- files) println(file)
        val listFiles=files.toList //toList 方法将 files数组 转换为 listFiles列表
        val wordsMap=scala.collection.mutable.Map[String,Int]()
        listFiles.foreach( file =>Source.fromFile(file).getLines().foreach(line=>line.split(" ").
                      foreach(
                          word=>{
                            if (wordsMap.contains(word)) {
                              wordsMap(word)+=1
                            }else {
                              wordsMap+=(word->1)
                            }
                          }
                      )
                )

        )
        println(wordsMap)
        for((key,value)<-wordsMap) println(key+": "+value)
    }
}

//定义一个方法
def m(x: Int, y: String): Int = x * y
//定义一个函数
val f = (x: Int, y: String) => x * y
//将方法转换为函数
val f1 = m _