不可变集合List

说明
（1）List默认为不可变集合
（2）创建一个List（数据有顺序，可重复）
（3）遍历List
（4）List增加数据
（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
（6）取指定数据
（7）空集合Nil

案例实操
object TestList {
    def main(args: Array[String]): Unit = {
        //（1）List默认为不可变集合
        //（2）创建一个List（数据有顺序，可重复）
        val list: List[Int] = List(1,2,3,4,3)
        //（7）空集合Nil
        val list5 = 1::2::3::4::Nil
        //（4）List增加数据
        //（4.1）::的运算规则从右向左
        //val list1 = 5::list
        val list1 = 7::6::5::list
        //（4.2）添加到第一个元素位置
        val list2 = list.+:(5)
        //（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
        val list3 = List(8,9)
        //val list4 = list3::list1
        val list4 = list3:::list1
        //（6）取指定数据
        println(list(0))
        //（3）遍历List
        //list.foreach(println)
        //list1.foreach(println)
        //list3.foreach(println)
        //list4.foreach(println)
        list5.foreach(println)
    }
}

创建:
**
创建有元素的
val l1 = List(1, 2, 3)
println(l1) //输出: List(1, 2, 3)
创建空集合,下面是两种方式
val l2 = ListInt
val l3 = Nil
println(l2) //输出: List()
println(l3) //输出: List()

添加:
**
val l1 = List(1, 2, 3)
//在list尾部添加
var result = l1 :+ 100
println(result) // 输出: List(1, 2, 3, 100)
//在list头部添加
var result3 = 200 +: l1
println(result3) // 输出: List(200, 1, 2, 3)
追加多个元素
val l1 = List(1, 2, 3)
var result3 = 200 :: 100 :: l1
println(result3) // List(200, 100, 1, 2, 3)

合并两个List元素:
**
val l1 = List(1, 2, 3)
val l2 = List(4, 5, 6)
// 合并方式1 ++
val result = l1 ++ l2
println(result) //List(1, 2, 3, 4, 5, 6)
// 合并方式2 :::
val result2 = l1 ::: l2
println(result2) //List(1, 2, 3, 4, 5, 6)

可变集合ListBuffer

说明
（1）创建一个可变集合ListBuffer
（2）向集合中添加数据
（3）打印集合数据

案例实操

import scala.collection.mutable.ListBuffer

object TestList {
  def main(args: Array[String]): Unit = {
    //（1）创建一个可变集合
    val buffer = ListBuffer(1, 2, 3, 4)
    //（2）向集合中添加数据
    buffer.+=(5)
    buffer.append(6)
    buffer.insert(1, 2)
    //（3）打印集合数据
    buffer.foreach(println)

    //（4）修改数据
    buffer(1) = 6
    buffer.update(1, 7)

    //（5）删除数据
    buffer.-(5)
    buffer.-=(5)
    buffer.remove(5)
  }
}

添加元素

    val buffer = ListBuffer(1, 2, 3)
    //在后面添加元素 +=
    buffer += 10
    println(buffer) //输出: ListBuffer(1, 2, 3, 10)
    // 在前面添加元素 +=:
    100 +=: buffer
    println(buffer) //输出: ListBuffer(100, 1, 2, 3, 10)

基本操作

//所有的集合都能用,这里就用List集合做演示
val list1 = List(30, 50, 70, 60, 10, 20)
// 1. 获取头部元素: 重点
println(list1.head) // 输出:30
// 2. 获取最后一个元素
println(list1.last) // 输出: 20
// 3. tail: 获取去掉第一个元素, 剩下的组成的集合
println(list1.tail) // 输出: List(50, 70, 60, 10, 20)
// 4. init: 去掉最后一个元素,剩下的组成的集合
println(list1.init) // 输出: List(30, 50, 70, 60, 10)
// 5. 长度
println(list1.size) // 输出: 6
println(list1.length) // 输出: 6
// 6. 转成横字符串
println(list1.toString()) // 输出:List(30, 50, 70, 60, 10, 20)
println(list1.mkString(“, “)) // 输出: 30, 50, 70, 60, 10, 20
//前缀”[“,中间分隔符 “,”,后面分隔符 “]”
println(list1.mkString(“[“, “,”, “]”)) // 输出: [30,50,70,60,10,20]
// 7 .迭代器
val iterator: Iterator[Int] = list1.iterator
// 7.1 遍历迭代器1,这种方式比较啰嗦
while (iterator.hasNext) {
val e: Int = iterator.next()
println(e)
}
// 7.2 遍历迭代器2,这种方式比较好
for (elem <- iterator) {
println(elem)
}
// 8. 是否包含
println(list1.contains(1))

基本操作2

val list1 = List(30, 50, 20, 60, 10, 20)<br />    // 1. 反转   1 to 100 reverse<br />    println(list1.reverse)<br />    // 2. 获取前几个<br />    val list2: List[Int] = list1.take(2) // 获取前两个<br />    println(list2)<br />    // 3. 抛弃前几个<br />    println(list1.drop(2))<br />    // 4. 获取满足条件的<br />    // 获取大于20 的,得到新的集合,从左往右遍历,只要遇到大于20的就停止了,返回之前遍历通过的值<br />    val list3: List[Int] = list1.takeWhile(x => x > 20)<br />    println(list3) //输出: List(30, 50)<br />    // 碰到大于20就丢弃<br />    val list7: List[Int] = list1.dropWhile(x => x > 20)<br />    println(list7) // 输出: List(20, 60, 10, 20)<br />    // 5. 取后n个<br />    val list5: List[Int] = list1.takeRight(2) //取后两个<br />    println(list5) // 输出: List(10, 20)

拉链操作

给两个集合拉在一起就是拉链操作

拉上操作

val list1 = List(30, 50, 70, 60, 10)
val list2 = List(3, 5, 7, 6, 1, 2)
// 1.两个集合组成一个,多余的会被抛弃
val list5: List[(Int, Int)] = list1.zip(list2)
println(list5) // 输出: List((30,3), (50,5), (70,7), (60,6), (10,1))
// 2. 多余会使用默认值来进行匹配,如果list1少的话,就用 -1 配对, 如果list2少的话就用 -2 配对
val list4: List[(Int, Int)] = list1.zipAll(list2, -1, -2)
println(list4) // 输出: List((30,3), (50,5), (70,7), (60,6), (10,1), (-1,2))
// 3. 和自己的索引进行zip
val list3: List[(Int, Int)] = list1.zipWithIndex
println(list3) //输出: List((30,0), (50,1), (70,2), (60,3), (10,4))

拉开操作

val list = Map("a" -> 1, "b" -> 2, "c" -> 3)<br />    // list中存储的是二维的元组的时候, 才能使用unzip<br />    val t = list.unzip<br />    println(t) // 输出: (List(a, b, c),List(1, 2, 3))

对集合里面元素的操作

val list1 = List(30, 50, 70, 60, 10, 20)<br />    //求和<br />    println(list1.sum) // 输出: 240<br />    //取最大值<br />    println(list1.max) // 输出: 70<br />    // 取最小值<br />    println(list1.min) // 输出 10<br />    // 求乘积,就是将集合里面所有的数值相乘<br />    println(list1.product) // 输出: 1260000000<br />    // 字符串也能乘数子<br />    println("abc" * 3) //输出:abcabcabc

Scala

02.集合通用操作