Scala之集合中常用的方法(6)

一  集合中常用的方法

1  集合之间的转换(重点)

1. toArray  将其他类型的集合转换成数组
2. toList    将其他类型的集合转转成list
3. toSet     将其他类型的集合转换成Set(有去重功能 ,但是distinct 方法也可以达到去重的效果)
4. toSeq     将其他类型的集合转换成Seq序列
5. toMap     将对偶类型的集合转换成Map
6. toString    将其他类型转换成字符串

注意 : 迭代器遍历时需要将其转为数组或者集合

2   foreach

迭代遍历集合中的每个元素, 对每个元素进行处理 ,但是没有返回值 ,常用于打印结果数据 !

val ls = List(1,3,5,7,9)
ls.foreach(println)       打印每个元素
ls.foreach(println(_))    打印每个元素
ls.foreach(x=>println(x*10))    每个元素乘以10 打印结果
ls.foreach(x=>print(x+" "))     打印每个元素,空格隔开

3   map函数

适用于任何集合 (列表 ,数组 ,Map 中都有 map函数 ,元组中没有 map 函数)

需要注意在 Map 集合中的用法

map 函数遍历每个元素处理返回原集合类型的新集合 ,也可以不返回数据

------定义数组和集合-------
val arr = Array[String]("JAVA", "C++", "SCALA")     ---定义一个 Array 数组
val ls = List(1, 3, 5, 7, 9)                      ------定义一个 List 集合
val set = Set(1, 3, 5, 7)                           ------定义一个 Set 集合
val mp = Map[String, Int]("ZSS" -> 100, "LSS" -> 99)   ----定义一个 Map 集合

-----map函数遍历每个元素处理返回原集合类型的新集合------
val new_arr: Array[String] = arr.map(x => x)
val new_list: List[Int] = ls.map(x => x)
val new_set: Set[Int] = set.map(x => x)

------Map集合----使用map函数------
val new_Map1: Map[String, Int] = mp.map({ case v: (String, Int) => (v._1, v._2 * 10) })
val new_Map2: Map[String, Int] = mp.map(e => (e._1, e._2 + 100))  ---去key 和 value 值

-------map函数也可以不返回数据------
ls.map(println(_))

4   filter 和 filterNot

使用于 Array数组  List 和 Map 集合

filter 返回符合自己条件的新的集合 ,filterNot 返回不符合自己要求/条件的新的集合

-----定义一个List集合 ,范围是 :1 2 3 4 5 6 7 8 9 10
val ls: List[Int] = List.range(1,10)

-------filter方法筛选过滤每个元素 ,模除2 = 0 的元素组成一个新的集合---------
ls.filter(x=>x%2==0)      ------x=>x 可以用 _ 表示
val new_list: List[Int] = ls.filter(_ % 2 == 0)    ----  _ 代表每个元素
new_list .foreach(x=>print(x+"  "))  ---打印结果为 : 2  4  6  8

-------filterNot方法-----筛选过滤出不符合自己条件的元素并组成新的集合---------
ls.filterNot(_%2!=1).foreach(x=>print(x+"  ")) ---- 1  3  5  7  9 

4.1  每个元素进行过滤

-----定义一个Set集合-----
val set = Set("spark" , "scala" , "c++" , "java")

-----过滤出开头是 "s" 的元素-------
val new_set: Set[String] = set.filter(_.startsWith("s"))

----过滤出长度>3的元素------
set.filter(_.length>3)

4.2   多条件filter 进行条件过滤, 可以使用匹配模式 ,也可以使用逻辑与(&&) 或者逻辑或( || )   -------多条件过滤就要使用这个

------定义一个集合-----
val ls = "spark":: "scala" :: "c++"::"java"::1::2::12.34d::Nil
-----过滤出选出String类型的和Double类型的数据-----
-----匹配模式---case....-------
ls.filter{
  case i:String => true  -----过滤出集合中是字符类型的元素
  case i:Int=>false      -----过滤出不是 Int 类型的元素
  case i:Double=>true    -----过滤出集合中是小数 /浮点类型的元素
} 

