Scala一种编程语言

红太狼 2022-04-08 13:24 221阅读 0赞

scala

安装

安装scala

去官网下载scala2.11.8（spark使用2.1.2对应scala版本是2.11.8）

下载scala-2.11.8.msi（安装）或scala-2.11.8.zip（解压）

注意：scala安装目录不能有中文和空格（特殊符号）

安装idea

下一步。。。。

configurens--》plugins--》搜索 “scala”--》install ---》 restart intellij

new project --》 选择scala --》选择IDEA -->next---》填写工程名 --》

jdk路径（选择本地的jdk1.8安装目录） --》 scala sdk --》scala安装目录--》finish

特点

面向对象 1+2 (1).+(2)

函数式

兼容的

简洁的

高层级的

静态类型的

交互模式

定义变量

val 常量（推荐）

var 变量

类型推断

这种 Scala能自动理解你省略的类型的能力

val msg2: java.lang.String = "Hello again, world!"

指定类型 变量：类型 = 值

定义函数

def 函数名(参数列表\[变量名：类型\]):结果类型 = ｛

方法体

｝

list(不可变类型必须一致)

List() 或 Nil 空 List

List("Cool", "tools", "rule) 创建带有三个值"Cool"，"tools"和"rule"的新 List\[String\]

val thrill = "Will"::"fill"::"until"::Nil 创建带有三个值"Will"，"fill"和"until"的新 List\[String\]

List("a", "b") ::: List("c", "d") 叠加两个列表（返回带"a"，"b"，"c"和"d"的新List\[String\]）

thrill(2) 返回在 thrill 列表上索引为 2（基于0）的元素（返回"until"）

thrill.count(s => s.length == 4) 计算长度为 4 的 String 元素个数（返回 2）

thrill.drop(2) 返回去掉前 2 个元素的thrill 列表（返回 List("until")）

thrill.dropRight(2) 返回去掉后 2 个元素的thrill 列表（返回 List("Will")）

thrill.exists(s => s == "until") 判断是否有值为"until"的字串元素在 thrill 里（返回 true）

thrill.filter(s => s.length == 4) 依次返回所有长度为 4 的元素组成的列表（返回 List("Will","fill")）

thrill.forall(s => s.endsWith("1")) 辨别是否 thrill 列表里所有元素都以"l"结尾（返回 true）

thrill.foreach(s => print(s)) 对 thrill 列表每个字串执行 print 语句（"Willfilluntil"）

thrill.foreach(print) 与前相同，不过更简洁（同上）

thrill.head 返回 thrill 列表的第一个元素（返回"Will"）

thrill.init 返回 thrill 列表除最后一个以外其他元素组成的列表（返回List("Will", "fill")）

thrill.isEmpty 说明 thrill 列表是否为空（返回false）

thrill.last 返回 thrill 列表的最后一个元素（返回"until"）

thrill.length 返回 thrill 列表的元素数量（返回3）

thrill.map(s => s + "y") 返回由 thrill 列表里每一个 String 元素都加了"y"构成的列表（返回 List("Willy", "filly", "untily")）

thrill.mkString(", ") 用列表的元素创建字串（返回"will, fill, until"）

thrill.remove(s => s.length == 4) 返回去除了 thrill 列表中长度为 4 的元素后依次排列的元素列表（返回 List("until")）

thrill.reverse 返回含有 thrill 列表的逆序元素的列表（返回 List("until","fill", "Will")）

thrill.sort((s, t) =>s.charAt(0).toLowerCase <t.charAt(0).toLowerCase)

返回包括 thrill 列表所有元素，并且第一个字符小写按照字母顺序排列的列表（返回List("fill", "until", "Will")）

thrill.tail 返回除掉第一个元素的 thrill 列表（返回 List("fill","until")）

Tuple(不可变类型可以不一致)

Set

可变scala.collection.mutable.Set

不可变scala.collection.immutable.Set

map

可变scala.collection.mutable.Map

不可变scala.collection.immutable.Map

\---------------------------------------------------

1.方法中的花括号有2种意思：

1）scala中函数的小括号，可以用花括号来表示，即foo\{xx\} 与 foo(xx)是一回事儿。

2）对于只有一个参数的方法，其小括号是可以省略的，map(lambda)可写为 map lambda，即这块\{case (key,value) => value\} 连同花括号整体是一个lambda(函数字面量)。

// 花括号和小括号的区别

val raw = List(("a",1),("b",2),("c",3))

val res = raw.map\{ case (key,value) => value \}.reduce(\_ + \_)

println(res)

2.\{case x => y\} 叫做偏函数(必须用大括号“｛｝”，使用“（）”会报错)。 与完全函数想对应，普通的方法都是完全函数，即f(i:Int) = xxx 是将所有Int类型作为参数的，是对整个Int集的映射；而偏函数则是对部分数据的映射

// 2.case偏函数

val res2 =List(1,2,3).map{
    
          case 1 => "first"
    
          case 2 => "second"
    
          case _ => "other"

3.变长参数

有时候，函数需要一个可变长度的参数。在scala中是容易实现的：

注意调用的时候使用:\_\*，将序列或者集合的内容全部当做参数来传递。

// 3.变长参数

def sum(args:Int*)={
    
            var result = 0
    
            for(arg <- args) result +=arg
    
            print (result)
    
          }
    
           val s = sum (1 to 5:_*)

12.03

类：

类似java

class 类名

属性

val（不可变）或var（可变） 变量名 = 值

方法

del 方法名（参数）：结果类型 = ｛方法体｝

访问权限

private与java类似

Singleton 对象

Scala 比 Java 更面向对象的一个方面是 Scala 没有静态成员。替代品是，

Scala 有： 单例对象：singleton object。

当单例对象与某个类共享同一个名称时，他被称作是这个类的 伴生对象

你必须在同一个源文件里定义类和它的伴生对象。

类被称为是这个单例对象的 伴生类：companionclass。

类和它的伴生对象可以互相访问其私有成员。

scala程序

要执行 Scala 程序，你一定要提供一个有 main 方法

（仅带一个参数， Array\[String\] ，且结果类型为 Unit ）的孤立单例对象名

Application 特质

可以不写main方法直接执行，继承Application

object 对象名 extends Application \{

此处语句可以直接执行，不需要main方法

｝

args 数组不可访问

某些 JVM线程模型里的局限，使用多线程必须写main

基本数据类型：

java中八个加上String

中置操作符

操作符位于两个参数之间

一元操作符

只有一个参数的操作符

结合性

所有操作符都是左结合（从左到右计算）

：和赋值是右结合

scala高阶函数

接收函数参数的函数

函数式编程

\--------------------------------------------

函数式编程的特点

函数式编程核心价值在于多核编程。

1） 参数私有，没有线程安全问题，这样就为分布式高并发提供了支持

2） 把函数做为参数

3） 把函数的返回值作为参数

定义:在js中方法和函数比较模糊。scala中的函数和方法不同，函数在scala中是一等公民。

格式：(参数：类型):返回值类型 => \{ 表达式； 表达式... \}

函数可以被赋值给其他变量或常量，可以作为参数传递，也可以作为返回值

object TestFunction {
    
              def add(a:Int,b:Int) = { a+b }          //定义对象的方法
    
              def main(args: Array[String]): Unit = {
    
                val fnadd = (a:Int,b:Int) => { a+b }  //定义函数
    
                println(fnadd(10,20))
    
              }
    
            }

\------------------------------------------------------------------------------------------------------------------------

函数编程的威力

任务：已存在一个数字集合，按照奇偶数分成两个集合，下面是java的实现

java实现:

List<Integer> list = new ArrayList<Integer>();
    
            list.add(1); list.add(2); list.add(3); list.add(4); list.add(5);
    
            List<Integer> a = new ArrayList<Integer>();
    
            List<Integer> b = new ArrayList<Integer>();
    
            for(Integer n: list){
    
                if(n%2 == 0){
    
                    a.add(n);
    
                }else{
    
                    b.add(n);
    
                }
    
            }

scala实现

object list {
    
              def main(args: Array[String]): Unit = {
    
                //按奇偶数将集合划分为两个
    
                val f2 = (n:Int) => {n%2 != 0}       //函数遇到奇数返回true，偶数返回false
    
                val array = Array(1,2,3,4,5).toList  //初始化数组
    
                println(array.partition(f2))      // partition分区的意思
    
    
    
                //还可以简写为
    
                println(array.partition((n:Int) => {n%2 != 0}))
    
              }
    
            }

结果：(List(1, 3, 5),List(2, 4))

可以看到函数式编程的好处，让代码变的简单。

以前面向对象是做抽象、继承、封装、多态，以对象的观点去写我们的程序。函数式编程把代码写在一个一个小的函数中，想办法把业务化成一块一块的内容，组合起来完成一个业务。

\------------------------------------------------------------------------------------------------------------------------

函数式的foreach

val list2 = List(1,2,3,4,5)
    
        list2.foreach { x => println(x) }
    
            【foreach源码说明】：
    
                def foreach[U](f: A => U) {      //f是一个函数，A、U都是泛型
    
                    var these = this
    
                    while (!these.isEmpty) {
    
                      f(these.head)      //.head获取到头元素也就是第一个元素
    
                      these = these.tail  //.tail获取到除第一元素后的所有元素
    
                    }
    
                }

集合操作

\------------------------------

def ++\[B\](that: GenTraversableOnce\[B\]): Array\[B\]

合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。类型返回已左侧为准！！

val a = Array(1,2,3)
    
        val b = Array(3,4,5)
    
        val c = a ++ b

//c中的内容是(1,2,3,3,4,5)

\--------------------------------------------------------------------------------------------------------------------------------------

def ++:\[B >: A, That\](that: collection.Traversable\[B\])(implicit bf: CanBuildFrom\[Array\[T\], B, That\]): That

这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型。

val a = List(1,2)
    
        val b = scala.collection.mutable.LinkedList(3,4)
    
        val c = a ++: b
    
        println(c.getClass().getName())

// c的类型是：scala.collection.mutable.LinkedList

\--------------------------------------------------------------------------------------------------------------------------------------

def +:(elem: A): Array\[A\]

在数组前面添加一个元素，并返回新的对象，下面添加一个元素 0

val a = List(1,2)
    
        val c = 0 +: a

// c中的内容是 （0,1,2）

\--------------------------------------------------------------------------------------------------------------------------------------

def :+(elem: A): Array\[A\]

同上面的方法想法，在数组末尾添加一个元素，并返回新对象

\--------------------------------------------------------------------------------------------------------------------------------------

def addString(b: StringBuilder): StringBuilder

将数组中的元素逐个添加到b中

val a = List(1,2,3,4)
    
        val b = new StringBuilder()
    
        val c = a.addString(b)

// c中的内容是 1234

\--------------------------------------------------------------------------------------------------------------------------------------

def addString(b: StringBuilder, sep: String): StringBuilder

同上，每个元素用sep分隔符分开

val a = List(1,2,3,4)
    
        val b = new StringBuilder()
    
        val c = a.addString(b,",")
    
        println("c:  "+c)

// c: 1,2,3,4

\--------------------------------------------------------------------------------------------------------------------------------------

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

同上，在首尾各加一个字符串，并指定sep分隔符

val a = List(1,2,3,4)
    
        val b = new StringBuilder()
    
        val c = a.addString(b,"{",",","}")
    
        println("c:  "+c)

// c: \{1,2,3,4\}

\--------------------------------------------------------------------------------------------------------------------------------------

def mkString: String

将所有元素组合成一个字符串

val a = Array(1, 2, 3, 4, 5)
    
        println(a.mkString)

// return 12345

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

def mkString(sep: String): String

将所有元素组合成一个字符串，以 sep 作为元素间的分隔符

val a = Array(1, 2, 3, 4, 5)
    
        println(a.mkString(","))

// return 1,2,3,4,5

def mkString(start: String, sep: String, end: String): String

将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

val a = Array(1, 2, 3, 4, 5)
    
        println(a.mkString("{",",","}"))

// return \{1,2,3,4,5\}

def aggregate\[B\](z: => B)(seqop: (B, T) => B, combop: (B, B) => B): B

聚合计算，aggregate是柯里化方法，参数是两个方法，为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。

def main(args: Array[String]) {
    
        val a = List(1,2,3,4)
    
        val c = a.par.aggregate(5)(seqno,combine)
    
        println("c:"+c)
    
      }
    
      def seqno(m:Int,n:Int): Int ={
    
        val s = "seq_exp=%d+%d"
    
        println(s.format(m,n))
    
        return m+n
    
      }
    
      def combine(m:Int,n:Int): Int ={
    
        val s = "com_exp=%d+%d"
    
        println(s.format(m,n))
    
        return m+n
    
      }
    
      /**
    
        seq_exp=5+3
    
        seq_exp=5+2
    
        seq_exp=5+4
    
        seq_exp=5+1
    
        com_exp=6+7
    
        com_exp=8+9
    
        com_exp=13+17
    
        c:30
    
      */
    
        上面过程可以简写为
    
        val c = a.par.aggregate(5)(_+_,_+_)

12.04

def apply(i: Int): T

同下面代码，取出指定索引处的元素

val first = numbers(0) // 读取第一个元素

\--------------------------------------------------------------------------------------------------------------------------------------

def canEqual(that: Any): Boolean

判断两个对象是否可以进行比较

\--------------------------------------------------------------------------------------------------------------------------------------

def charAt(index: Int): Char

获取index索引处的字符，这个方法会执行一个隐式的转换，将Array\[T\]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。

val chars = Array('a','b','c')
    
        println("c:"+chars.charAt(0))

//结果 a

\--------------------------------------------------------------------------------------------------------------------------------------

def clone(): Array\[T\]

创建一个副本

val chars = Array('a','b','c')
    
        val newchars = chars.clone()

\--------------------------------------------------------------------------------------------------------------------------------------

def collect\[B\](pf: PartialFunction\[A, B\]): Array\[B\]

通过执行一个并行计算（偏函数），得到一个新的数组对象

val chars = Array('a','b','c')
    
       val newchars = chars.collect(fun)
    
       println("newchars:"+newchars.mkString(","))

//我们通过下面的偏函数，把chars数组的小写a转换为大写的A

val fun:PartialFunction[Char,Char] = {
    
        case 'a' => 'A'
    
        case x => x
    
      }

/\*\*输出结果是 newchars:A,b,c \*/

\--------------------------------------------------------------------------------------------------------------------------------------

def collectFirst\[B\](pf: PartialFunction\[T, B\]): Option\[B\]

在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算

val arr = Array(1,'a',"b")
    
    //定义一个偏函数，要求当被执行对象为Int类型时，进行乘100的操作，对于上面定义的对象arr来说，只有第一个元素符合要求
    
      val fun:PartialFunction[Any,Int] = {
    
        case x:Int => x*100
    
      }

//计算

val value = arr.collectFirst(fun)
    
      println("value:"+value)
    
    //另一种写法
    
        val value = arr.collectFirst({case x:Int => x*100})

\--------------------------------------------------------------------------------------------------------------------------------------

def combinations(n: Int): collection.Iterator\[Array\[T\]\]

排列组合，这个排列组合会选出所有包含字符不一样的组合，对于 “abc”、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组

val arr = Array("a","b","c")
    
        val newarr = arr.combinations(2)
    
        newarr.foreach((item) => println(item.mkString(",")))

/\*\*

a,b

a,c

b,c

\*/

\--------------------------------------------------------------------------------------------------------------------------------------

def contains\[A1 >: A\](elem: A1): Boolean

序列中是否包含指定对象

\--------------------------------------------------------------------------------------------------------------------------------------

def containsSlice\[B\](that: GenSeq\[B\]): Boolean

判断当前序列中是否包含另一个序列

val a = List(1,2,3,4)
    
        val b = List(2,3)
    
        println(a.containsSlice(b))

//true

\--------------------------------------------------------------------------------------------------------------------------------------

def copyToArray(xs: Array\[A\]): Unit

此方法还有两个类似的方法

copyToArray(xs: Array\[A\], start: Int): Unit

copyToArray(xs: Array\[A\], start: Int, len: Int): Unit

val a = Array('a', 'b', 'c')

val b : Array\[Char\] = new Array(5)

a.copyToArray(b) /\*\*b中元素 \['a','b','c',0,0\]\*/

a.copyToArray(b,1) /\*\*b中元素 \[0,'a',b,c,0\]\*/

a.copyToArray(b,1,2) /\*\*b中元素 \[0,'a','b',0,0\]\*/

\--------------------------------------------------------------------------------------------------------------------------------------

def copyToBuffer\[B >: A\](dest: Buffer\[B\]): Unit

将数组中的内容拷贝到Buffer中

val a = Array('a', 'b', 'c')

val b:ArrayBuffer\[Char\] = ArrayBuffer()

a.copyToBuffer(b)

println(b.mkString(","))

\--------------------------------------------------------------------------------------------------------------------------------------

def corresponds\[B\](that: GenSeq\[B\])(p: (T, B) => Boolean): Boolean

判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true

下面代码检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素

val a = Array(1, 2, 3)

val b = Array(4, 5,6)

println(a.corresponds(b)(\_<\_)) //true

\--------------------------------------------------------------------------------------------------------------------------------------

def count(p: (T) => Boolean): Int

统计符合条件的元素个数，下面统计大于 2 的元素个数

val a = Array(1, 2, 3)

println(a.count(\{x:Int => x > 2\})) // count = 1

\--------------------------------------------------------------------------------------------------------------------------------------

def diff(that: collection.Seq\[T\]): Array\[T\]

计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回

val a = Array(1, 2, 3,4)

val b = Array(4, 5,6,7)

val c = a.diff(b)

println(c.mkString) //1,2,3

\--------------------------------------------------------------------------------------------------------------------------------------

def distinct: Array\[T\]

去除当前集合中重复的元素，只保留一个

val a = Array(1, 2, 3,4,4,5,6,6)

val c = a.distinct

println(c.mkString(",")) // 1,2,3,4,5,6

\--------------------------------------------------------------------------------------------------------------------------------------

def drop(n: Int): Array\[T\]

将当前序列中前 n 个元素去除后，作为一个新序列返回

val a = Array(1, 2, 3,4)

val c = a.drop(2)

println(c.mkString(",")) // 3,4

\--------------------------------------------------------------------------------------------------------------------------------------

def dropRight(n: Int): Array\[T\]

功能同 drop，去掉尾部的 n 个元素

def dropWhile(p: (T) => Boolean): Array\[T\]

去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

//下面去除大于2的，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 2,3,4

val a = Array(3, 2, 3,4)

val c = a.dropWhile( \{x:Int => x > 2\} )

println(c.mkString(","))

//如果数组 a 是下面这样，第一个元素就不满足，所以返回整个数组 1, 2, 3,4

val a = Array(1, 2, 3,4)

\--------------------------------------------------------------------------------------------------------------------------------------

def endsWith\[B\](that: GenSeq\[B\]): Boolean

判断是否以某个序列结尾

val a = Array(3, 2, 3,4)

val b = Array(3,4)

println(a.endsWith(b)) //true

\--------------------------------------------------------------------------------------------------------------------------------------

def exists(p: (T) => Boolean): Boolean

判断当前数组是否包含符合条件的元素

val a = Array(3, 2, 3,4)

println(a.exists( \{x:Int => x==3\} )) //true

println(a.exists( \{x:Int => x==30\} )) //false

\--------------------------------------------------------------------------------------------------------------------------------------

def filter(p: (T) => Boolean): Array\[T\]

取得当前数组中符合条件的元素，组成新的数组返回

val a = Array(3, 2, 3,4)

val b = a.filter( \{x:Int => x> 2\} )

println(b.mkString(",")) //3,3,4

\--------------------------------------------------------------------------------------------------------------------------------------

def filterNot(p: (T) => Boolean): Array\[T\]

与上面的 filter 作用相反

def find(p: (T) => Boolean): Option\[T\]

查找第一个符合条件的元素

val a = Array(1, 2, 3,4)

val b = a.find( \{x:Int => x>2\} )

println(b) // Some(3)

\--------------------------------------------------------------------------------------------------------------------------------------

def flatMap\[B\](f: (A) => GenTraversableOnce\[B\]): Array\[B\]

对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类

val a = Array(1, 2, 3,4)

val b = a.flatMap(x=>1 to x)

println(b.mkString(","))

/\*\*

1,1,2,1,2,3,1,2,3,4

从1开始，分别于集合a的每个元素生成一个递增序列，过程如下

1,2

1,2,3

1,2,3,4

\*/

\--------------------------------------------------------------------------------------------------------------------------------------

def flatten\[U\](implicit asTrav: (T) => collection.Traversable\[U\], m: ClassTag\[U\]): Array\[U\]

将二维数组的所有元素联合在一起，形成一个一维数组返回

val dArr = Array(Array(1,2,3),Array(4,5,6))

val c = dArr.flatten

println(c.mkString(",")) //1,2,3,4,5,6

\-------------------------------------------------------------------------------

\-def fold\[A1 >: A\](z: A1)(op: (A1, A1) => A1): A1

对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同，我们来对比一下他们的执行过程。

因为aggregate需要两个处理方法，所以我们定义一个combine方法

def seqno(m:Int,n:Int): Int =\{

val s = "seq\_exp=%d+%d"

println(s.format(m,n))

return m+n

def combine(m:Int,n:Int): Int =\{

val s = "com\_exp=%d+%d"

println(s.format(m,n))

return m+n

val a = Array(1, 2, 3,4)

val b = a.fold(5)(seqno)

/\*\* 运算过程

seq\_exp=5+1

seq\_exp=6+2

seq\_exp=8+3

seq\_exp=11+4

\*/

val c = a.par.aggregate(5)(seqno,combine)

/\*\* 运算过程

seq\_exp=5+1

seq\_exp=5+4

seq\_exp=5+3

com\_exp=8+9

seq\_exp=5+2

com\_exp=6+7

com\_exp=13+17

\*/

看上面的运算过程发现，fold中，seqno是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算

而aggregate中，seqno是把初始值与每个元素相加，但结果不参与下一步运算，而是放到另一个序列中，由第二个方法combine进行处理

\-def foldLeft\[B\](z: B)(op: (B, T) => B): B

从左到右计算，简写方式：def /:\[B\](z: B)(op: (B, T) => B): B

def seqno(m:Int,n:Int): Int =\{

val s = "seq\_exp=%d+%d"

println(s.format(m,n))

return m+n

val a = Array(1, 2, 3,4)

val b = a.foldLeft(5)(seqno)

/\*\* 运算过程

seq\_exp=5+1

seq\_exp=6+2

seq\_exp=8+3

seq\_exp=11+4

\*/

/\*\*

简写 (5 /: a)(\_+\_)

\*/

\-def foldRight\[B\](z: B)(op: (B, T) => B): B

从右到左计算，简写方式：def :\\\[B\](z: B)(op: (T, B) => B): B

def seqno(m:Int,n:Int): Int =\{

val s = "seq\_exp=%d+%d"

println(s.format(m,n))

return m+n

val a = Array(1, 2, 3,4)

val b = a.foldRight(5)(seqno)

/\*\* 运算过程

seq\_exp=4+5

seq\_exp=3+9

seq\_exp=2+12

seq\_exp=1+14

\*/

/\*\*

简写 (a :\\ 5)(\_+\_)

\*/

\--------------------------------------------------------------------------------------------------------------------------------------

def /:\[B\](z: B)(op: (B, T) => B): B

对数组中所有的元素进行相同的操作 ，foldLeft的简写

val a = List(1,2,3,4)

val c = (10 /: a)(\_+\_) // 1+2+3+4+10

val d = (10 /: a)(\_\*\_) // 1\*2\*3\*4\*10

println("c:"+c) // c:20

println("d:"+d) // d:240

\--------------------------------------------------------------------------------------------------------------------------------------

def :\\\[B\](z: B)(op: (T, B) => B): B

foldRight的简写

\-------------------------------------------------------------------------------------------------------------------

\-def forall(p: (T) => Boolean): Boolean

检测序列中的元素是否都满足条件 p，如果序列为空，返回true

val a = Array(1, 2, 3,4)

val b = a.forall( \{x:Int => x>0\}) //true

val b = a.forall( \{x:Int => x>2\}) //false

\-def foreach(f: (A) => Unit): Unit

遍历序列中的元素，进行 f 操作

val a = Array(1, 2, 3,4)

a.foreach(x => println(x\*10))

/\*\*

\*/

\-def groupBy\[K\](f: (T) => K): Map\[K, Array\[T\]\]

按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列，下面代码实现的是，把小于3的数字放到一组，大于3的放到一组，返回Map\[String,Array\[Int\]\]

val a = Array(1, 2, 3,4)

val b = a.groupBy( x => x match \{

case x if (x < 3) => "small"

case \_ => "big"

\})

\-def grouped(size: Int): collection.Iterator\[Array\[T\]\]

按指定数量分组，每组有 size 数量个元素，返回一个集合

val a = Array(1, 2, 3,4,5)

val b = a.grouped(3).toList

b.foreach((x) => println("第"+(b.indexOf(x)+1)+"组:"+x.mkString(",")))

/\*\*

第1组:1,2,3

第2组:4,5

\*/

\-def hasDefiniteSize: Boolean

检测序列是否存在有限的长度，对应Stream这样的流数据，返回false

val a = Array(1, 2, 3,4,5)

println(a.hasDefiniteSize) //true

\-def head: T

返回序列的第一个元素，如果序列为空，将引发错误

val a = Array(1, 2, 3,4,5)

println(a.head) //1

\-def headOption: Option\[T\]

返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None

val a = Array(1, 2, 3,4,5)

println(a.headOption) //Some(1)

\-def indexOf(elem: T): Int

返回elem在序列中的索引，找到第一个就返回

val a = Array(1, 3, 2, 3, 4)

println(a.indexOf(3)) // return 1

\-def indexOf(elem: T, from: Int): Int

返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回

val a = Array(1, 3, 2, 3, 4)

println(a.indexOf(3,2)) // return 3

\-def indexOfSlice\[B >: A\](that: GenSeq\[B\]): Int

检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引

val a = Array(1, 3, 2, 3, 4)

val b = Array(2,3)

println(a.indexOfSlice(b)) // return 2

\-def indexOfSlice\[B >: A\](that: GenSeq\[B\], from: Int): Int

检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，指定从 from 索引处开始

val a = Array(1, 3, 2, 3, 2, 3, 4)

val b = Array(2,3)

println(a.indexOfSlice(b,3)) // return 4

\-def indexWhere(p: (T) => Boolean): Int

返回当前序列中第一个满足 p 条件的元素的索引

val a = Array(1, 2, 3, 4)

println(a.indexWhere( \{x:Int => x>3\})) // return 3

\-def indexWhere(p: (T) => Boolean, from: Int): Int

返回当前序列中第一个满足 p 条件的元素的索引，可以指定从 from 索引处开始

val a = Array(1, 2, 3, 4, 5, 6)

println(a.indexWhere( \{x:Int => x>3\},4)) // return 4

\-def indices: collection.immutable.Range

返回当前序列索引集合

val a = Array(10, 2, 3, 40, 5)

val b = a.indices

println(b.mkString(",")) // 0,1,2,3,4

\-def init: Array\[T\]

返回当前序列中不包含最后一个元素的序列

val a = Array(10, 2, 3, 40, 5)

val b = a.init

println(b.mkString(",")) // 10, 2, 3, 40

\-def inits: collection.Iterator\[Array\[T\]\]

对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象

val a = Array(1, 2, 3, 4, 5)

val b = a.inits.toList

for(i <- 1 to b.length)\{

val s = "第%d个值：%s"

println(s.format(i,b(i-1).mkString(",")))

/\*\*计算结果

第1个值：1,2,3,4,5

第2个值：1,2,3,4

第3个值：1,2,3

第4个值：1,2

第5个值：1

第6个值

\*/

\-def intersect(that: collection.Seq\[T\]): Array\[T\]

取两个集合的交集

val a = Array(1, 2, 3, 4, 5)

val b = Array(3, 4, 6)

val c = a.intersect(b)

println(c.mkString(",")) //return 3,4

\-def isDefinedAt(idx: Int): Boolean

判断序列中是否存在指定索引

val a = Array(1, 2, 3, 4, 5)

println(a.isDefinedAt(1)) // true

println(a.isDefinedAt(10)) // false

\-def isEmpty: Boolean

判断当前序列是否为空

\-def isTraversableAgain: Boolean

判断序列是否可以反复遍历，该方法是GenTraversableOnce中的方法，对于 Traversables 一般返回true，对于 Iterators 返回 false，除非被复写

\-def iterator: collection.Iterator\[T\]

对序列中的每个元素产生一个 iterator

val a = Array(1, 2, 3, 4, 5)

val b = a.iterator //此时就可以通过迭代器访问 b

\-def last: T

取得序列中最后一个元素

val a = Array(1, 2, 3, 4, 5)

println(a.last) // return 5

\-def lastIndexOf(elem: T): Int

取得序列中最后一个等于 elem 的元素的位置

val a = Array(1, 4, 2, 3, 4, 5)

println(a.lastIndexOf(4)) // return 4

\-def lastIndexOf(elem: T, end: Int): Int

取得序列中最后一个等于 elem 的元素的位置，可以指定在 end 之前（包括）的元素中查找

val a = Array(1, 4, 2, 3, 4, 5)

println(a.lastIndexOf(4,3)) // return 1

\-def lastIndexOfSlice\[B >: A\](that: GenSeq\[B\]): Int

判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引

val a = Array(1, 4, 2, 3, 4, 5, 1, 4)

val b = Array(1, 4)

println(a.lastIndexOfSlice(b)) // return 6

\-def lastIndexOfSlice\[B >: A\](that: GenSeq\[B\], end: Int): Int

判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引，可以指定在 end 之前（包括）的元素中查找

val a = Array(1, 4, 2, 3, 4, 5, 1, 4)

val b = Array(1, 4)

println(a.lastIndexOfSlice(b,4)) // return 0

\-def lastIndexWhere(p: (T) => Boolean): Int

返回当前序列中最后一个满足条件 p 的元素的索引

val a = Array(1, 4, 2, 3, 4, 5, 1, 4)

val b = Array(1, 4)

println(a.lastIndexWhere( \{x:Int => x<2\})) // return 6

\-def lastIndexWhere(p: (T) => Boolean, end: Int): Int

返回当前序列中最后一个满足条件 p 的元素的索引，可以指定在 end 之前（包括）的元素中查找

val a = Array(1, 4, 2, 3, 4, 5, 1, 4)

val b = Array(1, 4)

println(a.lastIndexWhere( \{x:Int => x<2\},2)) // return 0

\-def lastOption: Option\[T\]

返回当前序列中最后一个对象

val a = Array(1, 2, 3, 4, 5)

println(a.lastOption) // return Some(5)

\-def length: Int

返回当前序列中元素个数

val a = Array(1, 2, 3, 4, 5)

println(a.length) // return 5

\-def lengthCompare(len: Int): Int

比较序列的长度和参数 len，根据二者的关系返回不同的值，比较规则是

x < 0 if this.length < len

x == 0 if this.length == len

x > 0 if this.length > len

\-def map\[B\](f: (A) => B): Array\[B\]

对序列中的元素进行 f 操作

val a = Array(1, 2, 3, 4, 5)

val b = a.map( \{x:Int => x\*10\})

println(b.mkString(",")) // 10,20,30,40,50

\-def max: A

返回序列中最大的元素

val a = Array(1, 2, 3, 4, 5)

println(a.max) // return 5

\-def maxBy\[B\](f: (A) => B): A

返回序列中第一个符合条件的最大的元素

val a = Array(1, 2, 3, 4, 5)

println(a.maxBy( \{x:Int => x > 2\})) // return 3

\-def nonEmpty: Boolean

判断序列不是空

\-def padTo(len: Int, elem: A): Array\[A\]

后补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

val a = Array(1, 2, 3, 4, 5)

val b = a.padTo(7,9) //需要一个长度为 7 的新序列，空出的填充 9

println(b.mkString(",")) // return 1,2,3,4,5,9,9

\-def par: ParArray\[T\]

返回一个并行实现，产生的并行序列，不能被修改

val a = Array(1, 2, 3, 4, 5)

val b = a.par // "ParArray" size = 5

\-def partition(p: (T) => Boolean): (Array\[T\], Array\[T\])

按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分

val a = Array(1, 2, 3, 4, 5)

val b:(Array\[Int\],Array\[Int\]) = a.partition( \{x:Int => x % 2 == 0\})

println(b.\_1.mkString(",")) // return 2,4

println(b.\_2.mkString(",")) // return 1,3,5

\-def patch(from: Int, that: GenSeq\[A\], replaced: Int): Array\[A\]

批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that

val a = Array(1, 2, 3, 4, 5)

val b = Array(3, 4, 6)

val c = a.patch(1,b,2)

println(c.mkString(",")) // return 1,3,4,6,4,5

/\*\*从 a 的第二个元素开始，取两个元素，即 2和3 ，这两个元素被替换为 b的内容\*/

\-def permutations: collection.Iterator\[Array\[T\]\]

排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样

val a = Array(1, 2, 3, 4, 5)

val b = a.permutations.toList // b 中将有120个结果，知道排列组合公式的，应该不难理解吧

/\*\*如果是combinations\*/

val b = a.combinations(5).toList // b 中只有一个，因为不管怎样排列，都是这5个数字组成，所以只能保留第一个

\-def prefixLength(p: (T) => Boolean): Int

给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p

val a = Array(1,2,3,4,1,2,3,4)

val b = a.prefixLength( \{x:Int => x<3\}) // b = 2

\-def product: A

返回所有元素乘积的值

val a = Array(1,2,3,4,5)

val b = a.product // b = 120 （1\*2\*3\*4\*5）

\-def reduce\[A1 >: A\](op: (A1, A1) => A1): A1

同 fold，不需要初始值

val a = Array(1,2,3,4,5)

val b = a.reduce(seqno)

println(b) // 15

/\*\*

seq\_exp=1+2

seq\_exp=3+3

seq\_exp=6+4

seq\_exp=10+5

\*/

\-def reduceLeft\[B >: A\](op: (B, T) => B): B

从左向右计算

\-def reduceRight\[B >: A\](op: (T, B) => B): B

从右向左计算

\-def reduceLeftOption\[B >: A\](op: (B, T) => B): Option\[B\]

计算Option，参考reduceLeft

\-def reduceRightOption\[B >: A\](op: (T, B) => B): Option\[B\]

计算Option，参考reduceRight

\-def reverse: Array\[T\]

反转序列

val a = Array(1,2,3,4,5)

val b = a.reverse

println(b.mkString(",")) //5,4,3,2,1

\-def reverseIterator: collection.Iterator\[T\]

反向生成迭代

\-def reverseMap\[B\](f: (A) => B): Array\[B\]

同 map 方向相反

val a = Array(1,2,3,4,5)

val b = a.reverseMap( \{x:Int => x\*10\} )

println(b.mkString(",")) // 50,40,30,20,10

\-def sameElements(that: GenIterable\[A\]): Boolean

判断两个序列是否顺序和对应位置上的元素都一样

val a = Array(1,2,3,4,5)

val b = Array(1,2,3,4,5)

println(a.sameElements(b)) // true

val c = Array(1,2,3,5,4)

println(a.sameElements(c)) // false

\-def scan\[B >: A, That\](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom\[Array\[T\], B, That\]): That

用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值

val a = Array(1,2,3,4,5)

val b = a.scan(5)(seqno)

println(b.mkString(",")) // 5,6,8,11,15,20

\-def scanLeft\[B, That\](z: B)(op: (B, T) => B)(implicit bf: CanBuildFrom\[Array\[T\], B, That\]): That

从左向右计算

\-def scanRight\[B, That\](z: B)(op: (T, B) => B)(implicit bf: CanBuildFrom\[Array\[T\], B, That\]): That

从右向左计算

\-def segmentLength(p: (T) => Boolean, from: Int): Int

从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度

val a = Array(1,2,3,1,1,1,1,1,4,5)

val b = a.segmentLength( \{x:Int => x < 3\},3) // 5

\-def seq: collection.mutable.IndexedSeq\[T\]

产生一个引用当前序列的 sequential 视图

\-def size: Int

序列元素个数，同 length

\-def slice(from: Int, until: Int): Array\[T\]

取出当前序列中，from 到 until 之间的片段

val a = Array(1,2,3,4,5)

val b = a.slice(1,3)

println(b.mkString(",")) // 2,3

\-def sliding(size: Int): collection.Iterator\[Array\[T\]\]

从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止

val a = Array(1,2,3,4,5)

val b = a.sliding(3).toList

for(i<-0 to b.length - 1)\{

val s = "第%d个：%s"

println(s.format(i,b(i).mkString(",")))

/\*\*

第0个：1,2,3

第1个：2,3,4

第2个：3,4,5

\*/

\-def sliding(size: Int, step: Int): collection.Iterator\[Array\[T\]\]

从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止

该方法，可以设置步进 step，第一个元素组合完后，下一个从 上一个元素位置+step后的位置处的元素开始

val a = Array(1,2,3,4,5)

val b = a.sliding(3,2).toList //第一个从1开始， 第二个从3开始，因为步进是 2

for(i<-0 to b.length - 1)\{

val s = "第%d个：%s"

println(s.format(i,b(i).mkString(",")))

/\*\*

第0个：1,2,3

第1个：3,4,5

\*/

\-def sortBy\[B\](f: (T) => B)(implicit ord: math.Ordering\[B\]): Array\[T\]

按指定的排序规则排序

val a = Array(3,2,1,4,5)

val b = a.sortBy( \{x:Int => x\})

println(b.mkString(",")) // 1,2,3,4,5

\-def sortWith(lt: (T, T) => Boolean): Array\[T\]

自定义排序方法 lt

val a = Array(3,2,1,4,5)

val b = a.sortWith(\_.compareTo(\_) > 0) // 大数在前

println(b.mkString(",")) // 5,4,3,2,1

\-def sorted\[B >: A\](implicit ord: math.Ordering\[B\]): Array\[T\]

使用默认的排序规则对序列排序

val a = Array(3,2,1,4,5)

val b = a.sorted

println(b.mkString(",")) // 1,2,3,4,5

\-def span(p: (T) => Boolean): (Array\[T\], Array\[T\])

分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合

val a = Array(3,2,1,4,5)

val b = a.span( \{x:Int => x > 2\})

println(b.\_1.mkString(",")) // 3

println(b.\_2.mkString(",")) // 2,1,4,5

\-def splitAt(n: Int): (Array\[T\], Array\[T\])

从指定位置开始，把序列拆分成两个集合

val a = Array(3,2,1,4,5)

val b = a.splitAt(2)

println(b.\_1.mkString(",")) // 3,2

println(b.\_2.mkString(",")) // 1,4,5

\-def startsWith\[B\](that: GenSeq\[B\], offset: Int): Boolean

从指定偏移处，是否以某个序列开始

val a = Array(0,1,2,3,4,5)

val b = Array(1,2)

println(a.startsWith(b,1)) // true

\-def startsWith\[B\](that: GenSeq\[B\]): Boolean

是否以某个序列开始

val a = Array(1,2,3,4,5)

val b = Array(1,2)

println(a.startsWith(b)) // true

\-def stringPrefix: String

返回 toString 结果的前缀

val a = Array(0,1,2,3,4,5)

println(a.toString()) //\[I@3daa57fb

val b = a.stringPrefix

println(b) //\[I

\-def subSequence(start: Int, end: Int): CharSequence

返回 start 和 end 间的字符序列

val chars = Array('a','b','c','d')

val b = chars.subSequence(1,3)

println(b.toString) // bc

\-def sum: A

序列求和，元素需为Numeric\[T\]类型

val a = Array(1,2,3,4,5)

val b = a.sum // 15

\-def tail: Array\[T\]

返回除了当前序列第一个元素的其它元素组成的序列

val a = Array(1,2,3,4,5)

val b = a.tail // 2,3,4,5

\-def take(n: Int): Array\[T\]

返回当前序列中前 n 个元素组成的序列

val a = Array(1,2,3,4,5)

val b = a.take(3) // 1,2,3

\-def takeRight(n: Int): Array\[T\]

返回当前序列中，从右边开始，选择 n 个元素组成的序列

val a = Array(1,2,3,4,5)

val b = a.takeRight(3) // 3,4,5

\-def takeWhile(p: (T) => Boolean): Array\[T\]

返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列

val a = Array(1,2,3,4,5)

val b = a.takeWhile( \{x:Int => x < 3\}) // 1,2

\-def toArray: Array\[A\]

转换成 Array 类型

\-def toBuffer\[A1 >: A\]: Buffer\[A1\]

转换成 Buffer 类型

\-def toIndexedSeq: collection.immutable.IndexedSeq\[T\]

转换成 IndexedSeq 类型

\-def toIterable: collection.Iterable\[T\]

转换成可迭代的类型

\-def toIterator: collection.Iterator\[T\]

同 iterator 方法

\-def toList: List\[T\]

同 List 类型

\-def toMap\[T, U\]: Map\[T, U\]

同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据

val chars = Array(("a","b"),("c","d"),("e","f"))

val b = chars.toMap

println(b) //Map(a -> b, c -> d, e -> f)

\-def toSeq: collection.Seq\[T\]

同 Seq 类型

\-def toSet\[B >: A\]: Set\[B\]

同 Set 类型

\-def toStream: collection.immutable.Stream\[T\]

同 Stream 类型

\-def toVector: Vector\[T\]

同 Vector 类型

\-def transpose\[U\](implicit asArray: (T) => Array\[U\]): Array\[Array\[U\]\]

矩阵转换，二维数组行列转换

val chars = Array(Array("a","b"),Array("c","d"),Array("e","f"))

val b = chars.transpose

println(b.mkString(","))

\-def union(that: collection.Seq\[T\]): Array\[T\]

联合两个序列，同操作符 ++

val a = Array(1,2,3,4,5)

val b = Array(6,7)

val c = a.union(b)

println(c.mkString(",")) // 1,2,3,4,5,6,7

\-def unzip\[T1, T2\](implicit asPair: (T) => (T1, T2), ct1: ClassTag\[T1\], ct2: ClassTag\[T2\]): (Array\[T1\], Array\[T2\])

将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列

val chars = Array(("a","b"),("c","d"))

val b = chars.unzip

println(b.\_1.mkString(",")) //a,c

println(b.\_2.mkString(",")) //b,d

\-def unzip3\[T1, T2, T3\](implicit asTriple: (T) => (T1, T2, T3), ct1: ClassTag\[T1\], ct2: ClassTag\[T2\], ct3: ClassTag\[T3\]): (Array\[T1\], Array\[T2\], Array\[T3\])

将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列

val chars = Array(("a","b","x"),("c","d","y"),("e","f","z"))

val b = chars.unzip3

println(b.\_1.mkString(",")) //a,c,e

println(b.\_2.mkString(",")) //b,d,f

println(b.\_3.mkString(",")) //x,y,z

\-def update(i: Int, x: T): Unit

将序列中 i 索引处的元素更新为 x

val a = Array(1,2,3,4,5)

a.update(1,9)

println(a.mkString(",")) //1,9,3,4,5

\-def updated(index: Int, elem: A): Array\[A\]

将序列中 i 索引处的元素更新为 x ,并返回替换后的数组

val a = Array(1,2,3,4,5)

val b = a.updated(1,9)

println(b.mkString(",")) //1,9,3,4,5

\-def view(from: Int, until: Int): IndexedSeqView\[T, Array\[T\]\]

返回 from 到 until 间的序列，不包括 until 处的元素

val a = Array(1,2,3,4,5)

val b = a.view(1,3)

println(b.mkString(",")) //2,3

\-def withFilter(p: (T) => Boolean): FilterMonadic\[T, Array\[T\]\]

根据条件 p 过滤元素

val a = Array(1,2,3,4,5)

val b = a.withFilter( \{x:Int => x>3\}).map(x=>x)

println(b.mkString(",")) //4,5

\-def zip\[B\](that: GenIterable\[B\]): Array\[(A, B)\]

将两个序列对应位置上的元素组成一个pair序列

val a = Array(1,2,3,4,5)

val b = Array(5,4,3,2,1)

val c = a.zip(b)

println(c.mkString(",")) //(1,5),(2,4),(3,3),(4,2),(5,1)

\-def zipAll\[B\](that: collection.Iterable\[B\], thisElem: A, thatElem: B): Array\[(A, B)\]

同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem

val a = Array(1,2,3,4,5,6,7)

val b = Array(5,4,3,2,1)

val c = a.zipAll(b,9,8) //(1,5),(2,4),(3,3),(4,2),(5,1),(6,8),(7,8)

val a = Array(1,2,3,4)

val b = Array(5,4,3,2,1)

val c = a.zipAll(b,9,8) //(1,5),(2,4),(3,3),(4,2),(9,1)

\-def zipWithIndex: Array\[(A, Int)\]

序列中的每个元素和它的索引组成一个序列

val a = Array(10,20,30,40)

val b = a.zipWithIndex

println(b.mkString(",")) //(10,0),(20,1),(30,2),(40,3)

wordcount案例

\-----------------------------------

val str = List("hello world","how are you hello","ni hao")

println(str.map(x=>x.split(" ")))

println(str.map(x=>x.split(" ").toList))

println(str.flatMap(x=>x.split(" ")))

println(str.flatMap(x=>x.split(" ")).map(x=> (x,1)))

println(str.flatMap(x=>x.split(" ")).map(x=> (x,1)).groupBy(x=>x.\_1))

println(str.flatMap(x=>x.split(" ")).map(x=> (x,1)).groupBy(x=>x.\_1).map(x=>(x.\_1,x.\_2.map(x=>x.\_2).reduce(\_+\_))))

Scala一种编程语言

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Python——一种多范式编程语言

相关 JavaScript：一种强大的编程语言

相关 JavaScript是一种单线程编程语言

相关 Scala 语言输出的三种方式

相关 Scala 语言输出的三种方式

相关 python是一种什么编程语言-想自学一种编程语言，各种编程语言都有什么区别？...

相关 Scala是多范式编程语言

相关 Scala编程基础语法（一）

相关 Scala一种编程语言

相关 Scala编程语言视频教程|Spark基础--快学Scala