0%

scala集合操作

scala集合操作

高阶函数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 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映射操作来将集合中的每一个元素通过指定功能直射成新的结果集,即将函数作为参数传递给两外一个函数,此为函数式编程

1
2
3
4
5
6
7
8
9
10
11
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是将集合中的每个元素的子元素映射到某个函数并返回新的集合

1
2
3
4
5
6
7
8
9
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是筛选出符合要求的数据放到新的集合中

1
2
3
4
5
6
7
8
9
10
11
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

1
2
3
4
5
6
7
8
9
10
// 接收两个参数,返回一个
// 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

1
2
3
4
5
6
7
val sum01 = listInt.fold(0)(add)
// 6
println(sum01)

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

scan扫描

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

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

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

拉链合并

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

1
2
3
4
5
6
// 拉链合并
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方法从集合中获取一个迭代器,使用迭代器来对集合进行遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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)
}

参数类型推断

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

  1. 参数类型可以推断时,可以省略参数类型
  2. 当传入的函数,只有单个参数时,可以省去括号
  3. 如果变量只在=>右边只出现一次,可以用_来代替
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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(_ + _))