------使用filter进行多条件过滤--------
val map = Map[String,Int](("zss" ,91),("zww",89),("zx",92) , ("ww",23))
map.filter(_._1.startsWith("z") && _._1.length>2)   ---使用了逻辑与

4.3  连续使用多次filter进行条件过滤 (不建议使用 ,因为使用一次 filter就返回一个新的集合,就要对这个新的集合进行再次过滤 ,效率上会低)

------连续使用多次filter进行条件过滤
val map = Map[String,Int](("zss" ,91),("zww",89),("zzx",92) , ("ww",23))
map.filter(_._1.startsWith("z")).filter(_._2>90)

5  collect 支持偏函数

常用于 Array数组  List   Map

collect 函数也可以遍历集合中的每个元素处理返回新的集合(对集合中的某种或某几种元素进行处理 ,筛选出想要的数据再对筛选出的数据进行处理 ) , collect 实现了 filter 和 map 特性.

-----定义一个混合集合 ,有整数也有字符元素-----
val res: List[Int] = List(1, 2, 3, 4, 5, 6,"hello")

-----------表现形式1---------
----------筛选出模除 2= 0 的整数 ,然后在对这些符号条件的元素进行 *10 处理---------
res.collect({case i:Int if i%2==0=>i*10})
res.foreach(println)  ----- 40  60

-------表现形式2----------collect实现filter和map特性-------
list.collect({ 
case i: Int => i * 10
case i: String => i.toUpperCase
}).foreach(println)

6   min 和 max ,minBy 和 maxBy

常用于 Array数组  List   Map

6.1  min 和 max 

-------数组-------
val arr = Array(1,2,345,67,5)
arr.min      ----求集合中的最小值
arr.max      ----求集合中的最大值
arr.sum      ----求集合中每个元素相加的总和 -----sum 方法仅适用元素都是整数或浮点数类型的集合

-------List--------
val ls = List(1,2,345,67,5)
ls.min
ls.max
ls.sum

-------Set---------
val set = Set(1,2,345,67,5)
set.min
set.max
set.sum

-------Map---------默认按照 key 排序获取最大和最小数据
val map = Map[String,Int]("a"->10, "b"->99 , "c"->88)
map.min  -----(a,10)
map.max  -----(c,88)

6.2   minBy 和 maxBy

集合中的 min 和 max 可以获取任意集合中的最小和最大值 ,但是如果集合中存储的是用户自定义的类 ,或者是按照 Map 集合中的 key ,value 规则排序的话 ,就需要用户指定排序规则

6.2.1  Map 集合中按照 value 取最小和最大

val map = Map[String,Int]("a"->10, "b"->99 , "c"->88)

------map默认是按照key排序获取最大和最小数据
------这里需要按照value排序,取 value 的最大值和最小值
map.maxBy(x=>x._2)   -----(b,99)    
map.minBy(x=>x._2)   -----(a,10)

_2 代表 value  , _1 代表 Map集合中的 key

6.2.2  Map 集合中存储的是用户自定义的类型

----用户自定义的类型------
class User(val name:String ,val age:Int) {}

-----通过年龄属性进行过滤-----
println(ls.maxBy(x => x.age).name)

7  count 和 sum

适用于 数组 / List / Map

----定义一个数组-----
val arr = Array(1,2,6,8,5)

----计算数组元素的和(所有元素相加之和)---只有数组中所有元素是整数时才可以用
arr.sum 

---计算出符合条件的集合元素的个数 / 数量-------count
arr.count(_>5)  -----array list  set 统用

val ls = List("hello" , "hi" , "heihei" , "tom")
ls.count(_.startsWith("h"))----元素开头是"h"的元素的数量
ls.count(_.equals("hello"))----元素是"hello"的个数
ls.count(_ == "hello")      ----元素是"hello"的个数
-----忽略大小写
ls.count(_.equalsIgnoreCase("HELLO"))
-----统计符合条件的map元素的数量 
val map = Map[String,Int]("a"->10,"ab"->10, "b"->99 , "c"->88)
map.count(x=>x._1.startsWith("a"))
map.count(_._2>10)

