文章目录
- 集合常用函数
- 一、基本属性和常用操作
- 1、常用方法
- 2、案例示例
- 二、衍生集合
- 1、衍生集合常用方法操作
- 2、案例示例
- 三、集合简单计算函数
- 1、常用计算操作
- 2、案例示例
- 四、集合计算高级函数
- 1、语义说明
- 2、案例示例
集合常用函数
一、基本属性和常用操作
1、常用方法
(1) 获取集合长度
(2) 获取集合大小
(3) 循环遍历
(4) 迭代器
(5) 生成字符串
(6) 是否包含
注意：这些是集合类型的通用操作
2、案例示例
总结：获取集合的长度使用lenght方法，对于线性的序列都可以用lenght方法来获取长度，但是像那种无序的集合，像Set集合，就不能用lenght方法，可以用size方法，来获取大小。遍历的话可以用for循环，获取迭代器。或者foreach方法都可以。生成字符串，使用mkstring()方法，这个方法非常好用。判断这个元素在集合中是否包含，使用contains()方法，如果存在返回true，如果不存在返回false
package Scala03_shujujiegou
//这些是集合类型的通用的一些常用操作
class test11_tongyong {
}
object test11_tongyong{
def main(args: Array[String]): Unit = {
val list = List(6,9,6,89,99) //熟悉的列表
val set = Set(6,8,6,1) //Set集合，不关心这个有多长因为他根本是无序的，所以关心的是他的大小
//(1) 获取集合长度
println(list.length) //获取长度length方法,只要是线性的序列都可以用lenght方法，如果是那种无序的可以用size
//println(set.lenght) //对于某一些类型而言是没有lenght这个属性的，比如Set集合
println(set.size) //对于无序的用大小比较合适，
println("================")
//(2) 获取集合大小
println(list.size) //获取大小size方法
//(3) 循环遍历
for (i <- list){
println(i)
}
for (i <- 0 until list.length){
println(list(i))
}
println("============")
//(4) 迭代器
val iter = list.iterator //while循环的迭代器
while (iter.hasNext){
println(iter.next())
}
for (i <- list.iterator){ //for循环的迭代器
println(i)
}
//(5) 生成字符串
println(list.mkString(",")) //用字符串连接在一起mkString方法
//(6) 是否包含
println(list.contains(6)) //判断这个元素是否存在，contains方法。如果存在返回true，不存在返回false
}
}
二、衍生集合
1、衍生集合常用方法操作
说明：
(1) 获取集合的头
(2) 获取集合的尾 (不是头的都是尾)
(3) 集合最后一个数据
(4) 集合初始数据 (不包含最后一个)
(5) 反转集合
(6) 取前(后) n 个元素
(7) 去掉前(后) n 个元素
(8) 交集
(9) 并集
(10) 差集
(11) 拉链
(12) 滑窗
2、案例示例
总结：大概分两种，一个集合的操作，和两个集合的操作
一个集合：
获取集合的头使用head方法，也就是集合的第一个元素。获取集合的尾，使用tail方法，注意除了头其他的元素都是尾。获取集合的最后一个元素，使用last方法。获取集合的初始数据，使用init方法，注意除了集合的最后一个元素，其他的元素都是初始数据。反转集合，使用reverse方法，这个方法很常用。取集合的前几个元素或者后几个元素，使用take()方法，里面的参数是取几个，取后几个元素用takeRight方法，相当于从后面开始取，但是输出来的元素的顺序还是没变的。去掉前几个元素或者后面几个元素，使用drop()方法，里面的参数是去掉几个元素，去掉后面几个元素使用dropRight()方法。
两个集合的操作：
求两个集合的并集，使用union()方法，里面的参数是要求并集的集合，注意如果是Set集合做并集的操作的话，那么会自动去重。两个集合的交集使用intersect()方法。求两个集合的差集使用diff()方法，里面的参数第二个集合，差集的意思是就是前面那个集合有的，第二个集合没有的元素，称之为差集。求两个集合的拉链，使用zip方法，两个集合的拉链的意思是两个集合中的元素一一对应，然后返回一个二元组的形式。求集合的滑窗，这个是一个集合的操作，使用sliding()方法，里面的参数是要每一个滑窗的元素个数，滑窗的意思是第一次输出123个元素，第二次输出的是234，这样依次滑下称之为滑窗，要是里面有两个参数的话，那么第二个参数就是步长
package Scala03_shujujiegou
//衍生集合方法
class test12_yansheng {
}
object test12_yansheng{
def main(args: Array[String]): Unit = {
val list = List(6,12,33,45,56)
val list2 = List(32,65,45,46,321)
// (1) 获取集合的头
println(list.head) //获取集合的头使用head方法，可迭代的类型都可以用，一般在有序的类型里面有，无序的不考虑头和尾
// (2) 获取集合的尾 (不是头的都是尾)
println(list.tail) //获取集合的尾用tail方法，注意除了头其他所有的元素都是尾
// (3) 集合最后一个数据
println(list.last) //获取集合的最后一个元素使用last方法
// (4) 集合初始数据 (不包含最后一个)
println(list.init) //init方法，除了最后一个元素，其他的元素都是初始数据
// (5) 反转集合
println(list.reverse) //reverse方法，将集合给翻转过来
// (6) 取前(后) n 个元素
println(list.take(3)) //取前几个元素用take方法
println(list.takeRight(3)) //取后几个元素，用takeRight方法，从右边开始取,顺序是不变的
// (7) 去掉前(后) n 个元素
println(list.drop(3)) //去掉前几个元素用drop方法
println(list.dropRight(3)) //全掉后几个元素用dropRight方法
//前面的都是一个集合做的操作，后面的时候基于两个集合做的操作
// (8) 并集
println("==============")
val union = list.union(list2) //求两个集合的并集也就是合在一起，使用union方法
println("并集："+union)
println(list ::: list2) //获取使用 :::
//如果是set做并集。那么重复的数据会被去重
val set = Set(6,12,33,45,56)
val set2 = Set(32,65,45,46,321,6)
val union2 = set.union(set2)
println(union2)
println(set ++ set2)
println("===============")
// (9) 交集
val jiaoji = list.intersect(list2) //求两个集合的交集使用intersect方法
println(jiaoji)
// (10) 差集
val diff = list.diff(list2) //就是以前面那个表为基准，list里有的元素，list2里没有的元素就是差值
println(diff)
println("==============")
// (11) 拉链
//这个拉链的意思是两个集合里的元素一一对应，返回一个一个的二元组
println(list.zip(list2)) //两个集合的拉链使用zip方法，如果某一个集合多出来一个元素，那么就不显示那一个
// (12) 滑窗
//滑窗的意思是，第一次取123元素，第二次去234，每次取三个这样滑下去，每次取多少可以定义
println(list.sliding(3)) //滑窗使用sliding方法，里面的参数是每次滑的元素是几个，可以看到是一个迭代器
for(i <- list.sliding(3)){ //使用类似于迭代器的方式遍历出来
println(i)
}
println("================")
//要是里面有两个参数的话，第二个参数是步长，一个参数的时候默认步长是1
for(i <- list.sliding(3,2)){
println(i)
}
}
}
三、集合简单计算函数
1、常用计算操作
说明：
(1) 求和
(2) 求乘积
(3) 最大值
(4) 最小值
(5) 排序
2、案例示例
总结：
求集合的和使用sum方法，或者自己用增强for循环写，在外面定义一个变量初始值为0，然后进行累加。求集合里元素的乘积使用product方法。求集合里元素的最大值使用max方法。求集合里元素的最小值使用min方法。排序使用sorted方法，默认是升序，要是想降序的话，可以先排序，然后翻转列表，可以到达效果，
例如：println(list.sorted.reverse)
要是像是二元组什么的，默认是按照第一个参数排序，第一个参数是String类型的，第二个参数是Int类型的，要是想按照数字排序的话，那么就是用sortBy方法
例如：println(list.sortBy(_._2))
还有第三种方法，sortWith这个方法相当于Java里面的比较器
例如：println(list.sortWith((a,b) => {a<b}))如果a<b那么就不交换就是升序，可以简化为println(list.sortWith(_ < _))
package Scala03_shujujiegou
//集合常用简单计算函数
class test13_jiandanjisuan {
}
object test13_jiandanjisuan{
def main(args: Array[String]): Unit = {
val list:List[Int] = List(5,1,8,2,3,4)
val list2 = List(("a",2),("c",1),("f,3"),("b",8))
// (1) 求和
//自己用for循环写
var sum = 0
for (i <- list){
sum += i //sum初始值为0，依次取出list列表里的值相加，最后结果不就是总和嘛
}
println("list的和为："+sum)
println(list.sum) //直接调用sum方法，直接就出来了
// (2) 求乘积
println(list.product) //求成绩使用product方法
// (3) 最大值
println(list.max) //求最大值使用max方法
// (4) 最小值
println(list.min) //求最小值使用min方法
// (5) 排序
//要做排序的话肯定是基于有序的集合类型才是有效的
//1,sorted
println(list.sorted) //这是升序，从小到大
println(list.sorted.reverse) //哈哈降序可以先排序然后翻转列表，可以达到效果
//传入隐式参数，降序排列 不传参数默认就是升序
//println(list.sorted(Ordered[Int]))
//2,sortBy
//像那种二元组第一个值是String类的第二个类型是Int类型的，直接println(sortBy(_._2))就可以了，
//3,sortWith 这个方法相当于java里的比较器
println("================")
println(list.sortWith((a,b) => {a<b})) //a小于b的时候不用交换，如果a大于b就交换
println(list.sortWith(_ < _ )) //可以直接简化成这个样子
}
}
四、集合计算高级函数
1、语义说明
(1) 过滤
遍历一个集合并从中获取满足指定条件的元素组成一个新的集合
(2) 转换/映射(map)
将集合中的每一个元素映射到某一个函数
(3) 扁平化 (flatten)
有点像两个列表要合并，列表里面还套着列表，我们要将他打散，这样的操作就叫做扁平化
(4) 扁平化+映射 注：flatMap相当于先进行map操作，再进行flatten操作集合中的每个元素的子元素映射到某个函数并返回新的集合
(5) 分组(group)
按照指定的规则对集合的元素进行分组，分组是转换成了map
(6) 简化(reduce归约)
这个有点像reduce
(7) 折叠(fold)
2、案例示例
总结：
1、过滤使用filter()函数，里面的参数是一个函数，比如选取列表中的偶数可以写为：
val list2 = list1.filter(a => a % 2 == 0) 就可以将数组中所有的偶数筛选出来
2、映射使用map()函数，比如将集合中的每个数*2，可以写为：
println(list1.map(a => a * 2))
3、扁平化使用flatten函数，两个列表合并，列表中又嵌套了列表，将列表中的元素一个个拆开，然后合并成一个新的列表，比如：println(list1.flatten)
4、扁平映射，使用flatMap函数，就是先映射然后进行扁平化，就是将一组单词进行分词，然后保存成新的列表，比如：
println(list1.flatMap(a => a.spilt(" "))) //split函数使用空格分割单词，然后直接完成了映射扁平操作
5、分组使用groupBy()函数，里面的参数也是一个函数，比如列表里面有奇数和偶数:
println(list.groupBy(_ % 2)) 对2取余就只有两个结果一个是0，一个是1，然后就会自动分成两个组
再比如有一个需求，列表里都是单词，然后按照单词的首字母进行分组，首字母一样的都是一个组：
println(list.groupBy(a => a.charAT(0))) //charAt取单词的某个字母，参数是索引，然后就完成了单词的首字母的分组
package Scala03_shujujiegou
//集合高级计算函数
class test14_gaojijisuan {
}
object test14_gaojijisuan{
def main(args: Array[String]): Unit = {
val list = List(1,2,3,4,5,6,7,8,9)
//1、过滤
//选取偶数
val evenlist = list.filter(a => a % 2 == 0) //这里面传入的是一个函数
val evenlist1 = list.filter(_ % 2 ==0 ) //可以简化成这样
println(evenlist) //取余为0那么都是偶数
println(evenlist1)
//取奇数
println(list.filter(_ % 2 == 1)) //可以直接不用赋值也可以
//2、map
//把集合中每个数乘2
println(list.map(_ * 2)) //传入的参数也是一个函数
println(list.map(a => a * a)) //这个是求平反方，这个就不能用_ * _了因为没有两个参数
println("================")
//3、扁平化
//列表合并，将每一个列表拆成一个一个的元素，这种操作就是扁平化
val list3:List[List[Int]] = List(List(1,2,3),List(4,5,6),List(6,7,8,9)) //这里这里面是list里面嵌套一个list
val flatlist =list3(0) ::: list3(1) ::: list3(2) //先用索引吧每一个列表取出来，然后用:::合并在一起
println(flatlist)
//flatten ，上面那种方式要是数据非常的多那么就非常麻烦一个一个写出来，flatten方法一下就出来了
val flatlist2 = list3.flatten //直接用flatten方法就完成了扁平化了
println(flatlist2)
println("=================")
//4、扁平映射
//将一组字符串进行分词，并保存成单词的列表
//split方法是java里面的，包装在scala里面就是Array[String]类型的一个数组。所以相当于用map函数进行了映射，将这个数组转化为List
val strings: List[String] = List("hello","word","scala","hello scala","hello java","we study")
val split:List[Array[String]] = strings.map(a => a.split(" ")) //使用split方法，空格拆分
val flattenList = split.flatten //首先经过映射之后，再调用flatten方法进行扁平化处理
println(flattenList)
println(split.flatten)
//有个更简单的操作,flatMap函数，直接包含了先映射再扁平的这两步操作
val flatmapList = strings.flatMap(a => a.split(" "))//相当于直接进行了转换然后在传入spilt操作
println(flatmapList)
println("==============")
//5、分组groupBy
//直接列表有奇数和偶数，直接分成两组
val groupMap = list.groupBy(_ % 2) //对2取余就只有两个结果嘛一个是0，一个是1，然后这两种结果分为两个组了
val groupMap2 = list.groupBy(a => { //用上面那个就行了
if(a % 2 ==0){
println("偶数")
}else{
println("奇数")
}
})
println(groupMap)
println(groupMap2)
//给定一组词汇，按照单词的首字母进行分组
val wordList = List("china","aex","alice","canda","cary","bob","japan")
println(wordList.groupBy(a => a.charAt(0))) //charAt方法取单词的首字母
}
}
(6) 简化(reduce归约)
sum都是一个归约操作，里面参数是两个相同类型的，最后最后结果就是一个数字
例如：println(list.reduce((a,b) => a * b))
(7) 折叠(fold)
折叠操作和reduce是一样的，有一个初始值，
例如：println(list.fold(10)(_ + _)) //然后初始值在前面 10 + 然后后面列表里的数依次相加
注意：reduce和fold折叠的区别就在于，fold有初始值，reduce没有初始值
package Scala03_shujujiegou
//高级计算函数
class test14_gajijisuan2 {
}
object test14_gajijisuan2{
def main(args: Array[String]): Unit = {
//reduce 类
val list = List(1,2,3,4,5,6,7,8,9)
//1、reduce (规约)
println(list.reduce((a,b) => a * b))//里面的参数是一个函数,其实sum就是一个规约操作，最后只剩下了一个数
val list2 = List(3,4,5,8,10)
println(list2.reduce(_ - _)) //默认是reduceLeft，跟reduceRight不一样
println(list2.reduceRight(_ - _)) //他这个结果是一个尾递归底层是这样的3-(4-(5-(8-10))) 结果就是-6
println("=======================")
//2、fold(折叠)
// 过程：10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
println(list.fold(10)(_ + _)) //前面那个参数是初始值，后面那个参数是操作。比如数组加起来45然后加个10
println(list.foldLeft(10)(_ - _)) //10 - 1 -2 -3 -4 -5 -6 -7 -8 -9
println(list.foldRight(10)(_ - _)) // 1 -(2 -(3 -(4 -(5 -(6 -(7 -(8 -(9 -10))))))))) 先是 9 -10
}
}
