scala集合操作

基本介绍

将集合中的每一个元素通过指定的功能（函数）映射（转换）成新的结果集合这里其实就是所谓的将函数作为参数传递给另一个函数，这就是函数式编程的特点。

map函数签名

def map[B](f:(A)=>B):HashSet[B] //map函数签名

1. [B]是泛型
2. map是一个高阶函数（可以接收一个函数的函数），可以接收函数:f:(A)=>B
3. HashSet[B]就是返回的新的集合

高阶函数

1. 接收有参的

  def main(args: Array[String]): Unit = {
    val res = test(sum2, 100.00)
    println(res)

    // 在scala中，可以把一个函数直接赋给一个变量，但是不执行函数
    val f1 = myPrint _
    f1() // 执行
  }

  def myPrint()={
    println("hello world")
  }

  // 1.test就是一个高阶函数
  // 2.f:Double=>Double 表示一个函数，该函数可以接收一个Double，返回Double
  // 3.n1:Double 普通参数
  // 4.f(n1)在test函数中，执行你传入的参数
  def test(f: Double=>Double, n1:Double) ={
    f(n1)
  }

  // 普通的函数，接收一个Double，返回一个Double
  def sum2(d: Double):Double = {
    println("sum2 被调用")
    d+d
  }

2. 接收无参的

 def main(args: Array[String]): Unit = {
    test(sayOk)
  }

  // test是一个高阶函数，可以接收一个没有输入，返回unit的函数
  def test(f:()=>Unit)={
    f()
  }

  def sayOk() = {
    println("Ok")
  }

map函数

def main(args: Array[String]): Unit = {

    val list = List(3, 5, 7)

    // 1.将list这个集合的元素，依次遍历
    // 2.将各个元素传递给multiple函数 => 新的Int
    // 3.将得到的新Int，放入到一个新的集合并返回
    // 4.因此multiple将会被调用三次
    val list2 = list.map(multiple)

    println(list2)

  }

  def multiple(n : Int) : Int ={
    n*n
  }

flatMap函数

flatmap:flat即压扁，压平，扁平化，效果就是将集合中的每个元素的子元素映射到某个函数并返回新的集合

 val list = List("zhangshan", "lisi", "wangwu")
    // 注意每个字符串也是char集合
    val newList = list.flatMap(x => x.toUpperCase)
    // 输出结果
    // List(Z, H, A, N, G, S, H, A, N, L, I, S, I, W, A, N, G, W, U)
    println(newList)
  }

filter函数

将符合要求的数据（筛选）放置到新的集合中

  val list = List("Zhangsan", "lishi")
    // 过滤集合中以Z为开头的字符串集合
    val newList = list.filter(x => x.startsWith("Z"))
    // 输出结果
    // List(Zhangsan)
    println(newList)

化简

将二元函数引用于集合中的函数

reduceLeft

 val list = List(1,3,5,7,9)
    //val sum = list.reduceLeft((x, y)=> x+y)
    //println(sum)

    // 说明
    // 1.reduceLeft(f)接收的函数需要的形式为：op(B,A)=>B):B
    // 2.reduceLeft(f)的运行规则是从左边开始执行将得到的结果返回给第一个参数
    // 3.然后继续和下一个元素运行，将得到的结果继续返回给第一个参数，继续...
    // 4.即((((1+3)+5)+7)+9)
    val res = list.reduceLeft(sum)

    println(res)
  }

  def sum(n1 : Int, n2 : Int): Int={
    n1+n2
  }

reduceRight

def main(args: Array[String]): Unit = {
    val list = List(1, 3, 5)
    //(3-5)
    //1-(3-5)
    val newList1 = list.reduceRight(minus)
    println(newList1)

    //(1-3)
    //(1-3)-5
    val newList2 = list.reduceLeft(minus)
    println(newList2)
  }

  def minus(n1 : Int, n2 : Int): Int={
    n1 - n2
  }

fold函数

fold函数将上一步返回的值作为函数的第一个参数继续传递参与运算，直到list中的所有元素被遍历，可以把reduceLeft看做简化版的foldLeft

迭代器

通过iterator方法从集合获得一个迭代器，通过while循环和for表达式对集合进行遍历

  val iterator = List(1, 3, 5, 7, 9).iterator

    // 遍历方式1：while
    while (iterator.hasNext){
      println(iterator.next())
    }

    // 遍历方式2：for
    for(item <- iterator){
      println(item)
    }

拉链

在开发中，当我们需要将两个集合进行 对偶元组合并，可以使用拉链

    val list1 = List(1, 3, 5)

    val list2 = List(2, 4, 6)

    val result = list1.zip(list2)
    // 输出结果
    // List((1,2), (3,4), (5,6))
    println(result)

1. 拉链的本质就是两个集合的合并操作，合并后每个元素是一个对偶元组
2. 如果两个集合个数不对应，会造成数据丢失
3. 集合不限于List，也可以是其他集合，比如Array
4. 如果要取出合并后的各个对偶元组的数据，可以遍历

 for (item <- result){
      println(item._1+"    "+item._2)
    }