8  find

适用于 数组 / List / Map

查找符合要求的元素 ,匹配到就返回数组 ,最多只返回一个(只返回符合条件的第一个元素 ,没有符合的就返回None)

object Find01 {
  def main(args: Array[String]): Unit = {
    val arr = Array(1,3,4,6,88)

   ----find 方法只返回符合条件的第一个元素 ,后面符合的都不返回了-----
    val maybeInt: Option[Int] = arr.find(x => x > 3)
    maybeInt.foreach(println(_))    ---4
  }
}

9   flatten( Map 集合中不能使用 ,需要将其转为 List 或者 Array)

适用于 数组 List

压平 ,将一个集合展开(获取下层集合的所有元素) ,组成一个新的集合

 ---flatten方法 ,将集合元素压平 ,进行扁平化 
val list = List("zss HUU","TII lii")
 list.flatten.foreach(println(_))  ------ z s s  H U U T I I l i i

--将集合进行扁平化 ,获取下层集合的所有元素,将集合中不同子集合中的元素都取出来,装到一个新的集合中
 val list2 = List(Array("ZSS","LII"),Array("HUU"))
 list2.flatten.foreach(println)   ---- ZSS  LII  HUU

10  flatMap (重要!!!)

适用于 数组 List

map函数 + flatten 函数的组合 ,先遍历集合中的每个元素 ,再按照指定的规则压平 ,返回压平后的新的集合

val ls = List("today is my first day of my life" , "so I feel so happy")

------map处理每个元素 就是处理每句话
 ls.map(x=>println(x))

------获取集合中的每个元素   获取两句话   然后再扁平成字符
ls.flatMap(x=>x)

------指定扁平化的规则 按照空格压平  压平的规则
ls.flatMap(x=>x.split(" ")).foreach(println) ----获取到每个单词

