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

╰+攻爆jí腚メ 2022-05-19 11:35 325阅读 0赞

## 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遍历...

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