集合部分
一、数组
1. 可变数组
1. 创建可变数组
val arrayBuffer = new ArrayBuffer()
2. 使用伴生对象进行创建
val ret = ArrayBuffer(1,2,3)
3. 修改数组元素
ret(1) = 1
4. 添加元素
1. 操作符方式 += 返回的是同一个数组
val ret1 = ret += 15
或者
var ret2 = 15 +=: ret
2. 调用方法名的方式 向后添加
ret.append(18)
3. 向前添加
ret.prepend(91)
4. 指定位置进行添加
ret.insert(1, 98)
5. 删除元素
1. 传索引值[连续删除多少]
ret.remove(1)
2. 删除一个元素
ret -= 66
6. 可变数组转为不可变数组
val array: Array[Int] = ret.toArray
7. 不可变数组转为可变数组
val buffer = array.toBuffer
8. 创建多维数组 创建两行三列的数组
val array1: Array[Array[Nothing]] = Array.ofDim(2, 3)
2. 不可变数组
1. 创建不可变数组 new Array[Type](length)
val ints = new Array[Int](10)
2. 直接调用apply方法创建数组等价于 Array(1,2,3) 底层调用的还是apply方法
val ints1 = Array.apply(1, 2, 3)
3. 获取元素用小括号
ints1(0) // 区第一个位置的元素
4. 修改元素
ints1(2) = 6 也可以 ints.update(2, 6)
5. 循环数组
1. 索引的方式 打印索引
for(ele <- ints1.indices){
println(ele)
}
2. 加强for循环的方式
for(item <- ints1){
println(item)
}
3. 迭代器方式
val iterator = ints1.iterator
while (iterator.hasNext){
println(iterator.next())
}
4. 类似Javalambda表达式的输出
ints1.foreach((ele: Int) => {println(ele)})
// 添加一个数组元素 调用操作符的方法就是返回一个新的数组 底层new一个新的
6. 操作符的方式 :+是添加到末尾 +:添加到头部
val ret = ints1.:+(23)
ret.appended(15) // 末尾追加
ret.prepended(15) // 头部追加
二、列表
1. 可变列表
1. 创建一个可变ListBuffer对象
val value: ListBuffer[Int] = new ListBuffer[Int]()
2. 通过伴生对象创建ListBuffer
val listBuffer = ListBuffer(11, 22, 33, 44)
3. 添加元素
1. 追加元素
listBuffer.append(19)
2. 头部添加元素
listBuffer.prepend(50)
3. listBuffer.insert(1, 66)
4. 合并两个listbuffer
val value1 = listBuffer ++ value
5. 更新元素
listBuffer.update(2,3)
6. 删除
listBuffer.remove(2) // 传索引
或者
listbuffer -= 5 // 删除元素5
2. 不可变列表
1. 因为List底层是一个抽象类 所以只能用伴生对象 list不可变
val list = List(22,33,11)
2. 也可以通过nil去创建 在一个空列表中添加一条数据 Nil是一个空列表
val i = 19 :: Nil
3. for循环
list.foreach((ele: Int) => {println(ele)})
4. 添加元素
val value = list.::(15)
// 头部添加
val value = list.appended(66)
// 尾部添加
val value = list.prepended(66)
5. 合并两个列表
val value1 = i ::: value
或者
val value2 = i ++ value
三、集合
一、可变集合
1. 都是引用set所处的包不一样 创建可变set
val value = mutable.Set(1, 2, 3, 4, 5, 6)
2. 添加 add会返回当前集合是否存在该元素
value.add(51)
3.删除 remove会返回当前集合是否存在该元素
value.remove(51)
4. 合并两个set
val value1 = value ++= value
二、不可变集合
1. 创建不可变set
val set = Set(1,2,3,1)
2. 添加元素
val value = set.+(6)
3. 合并set
val value1 = set ++ value
4. 删除
val value2 = value1.-(6)
四、Map
一、可变Map
1. 创建可变map
val value: mutable.Map[String, Int] = mutable.Map("a"->13, "b"->191)
2. 添加元素 用put方法
value.put("pp", 97)
3. 删除
value.remove("pp")
4. 更新元素
value.update("pp" ,666)
5. 合并 ++= 后面的添加到前面 key相同会覆盖
map = value ++= value2
二、不可变Map
1. 创建不可变map key->value 这种格式
val map1:Map[String, Int] = Map("a"->13, "b"->191)
2. 获取所有key
map1.keys
3. 获取所有value
map1.values
4. 访问有值会返回some类型 没有访问到返回None类型
println(map1.get("a").get)
println(map1.get("e"))
println(map1.getOrElse("a", "999"))
println(map1.getOrElse("e", "999")) // 获取不到取默认值
五、元组
1. 创建tuple 用小括号括起来 一个元组最多只能有22个元素
val tuple1 = (1,2,3)
2. 通过下划线+元素的顺序 访问元素
tuple1._1
3. 遍历元组
for(ele <- tuple1.productIterator){
println(ele)
}
六、常用的方法
1. 获取头
list.head
2. 获取尾元素集合 获取的不是最后一个元素 而是除了头所有的元素
list.tail
3. 获取尾
list.last
4. 反转列表元素
list.reverse
5. 获取前n个元素
list.take(n)
6. 获取除了前n个元素剩下所有的
list.drop(n)
7. 并集
val list1: List[Int] = List(1, 2, 3, 4)
val list2: List[Int] = List(4,5,6,7)
val value = list1.union(list2)
8. 交集
list1.intersect(list2)
9. 差集
list1.diff(list2)
10. 拉链 就是py的zip
value = list1.zip(list2)
11. 滑窗
val value: Iterator[List[Int]] = list1.sliding(2,2) // 创建一个大小为2的窗口,步长为2
12. 比较大小、排序
val list1: List[(Int, Int)] = List((1, 2), (3, 4), (5, 6), (7, 8))
list1.maxBy(_._2) // 根据第二个元素进行大小比较 当参数只有一个的时候就可以用下划线代替
list1.minBy(_._2)
list1.sortBy(_._2)
13. 反转排序
list1.sorted.reverse
14. 传入排序规则的排序
val list1: List[Int] = List(1,3,2,4,5)
list1.sortWith((a:Int, b:Int) => {a < b}) // 传入的规则是从小到大的顺序 经过简化后就是下面的式子
// 简化步骤 类型可以去掉、一行代码去掉大括号、由于所有变量按顺序只出现一次所以可以用_代替
list1.sortWith( _ < _)
七、高阶函数的应用
val list1: List[Int] = List(1,3,2,4,5)
1. filter函数 过滤
list1.filter(_ % 2 == 0) // 过滤出全部的偶数
2. map函数 对每个元素进行操作
list1.map( _ * 2)
3. 扁平化 将集合内的元素打散 和多个列表合并一个效果
val value = List(List(1, 2), List(3, 4), List(5, 6))
val flatten = value.flatten
4. groupBy 按照结果分组
value.groupBy( _ % 2) // 根据结果进行分组(当前是根据对二取余的结果进行分组)
5. reduce函数 对每个元素进行操作
1. 第一个数和第二个数进行操作 其结果作为下次操作的第一个数
2. reduce 底层调用reduceLeft方法 从左边开始计算
val i = value.reduce((a, b) => {
a + b // a+b的结果在下次计算又被作为第一个参数传入
})
// 特殊情况 reduceRight 虽然是从右开始计算但是递归调用的方式
// 1 - (2 - (3 - (4 - 5)))
val i1 = value.reduceRight((a, b) => {
a - b
})
6. fold 就是给一个初始值 然后对每个值进行操作 和reduce很像
value.fold(10)(_ + _) //这里需要传两个参数 一个是初始值 一个是操作
value.foldRight(10)(_ - _) // 这样和reduceright一样计算的方式 1- (2- (3 - (4 - (5 -10))))
fold 传入的初始值和操作的两个数的类型必须相同,如果不能相同就要用foldLeft这个方法
map2.foldLeft(map1)((mergeMap, kv) => {
mergeMap是初始值map1, kv是map2的每个item
})
八、队列和栈
1. 定义一个可变队列
val queue = new mutable.Queue[Int]()
// 入队操作
queue.enqueue(1,2,3,1)
// 出队
queue.dequeue()
2. 定义一个栈
val stack: mutable.Stack[Int] = new mutable.Stack[Int]()
// 压栈
stack.push(1,2,3)
// 弹栈
stack.pop()