----------示例 ,从外部读取文件 ,统计文件中每个单词出现的个数---------flatten 和 flatMap 函数的比较---------------------------

    --示例1----flatten方法----------
    -----读取文件 ,并将文件存储在缓存区----------
    val bufferedSource = Source.fromFile(new File("D://word.txt"))

    ------从缓存区中读取文件,一行一行的读取,并获取一行一行的数据----
    val lines: Iterator[String] = bufferedSource.getLines()

    -----对读取的行数据进行遍历 ,然后处理每一行的数据 ,根据规则切割成一个个单词------
    -----一行的单词为一个数组 ,这里得到很多数组,每个数组中有一个个单词-----------
    val wordsArrs: Iterator[Array[String]] = lines.map(_.split("\\s+"))

    ------将其转为 List 集合 ,然后压平 ,获取单词
    val words: Seq[String] = wordsArrs.toList.flatten  ----------得到所有的单词

    -----将单词进行遍历 ,组装成(单词,1)的元组 ,然后将其转为List集合 ,再按照单词进行分组----
    -----单词相同的被分为一个集合中存储 : Map(单词,List((单词,1),(单词,1)))---------
    val wordgroup: Map[String, List[(String, Int)]] = words.map((_, 1)).toList.groupBy(_._1)

   -----Map集合中第一个元素是单词 ,第二个元素的长度就是单词出现的次数--------
    ----然后得到一个List(单词,出现的总次数) ,根据总次数,可以对List集合进行排序-----
   wordgroup.map(e=>(e._1,e._2.size)).toList.sortBy(_._2).foreach(println(_))

    --示例2-----flatMap方法---------
    ---读取文件,获取里面的数据,将其存储到缓存区----
    val bs = Source.fromFile(new File("D://word.txt"))

    ---读取文件,一行行的读取,然后将以行为集合的数据进行扁平化 ,获取所有元素,并将其进行切割---
    val words1 = bs.getLines().flatMap(_.split("\\s+"))

    ---得到文件中所有的单词,遍历转为(单词,1)的元组形式 ,将其转为List集合,根据单词进行分组---
    ---得到Map集合(单词,List((单词,1),(单词,1)) ,第一个元素是单词,第二个元素的长度就是单词出现的总次数---
    -----遍历,将结果打印出来 ,如果要根据单词出现的次数进行排序可以根据示例1的方式进行操作---
    words1.map((_,1)).toList.groupBy(_._1).map(mp=>(mp._1,mp._2.size)).foreach(println)

11  sorted

适用于 数组 List Map

sorted 适用于简单的数字 / 字符串等排序规则简单的集合的排序 , 如果需要定制化排序建议使用 sortBy 和 sortWith 函数

--------------List---------------
val  list = List (1, 34 , 32 , 12 , 20 ,44 ,27)
------返回排好序的list集合   默认从小到达排序
val sorted: List[Int] = list.sorted

--------------Array-----------------
val arr = Array("jim" , "cat" , "jong" , "huba")
------字符串默认按照先后排序
val sorted_arr: Array[String] = arr.sorted

---------------Map-----------------
val map = Map[String , Int]("aeiqi"->4 , "qiaozhi"->2 , "baji"->34)

------map集合也没有sorted 函数 只有转换成List或者Array集合 默认按照key字典先后排序
val sorted_map: Seq[(String, Int)] = map.toList.sorted
sorted_map.foreach(println)

12   sortBy 和 sortWith

适用于 数组  List  Map

   ---------------------示例 ,统计文件中每个单词出现的次数 ,并且按照出现的次数进行排序--------------------------------

  ----------------统计文件中每个单词出现的次数----------------
    val bs = Source.fromFile(new File("D://word.txt"))
    val words = bs.getLines().flatMap(_.split("\\s+"))
    val wordAndOne = words.map((_, 1)).toList.groupBy(_._1)
    val wordCount = wordAndOne.map(mp => (mp._1, mp._2.size))

    ---------------------排序的方法--------------------------
    ---------------sortWith------------------------
    wordCount.toList.sortWith((x1,x2)=>x1._2 > x2._2).foreach(println(_))     ----降序
    wordCount.toList.sortWith((x1,x2)=>x1._2 < x2._2).foreach(println)        ----升序

    ---------------sortBy----------------------
    wordCount.toList.sortBy(_._2).foreach(println)              ---升序
    wordCount.toList.sortBy(-_._2).foreach(println)             ---降序

    wordCount.toArray.sortBy(_._2).foreach(println)            ---升序
    wordCount.toArray.sortBy(-_._2).foreach(println)           ---降序

var arr = Array(1, 11, 23, 45, 8, 56)

---------------sortBy-----------
val arr1 = arr.sortBy(x => x) --------(1, 8, 11, 23, 45, 56)   -----升序排序----------
val arr2 = arr.sortBy(x => -x) ---------(56, 45, 23, 11, 8, 1)   -----倒序排列---

----------sortWith---------
arr.sortWith((x, y) => x > y)    ---降序
arr.sortWith((x, y) => x < y)    ----升序

--------------------------------------------------------------自定义类型在集合中的排序----------------------------------------------

case class User(name:String,age:Int)   ----写一个样例类

object sort01{
  def main(args: Array[String]): Unit = {
----定义一个个对象并赋值-------
val u1 = new User("wuji", 34)
val u2 = new User("zhiruo", 24)
val u3 = new User("zhoamin", 44)
val u4 = new User("cuishan", 64)

----将一个个对象组成一个数组-----
var arr = Array(u1, u2, u3, u4)
---------sortBy-----------------
arr.sortBy(user => user.name)     ----按照姓名字典排序
arr.sortBy(user => user.age)      ----年龄小到大
arr.sortBy(user => -user.age)     -----数值类型的排序可以直接使用- 来倒序排列 年龄大到小
---------sortWith---------------
arr.sortWith((user1, user2) => user1.age > user2.age)   -----年龄大到小
arr.sortWith((user1, user2) => user1.age < user2.age)   -----年龄小到大
arr.sortWith((user1, user2) => user1.name < user2.name)  -----姓名字典升序
arr.sortWith((user1, user2) => user1.name > user2.name)  -----姓名字典降序
  }
}

13  partition 和 span

适用于 数组  List  Map

13.1   partition 将数组按照指定的规则分组 ,只能分为2组 , 返回一个对偶元组 . (集合(前面符合条件的),集合(不符合条件的))

满足条件的数据放在前面的集合 ,不满足的放在后面的集合 (因为这个只能分为两组 ,意义不大 ,一般用 groupBy--按照某种规则分组)

13.2  span 从头开始遍历每个元素进行分组,如果条件不满足就终止分组[顺序性],结束运行

val  list = List(1,2,3,4,5,6,7,8,9)
----------partition----------------
----将集合根据条件分成两组返回一个存储集合的元组第一个集和实符合要求的元素------
val res: (List[Int], List[Int]) = list.partition(x=>x%3==0)
----结果为 : (List(3, 6, 9),List(1, 2, 4, 5, 7, 8))

----------span-------------
----从头开始遍历每个元素进行分组,如果条件不满足就终止分组[顺序性],结束运行------
val tuple1: (List[Int], List[Int]) = list.span(_ > 3)  
---集合第1个元素就不满足条件 ,所以结束分组 ,结束运行-------所以得到一个空集合-----
tuple1.productIterator.foreach(println)  -----List()    List(1, 3, 5, 6, 7, 4, 8)

partition 与 filter 的区别 :

• filter 只保留符合条件的数据集
• partition 分开保留符合条件和不符合条件的数据集,并将其组装成元组

14  grouped 和 groupBy(重要 ,常用!!!)

grouped : 将集合中的元素按照指定的个数进行分组

groupBy : 将集合中的数据按照指定的规则进行分组 (常用 ,重要 !!!)

    ------定义数组集合-----
    val list = List(1,2,3,4,5,6,7)
    val list2 = List("ZSS","LII","YUU","FOO")

    -----------------------------group(n) 按一组 n 个元素进行分组------------
      list.grouped(3).foreach(println(_))   ----List(1, 2, 3)  List(4, 5, 6)  List(7)
      list2.grouped(2).foreach(println(_))  -----List(ZSS, LII)  List(YUU, FOO)

      val iterator: Iterator[List[String]] = list2.grouped(2)
      var i =0
      iterator.toList.map(ls=>{
        i += 1
        println("第" + i + "组")
        ls.foreach(println(_))   ------第一组 ZSS LII    第2组 YUU FOO
      })

    ----------------------------groupBy(_,xx) 根据某种规则进行分组------------
    list.groupBy(_ > 3).foreach(println(_))  --(true,List(4, 5, 6, 7))  (false,List(1, 2, 3))
    val res: Map[Boolean, List[Int]] = list.groupBy(_ > 3)
    val op = res.get(true)     -----获取符合条件的一组数据
    if(op.isDefined){
      op.get.foreach(println(_))    ----4 5 6 7
    }

    val map = Map[String,Int]("peiqi" -> 5, "jong" -> 3, "baji" -> 12)
    ----按照key和value的内容分组
    println(map.groupBy(mp => mp._1))
    println(map.groupBy(mp => mp._2))

15   reduce 

底层调用的是 reduceLeft ,从左边开始运算元素

    val lsit = List(1,2,3,4)
    println(lsit.reduce((x1, x2) => x1 + x2))   ---运算公式:(((1+2)+3)+4)=  10
    println(lsit.reduce((x1, x2) => x1 * x2))   ---(((1*2)*3)*4)=  24
    println(lsit.reduce((x1, x2) => x1 - x2))   ---(((1-2)-3)-4)=  -8
    println(lsit.reduce(_ - _))                 ---  -8

    val list2 = List("A","B","C")
    println(list2.reduce((s1, s2) => (s"$s1  $s2")))   --- A B C


    val mp = Map(("shaolin",88),("wudan",77),("emei",66))
    println(mp.reduce((m1, m2) => (s"${m1._1}:${m2._1}",m1._2+m2._2))) ---(shaolin:wudan:emei,231)

16   reduceLeft 和 reduceRight

reduceLeft : 从左边开始运算元素

reduceRight : 从右边开始运算元素

  val list = List(1, 3, 5, 7, 9)
  val arr = Array("a", "b", "c","d","e")
  val map = Map(("shaolin",88),("emei", 77),("wudang",99))

  -----------reduceLeft-------------
  val res1: Int = list.reduceLeft(_+_)    ---执行顺序是  1+3)+5)+7)+9
  val res01: Int = list.reduceLeft(_-_)    1-3)-5)-7)-9
  val res2: String = arr.reduceLeft((a1, a2)=>a1+","+a2)   ---a,b),c),d),e
  val res3: (String, Int) = map.reduceLeft((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))
  println(res1)  -----25
  println(res2)  ------a,b,c,d,e
  println(res3)  -----(shaolin emei wudang,264)

  -----------reduceRight---------------
  val res11: Int = list.reduceRight(_+_)     -------25
   ---------执行顺序是  a,(b,(c,(d,e)))    a2  右边的最后一个元素
  val res12: String = arr.reduceRight((a1, a2)=>a1+","+a2)    --------a,b,c,d,e
  val res13: (String, Int) = map.reduceRight((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))  
  val res14: Int = list.reduceRight(_-_)  
  println(res14)    ----5

  println(res11)  ---25
  println(res12)  ---a,b,c,d,e
  println(res13)  ---(shaolin emei wudang,264)
  println(res14)  ---  5-(7-9)-->5-(7-9)-->3-(5-(7-9))-->1-(3-(5-(7-9)))

