基本介绍

Scala中的List 和Java List不一样，在Java中List是一个接口，真正存放数据是ArrayList，而Scala的List可以直接存放数据,就是一个object,默认情况下Scala的List是不可变的，List属于序列Seq。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
val List = scala.collection.immutable.List
object List extends SeqFactory[List]

// 代码用例

object ListDemo {
  def main(args: Array[String]): Unit = {
    //    创建时直接赋值
    val list01 = List(1, 2, 3)
    //    打印集合
    println(list01)
    //  声明一个空的集合
    val list02 = Nil
    println(list02)
  }
}

list集合的访问

通过集合名加上 小括号(index)索引来进行访问

list集合中元素的追加

向列表中增加元素,会返回新的列表集合/集合对象。注意:Scala中List元素的追加形式非常独特,和Java不一样

在列表的最后面追加数据

1
2
3
4
5
6
7
8
9
10
var list03 = List("a", "b", "c")
    //    创建一个新的 集合,而我们**原本的集合不会改变**
    //    向前面追加
    val list03_new = list03 :+ "d"
    println(list03_new)
    println("===============")
    var list04 = List(1, 2, 3)
    //    向后面追加
    val list04_new = 0 +: list04
    println(list04_new)

:: 运算符号的使用

  1. :: 表示向集合中 新建集合添加元素
  2. 运算时,集合对象一点要放置在最右边
  3. 运算规则从右到左
  4. :::(三个冒号)运算符是将集合中的**每一个元素(不是直接把集合放进去)**加入到空集合中去
1
2
3
4
5
val list05 = 1 :: 2 :: 3 :: list03 :: Nil
  println(list05)
  val list06 = "a" :: "b" :: "c" :: list04 ::: Nil
  println("======--------=========")
  println(list06)

小结

  1. List默认为不可变的集合
  2. List在 scala包对象声明的,因此不需要引入其它包也可以使用
  3. val List = scala.collection.immutable.List
    List中可以放任何数据类型,比如 arr1的类型为List[Any]
  4. 如果希望得到一个空列表，可以使用Nil对象，在scala包对象声明的,因此不需要引入其它包也可以使用
    val Nil = scala.collection.immutable.Nil

ListBuffer

ListBuffer是个可变的list集合,可以添加删除元素,listbuffer属于序列

添加元素

1
2
3
4
5
6
7
//    追加元素
  //    2种方式  1. 使用 +=  2.使用 append
  var listbf02 = new ListBuffer[Int]
  listbf02 += 6
  listbf02.append(7)
  //    打印 listfb02里面的元素
  listbf02.foreach(f1)

将一个集合赋给另一个集合(使用 ++= 关键字)

1
2
3
//将 listbf02里面的元素赋给listbuffer
  listbuffer ++= listbf02
  println("listbuffer=" + listbuffer)

删除某一个元素

使用 集合.remove(下标)

整体代码

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
object ListBufferDemo {
  def main(args: Array[String]): Unit = {
    //    创建一个listBuffer
    val listbuffer = ListBuffer[Int](1, 2, 3)
    //    访问
    println("liastbuffer第一个值为=" + listbuffer(0))
    //    遍历
    listbuffer.foreach(f1)

    println("============")
    //    追加元素
    //    2种方式  1. 使用 +=  2.使用 append
    var listbf02 = new ListBuffer[Int]
    listbf02 += 6
    listbf02.append(7)
    //    打印 listfb02里面的元素
    listbf02.foreach(f1)
    println("=================")
    //将 listbf02里面的元素赋给listbuffer
    listbuffer ++= listbf02
    println("listbuffer=" + listbuffer)
    println("============")
    //    删除某个元素
    listbuffer.remove(4)
    // 删除后进行展示
    listbuffer.foreach(f1)
  }

  def f1(num: Int): Unit = {
    println(num)
  }

}

拓展-拉链(合并)

基本介绍

在开发中,当我们需要将两个集合进行对偶元素合并,可以使用拉链

注意事项

  1. 拉链的本质就是两个集合的合并操作，合并后每个元素是一个对偶元组

  2. 如果两个集合个数不对应，会造成数据丢失

  3. 集合不限于List，也可以是其它集合比如Array

  4. 如果要取出合并后的各个对偶元组的数据,可以遍历

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    object ZipDemo {
      def main(args: Array[String]): Unit = {
        val list = List(1, 2, 3)
        val list02 = List(4, 5, 6)
        val list03 = list.zip(list02)

        for (item <- list03) {
          println(item._1, item._2)
        }
      }
    }