scala集合操作

高阶函数

高阶函数就是可以接受函数参数的函数，也可以返回函数类型

// f:Int => Int  表示一个函数，接收Int类型参数，返回Int
// n1:Int  是一个普通参数
def test (f:Int => Int,n1:Int) :Int =  {
  // 执行所传入的函数
  f(n1)
}

def double(d : Int) = {
   2 * d
}

// f: () => Unit表示无参，返回值为Unit
def test2(f: () => Unit): Unit ={

}

// 注意传入的double函数不需要加()，如果加了()表示的是将操作结果传递到test函数中
println(test(double,2))

就像java8中的stream操作，java8中的很多操作都是从scala中吸取过来的

map映射操作

scala中可以通过map映射操作来将集合中的每一个元素通过指定功能直射成新的结果集，即将函数作为参数传递给两外一个函数，此为函数式编程

def double(d : Int) = {
    println("传入值为"+d)
     2 * d
  }

val listInt: List[Int] = List(1, 2, 3)
// def map[B](f: A => B): List[B]
// 将listInt集合元素遍历，将各个元素传递给double方法，得到新的值，将得到的新的值放入到新的集合
val list = listInt.map(double)
// List(2, 4, 6)
println(list)

flatMap映射

flatMap是将集合中的每个元素的子元素映射到某个函数并返回新的集合

val listString = List[String]("Tom","Jack")
// def flatMap[B](f: A => IterableOnce[B]): List[B]
val list1 = listString.flatMap(upper)
// List(T, O, M, J, A, C, K)
println(list1)

def upper(s:String) = {
    s.toUpperCase
}

filter过滤

filter是筛选出符合要求的数据放到新的集合中

def even(num: Int): Boolean = {
  if (num % 2 == 0) {
    true
  } else {
    false
  }
}
// def filter(p: A => Boolean): List[A]
val list2 = listInt.filter(even)
// List(2)
println(list2)

reduce化简

reduce是将二元函数引用于集合中的函数，函数有三个reduce、reduceLeft、reduceRight

// 接收两个参数，返回一个
// def reduce[B >: A](op: (B, B) => B): B = reduceLeft(op)
// reduceLeft的运行是 从左边开始执行将得到的结果返回给第一个参数，然后继续和下一个参数运行，直到结束
val sum = listInt.reduce(add)
// 6
println(sum)

def add(num1: Int, num2: Int): Int = {
    num1 + num2
}

fold折叠

fold是将上一步返回的值作为函数的第一个参数继续传递参与运算，直到结束，与reduce类似，只不过需要提供第一个值，同样有三个函数fold、foldLeft、foldRight

val sum01 = listInt.fold(0)(add)
// 6
println(sum01)

def add(num1: Int, num2: Int): Int = {
    num1 + num2
}

scan扫描

scan是对某个集合中的所有元素做fold操作，但是会将产生的中间结果放在一个集合中保存

val list3 = listInt.scan(0)(add)
// List(0, 1, 3, 6)
println(list3)

def add(num1: Int, num2: Int): Int = {
    num1 + num2
}

拉链合并

两个集合之间进行对偶元素合并

// 拉链合并
val listInt1: List[Int] = List(1, 2, 3)
val listInt2: List[Int] = List(4, 5, 6)
val listInt3 = listInt1.zip(listInt2)
// List((1,4), (2,5), (3,6))
println(listInt3)

如果两个集合个数不相等，会按照数量少的集合进行合并，另一个集合多余的数据会被丢弃

迭代器

可以通过iterator方法从集合中获取一个迭代器，使用迭代器来对集合进行遍历

val list = List[Int](1, 2, 3, 4, 5)

val it: Iterator[Int] = list.iterator

println("遍历")
for(item <- it){
  println(item)
}

// 一个Iterator只能遍历一次，之后遍历就没哟数据了
println("再次遍历")
for(item <- it){
  println(item)
}

参数类型推断

参数推断省去类型信息，可以进行相应的简写

参数类型可以推断时，可以省略参数类型
当传入的函数，只有单个参数时，可以省去括号
如果变量只在=>右边只出现一次，可以用_来代替

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

def addOne(x: Int) = {
  x + 1
}

// 正常调用函数
//List(2, 3, 4, 5)
println(list.map(addOne))
// 使用匿名函数
//List(2, 3, 4, 5)
println(list.map((x: Int) => x + 1))
// 参数类型可以推断时，可以省略参数类型，省略Int类型
//List(2, 3, 4, 5)
println(list.map((x) => x + 1))
// 当传入的函数，只有单个参数时，可以省去括号
//List(2, 3, 4, 5)
println(list.map(x => x + 1))
// 如果变量只在=>右边只出现一次，可以用_来代替
//List(2, 3, 4, 5)
println(list.map(_ + 1))

def sum(x: Int, y: Int) = {
  x + y
}

// 正常调用函数
// 10
println(list.reduce(sum))
// 使用匿名函数
// 10
println(list.reduce((x: Int, y: Int) => x + y))
// 参数类型可以推断时，可以省略参数类型，省略Int类型
// 10
println(list.reduce((x,y) => x + y))
// 如果变量只在=>右边只出现一次，可以用_来代替
// 10
println(list.reduce(_ + _))