17   交集差集并集

intersect : 获取两个集合的交集(两个集合中重叠 / 相同的元素)

diff : 获取两个集合的差集(取一个集合中与另一个集合不相同的元素)

union : 获取两个集合的并集(在 2.13 版本中被 concat 替代了)

val arr1 = Array(1, 3, 5, 7, 0)
val arr2 = Array(5, 7, 8, 9)
val res1: Array[Int] = arr1.intersect(arr2)  -----交集 5  7  取两个集合中相同的元素
val res2: Array[Int] = arr1.diff(arr2)   -----差集  1  3    取与arr2集合不相同的元素
val res3: mutable.ArraySeq[Int] = arr1.union(arr2) ----1,3,5,7 ,5,7,8,9  并集,两个集合合并
val res4: mutable.ArraySeq[Int] = res3.distinct -----1,3,5,7,8,9  去重,将重复的元素去除

18   distinct 和 distinctBy

去除集合中的重复的元素 ,可以去除简单类型的数据 ,也可以除去自定义的类型(底层依然是 hashCode 和 equals)

---------distinct---------------
val arr1 = Array("a", "a","ab","cat" ,"hellocat" ,"hicat")
val newarr: Array[String] = arr1.distinct     ---将集合中重复的元素去除
newarr.foreach(println)    --"a" "ab"  "cat" "hellocat" "hicat"

