[Scala] Scala 学习笔记 (3) - 集合（待补充）

Scala集合

集合要掌握的基本内容：

集合创建
集合赋值
集合取值

1. Array 数组

定长数组：Array

    // 数组定义
    val a = new Array[String](5)

    // 数组定义并赋值
    val a1 = Array("aaa","bbb","ccc") // 这种定义方法必然是调用了object中的apply方法，在apply中new了一个class

    // 数组取值
    println(a1.length)
    println(a1(0))      // 下标从0开始

    // 修改数组里面的元素
    a1(2) = "ddd"
    println(a1(2))

注意：val定义的变量被引用时不能被改变，但是不引用的时候变量里面的内容是可以被改变的。

变长数组（可变数组）：ArrayBuffer

    // 导入包
    import scala.collection.mutable.ArrayBuffer

    //定义一个变长的数组，长度为空
    val c = ArrayBuffer[Int]()

    // 向变长数组里面添加一个元素
    c += 1
    println(c)

    // 添加多个元素
    c += (2,3,4)
    println(c)

    // append方法也可以一次添加多个元素
    c.append(9,9,8)
    println(c)

    // 添加定长数组。变长+定长使用++=
    c ++= Array(7,8,9,10,11,12,13,14,15,16)
    println(c)

    // 上面的方法都是向右加
    // 下面的方法插入到指定的地方(从第0个位置开始，添加一个0)
    c.insert(0,0)
    println(c)

    // 从集合中减去一个元素，当该元素有多个时，减去左边开始第一个
    c -= 9
    println(c)
   
    // 删除指定位置的一个元素(下标从0开始）
    c.remove(1)
    println(c)

    // 删除指定位置的多个元素（从0开始删掉3个值）
    c.remove(0,3)
    println(c)

    // 删除最后的n个元素
    c.trimEnd(2)
    println(c)

++= 也可以是追加两个类型一样的元素

Array集合运算

不论是Array还是ArrayBuffer，都有如下运算方法

    // 运算方法，Array和ArrayBuffer都有
    println(c.max)
    println(c.min)
    println(c.sum)
    println(c.length)

    // 变长数组转成定长数组（ArrayBuffer转换成定长的Array）
    val c1 = c.toArray
    println(c1)

    // 数组里面所有的元组拼接成一个长字符串
    println(a2.mkString)
    // 数组里面所有的元组拼接成一个长字符串，用，作为分隔符
    println(a2.mkString(","))
    /**
      * 第一个参数：拼接字符串左边的值
      * 第二个参数：分隔符
      * 第三个参数：拼接字符串右边的值
      */
    // 数组里面所有的元组拼接成一个长字符串，用，作为分隔符。并且在前后加上[]
    println(a2.mkString("[",",","]"))

Array遍历

    for (i <- 0 until(c.length)) {
      println(i)
    }

    // 增强for循环
    for (ele <- c) {
      println(ele)
    }

ArrayBuffer转成Array

    val c1 = c.toArray
    println(c1)

2. List 列表

概念：

Nil：一个空的List
head：List里面第一个元素
tail：List里面除head以外其他元素的列表

定长列表：List

    // 创建一个空List
    val l = Nil
    val l1 = List()

    // 创建一个List
    val l2 = List(1,2,3,4,5)

    // 返回List的第一个元素
    println(l2.head)

    // 返回的是去掉head之外的List
    println(l2.tail)

    // 头 :: 尾 = 头 + 尾
    val l3 = 1 :: Nil

    // 2开头，集合l3结尾
    val l4 = 2 :: l3

    // 1，2，3
    val l5 = 1 :: 2 :: 3 :: Nil

变长列表：ListBuffer

    // 导入包
    import scala.collection.mutable.ListBuffer

    // 定义一个空的ListBuffer
    val l6 = ListBuffer[Int]()

    // 向List添加元素
    l6 += 2
    l6 += (3,4,5,6,7,8,9)

    // 从List中减去元素
    l6 -= 3

    // 减去一个List当中没有的元素1，不会报错
    l6 -= (1,4)

    // 可变List +/- List用++=/--=
    l6 ++= l5

    l6 --= List(1,2,3)

    // head
    println(l5.head)
    println(l5.tail)
    println(l5.tail.tail)

变长ListBuffer转成定长List

    // ListBuffer转换成定长的List
    println(l6.toList)

3. Set 集合

Set和List的区别：

Set：无序，不重复
List：有序，可重复

4. Map

定长：Map（Map底层的数据结构是HashMap实现的）

// 定义一个Map
  val a = Map("k1" -> "v1", "k2" -> "v2" )
  println(a)

  // 取Map中一个key的value
  println(a("k1"))

  // 不可变Map里面的值不能被改变
  // a("k1") = "v3"

变长：HashMap

  // 定义一个HashMap
  val c = HashMap[String, Int]()

  // 向HashMap添加数据
  c("k1") = 1
  c("k2") = 2
  c += ("k3" -> 3)
  c += ("k4" -> 4, "k5" -> 5, "k6" -> 6)

  c += ("k3" -> 3)

  // 可以修改
  c("k1") = 3
  println(c)

Map遍历

  // 不能取不在Map里面的key，报错
  // println(c("k3"))
  // 工作中正确的做法是用get方法取value对应的值。取不到就取默认值，不会报错
  println(c.get("k1"))
  println(c.getOrElse("k1", -9999))

  // 遍历Map
  for ((k,v) <- c) {
    println(k + " : " + v)
  }
  // 也可以用占位符
  for ((k,_) <- c) {
    println(k + " : " + c.getOrElse(k, -9999))
  }

  // 遍历Map里面的keys
  for (ele <- c.keySet) {
    println(ele + " : " + c(ele))
  }

  // 遍历Map里面的values
  for (ele <- c.values) {
    println(ele)
  }

  for ((k,_) <- c) {
    println(k + " : " + c.getOrElse(k, 9999))
  }

5. Tuple 元组

  // 定义一个tuple
  val a = (1,2,3,4,5)
  println(a._1 + " " + a._2)

  val ipPort = "192.168.1.7:3306"
  val ip = ipPort.split(":")(0)
  val port = ipPort.split(":")(1)
  println(ip)
  println(port)

TO BE UPDATE LATER ON...

总结：

Scala集合类型的共同点：

都支持max/min/sum/length运算
都支持循环遍历，但是遍历方法不一样

List遍历

Map遍历...

都可以把变长转成定长
...

[Scala] Scala 学习笔记 (3) - 集合 （待补充）