Scala学习笔记(三)

集合部分

一、数组

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()