----------distinctBy 条件去重-----------
val arr1 = Array(new User("ls",21),new User("ls",22),new User("zss",21))
----------去除重名的重复数据---根据年龄去重
val res: Array[User] = arr1.distinctBy(x=>x.age)
res.foreach(x=> println(x.name))

19  zip 和 zipWithIndex

zip  :   实现拉链式拼接 ,只要操作的集合是迭代集合就可以拼接

zipWithIndex : 简单理解为遍历集合中的每个元素 ,将每个元素打上对应的索引值 ,组成元组(element,index) ,返回新的集合 .

    ----定义数组和集合------
    val list = List(1,2,3,4)
    val arr = Array("A","B","C","D")
    val mp = Map[String,Int]("aa"->11,"bb"->22,"cc"->33)

    -----zip ,拉链操作 ,将两个集合组装成元组模式--------
    arr.zip(list).foreach(println)   ---- (A,1) (B,2) (C,3)  (D,4)
    list.zip(mp).foreach(println(_))  ----(1,(aa,11))  (2,(bb,22))  (3,(cc,33))

    -----zipWithIndex ,遍历组装的元组 ,遍历每个元素,并为每个元组/元素打上对应的索引值--------
    arr.zip(list).zipWithIndex.foreach(println)  ---((A,1),0) ((B,2),1) ((C,3),2) ((D,4),3)
    arr.zipWithIndex.foreach(println(_))   ---(A,0) (A,0) (C,2) (D,3)

20  mkString

将集合中的每个元素拼接成字符串

    val arr = Array("A","B","C","D")
    println(arr.mkString(":"))  ---A:B:C:D
    println(arr.mkString("+"))  ---A+B+C+D

21  fold,foldLeft和foldRight

折叠是归约操作类似于reduce函数 ,但是fold函数中多出来一个初始值(需要有一个初始值在)

val arr = Array("tom" , "cat" , "jim" , "rose")
----遍历集合中的每个元素进行拼接  比reduce函数多出一个初始值
val res:String = arr.fold("hello")(_+" "+_)
println(res)   ---hello tom cat jim rose

val ls = List(1,3,5,7)
----100+1)+3)+5)+7 底层调用的是 foldLeft
val res2 = ls.fold(100)(_+_)   ---116 
ls.foldLeft(100)(_+_)   ---116

----从右边开始运算   默认的值先参与运算进来
----7-10)-->5-(-3)-->3-8 -->1-(-5)
val res01: Int = ls.foldRight(10)(_-_) ---- 6

22  scan

有一个初始值 ,从一个初始值开始 ,从左向右遍历每个元素 ,进行积累的 op 操作 ,每遍历一个元素 ,都需要加上之前遍历累加的元素和

val arr = Array("cat" , "jim" , "tom")
-----结果为 : ArraySeq(hello, hello cat, hello cat jim, hello cat jim tom)
arr.scan("hello" )(_+" "+_)

val nums = List(1,2,3)
-----结果为 : List(10,10+1,10+1+2,10+1+2+3) = List(10,11,12,13)
val result = nums.scan(10)(_+_)   

23   slice 和 sliding

slice(start index, end index) : 提取列表中从开始索引到结束索引位置的元素 ,但是不包含结束索引位置的元素

sliding(size:Int ,step:Int) :  : 将列表按照固定大小size进行分组 ,步进为 step ,step默认为1,返回结果为迭代器 Iterator[List[A]] ,遍历迭代器需要将其转为 List 或者Array 才能进行遍历

    val arr  = Array(1,2,3,4,5,6)
    -----slice-----
    arr.slice(1, 3).foreach(println(_))    ---- 2 3

    -----sliding----
    -----参数一:子集的大小    参数二:步进--------  
    val iterator: Iterator[Array[Int]] = arr.sliding(2, 2)
    -----迭代器转 List 集合遍历-------
    val list: Seq[Array[Int]] = iterator.toList
    list.foreach(e=>e.foreach(println(_)))  ----List(List(1, 2), List(3, 4), List(5, 6))

24  take / takeRight / takeWhile

take : 默认从左边开始取元素

takeRight : 默认从右边开始取值

takeWhile : 从头(左)开始取值 ,符合条件就取值 ,不符合条件就立刻不取值并且立刻终止程序运行

val arr = Array("a", "b", "c" ,"d","e","f")
-----take----从左边获取三个元素 组成新的数组集合
arr.take(3).foreach(println(_))   ----a b c

----takeRight---从右边开始取 n 个值,组成新的数组集合
arr.takeRight(2).foreach(println)   ----e f

----takeWhile---从左边开始,符合条件就取值,不符合条件就终止程序,不取值
arr.takeWhile(_.startsWith("c")).foreach(println) ---开头元素的首字母不是c ,程序结束,没有值
arr.takeWhile(_.startsWith("a")).foreach(println(_))  ---a