Scala語言入門三（集合）

一、數(shù)組

Scala 語言中提供的數(shù)組是用來存儲固定大小的同類型元素，數(shù)組對于每一門編輯應語言來說都是重要的數(shù)據(jù)結構之一。數(shù)組的第一個元素索引為0，最后一個元素的索引為元素總數(shù)減1

1、聲明數(shù)組

  • 不可變數(shù)組
/**
 * @author Gjing
 **/
object ArrayApp {

  def main(args: Array[String]): Unit = {
    // 聲明一個長度為2的不可變數(shù)組
    val arr = new Array[String](2)
    // 賦值
    arr(0) = "java"
    arr(1) = "scala"

    // 使用另外一種方式聲明數(shù)組
    val arr2 = Array("java","scala")
  }
}
  • 不可變數(shù)組
/**
 * @author Gjing
 **/
object ArrayApp {

  def main(args: Array[String]): Unit = {
    val buffer = ArrayBuffer[String]()
    // 追加一個值
    buffer += "java"
    // 追加一個數(shù)組
    buffer ++= Array("scala", "vue")
  }
}

2、數(shù)組的處理

列出常見的一些操作，其余的自行查閱文檔

  • 循環(huán)輸出
/**
 * @author Gjing
 **/
object ArrayApp {

  def main(args: Array[String]): Unit = {
    val arr = Array("java", "scala")
    for (x <- arr) {
      println(x)
    }
  }
}
  • 合并數(shù)組
/**
 * @author Gjing
 **/
object ArrayApp {

  def main(args: Array[String]): Unit = {
    val arr = Array("java", "scala")
    val arr2 = Array("vue", "go")
    // 這種方式需要引入 import Array._
    val arr3 = concat(arr, arr2)
    // 直接調用
    val arr4 = arr.concat(arr2)
  }
}

二、List

List的特征是其元素以線性方式存儲，集合中可以存放重復對象。

1、創(chuàng)建List

  • 定長list
/**
 * @author Gjing
 **/
object ListApp {

  def main(args: Array[String]): Unit = {
    // 數(shù)字列表
    var l1 = List(1, 2, 3, 4)
    var l2 = 1 :: 2 :: 3 :: Nil
    // 生成空列表
    var l3 = Nil
  }
}

構造列表的兩個基本單位是 Nil 和 ::

Nil 也可以表示為一個空列表。

  • 不定長
/**
 * @author Gjing
 **/
object ListApp {

  def main(args: Array[String]): Unit = {
    val l = ListBuffer[Int]()
    // 加一個元素
    l += 2
    // 加入多個元素
    l += (3,4)
    // 加入一個集合
    l ++= List(5,6)
    // 打印 2,3,4,5,6
    println(l.mkString(","))
  }
}

2、列表的操作

  • 基本操作(返回第一個元素、返回第一個元素以外的列表、判斷列表是否為空)
/**
 * @author Gjing
 **/
object ListApp {

  def main(args: Array[String]): Unit = {
    var l = List(1,2,3)
    // 打印 1
    println(l.head)
    // 打印 List(2,3)
    println(l.tail)
    // 打印false
    println(l.isEmpty)
  }
}
  • 拼接
/**
 * @author Gjing
 **/
object ListApp {

  def main(args: Array[String]): Unit = {
    val l1 = List(1, 2, 3)
    val l2 = List(3,4)
    val l3 = l1 ::: l2
    // 較第一種是后者加進去后再列表前面
    val l4 = l1.:::(l2)
    val l5 = List.concat(l1,l2)
    println(l3.mkString(","))
    println(l4.mkString(","))
    println(l5.mkString(","))
  }
}
  • 列表反轉
/**
 * @author Gjing
 **/
object ListApp {

  def main(args: Array[String]): Unit = {
    val l1 = List(1, 2, 3)
    // 打印 3，2，1
    println(l1.reverse.mkString(","))
  }
}
  • 創(chuàng)建一個指定重復數(shù)量的元素列表
/**
 * @author Gjing
 **/
object ListApp {

  def main(args: Array[String]): Unit = {
    val l1 = List.fill(2)(1)
    // 打印 1，1
    println(l1.mkString(","))
  }
}

三、Set

Set是最簡單的一種集合。集合中的對象不按特定的方式排序，并且沒有重復對象, 用法和list差不多，這里不過多介紹

四、Map

Map 是一種把鍵對象和值對象映射的集合，它的每一個元素都包含一對鍵對象和值對象。Map 有兩種類型，可變與不可變，區(qū)別在于可變對象可以修改它，而不可變對象不可以。默認情況下 Scala 使用不可變 Map。如果你需要使用可變集合，你需要顯式的引入
import scala.collection.mutable.Map 類在 Scala 中 你可以同時使用可變與不可變 Map，不可變的直接使用 Map，可變的使用 mutable.Map

1、創(chuàng)建Map

/**
 * @author Gjing
 **/
object MapApp {
  def main(args: Array[String]): Unit = {
    // 空map
    val m1 = Map()
    // 存在鍵值對
    var m2 = Map("名字" -> "張三", "年齡" -> 12)
    println(m2.mkString(","))
    // 加一個新的鍵值對進去
    m2 += ("性別" -> "男")
    println(m2.mkString(","))
  }
}

2、基本操作

/**
 * @author Gjing
 **/
object MapApp {
  def main(args: Array[String]): Unit = {
    var m2 = Map("名字" -> "張三", "年齡" -> 12)
    // 返回所有key
    println(m2.keys)
    // 返回所有value
    println(m2.values)
    // 判斷是否為空
    println(m2.isEmpty)
  }
}

3、合并

你可以使用 ++ 運算符或 Map.++() 方法來連接兩個 Map，Map 合并時會移除重復的 key

/**
 * @author Gjing
 **/
object MapApp {
  def main(args: Array[String]): Unit = {
    val map1 = Map("年齡" -> "12")
    val map2 = Map("性別" -> "男")
    println(map1 ++ map2)
    println(map1.++(map2))
  }
}

4、查看 Map 中是否存在指定的 Key

object MapApp {
  def main(args: Array[String]): Unit = {
    var m1 = Map("名字" -> "張三", "年齡" -> 12)
    // 打印 true
    println(m1.contains("名字"))
  }
}

四、元組

元組是不同類型的值的集合，與列表一樣，元組也是不可變的，但與列表不同的是元組可以包含不同類型的元素

1、定義元組

/**
 * @author Gjing
 **/
object TupleApp {
  def main(args: Array[String]): Unit = {
    val t1 = (1, "呢", 1.1)
    val t2 = new Tuple3(1, "呢", 1.1)
  }
}

元組的實際類型取決于它的元素的類型，比如 (99, "runoob") 是 Tuple2[Int, String], 目前 Scala 支持的元組最大長度為 22。對于更大長度你可以使用集合，或者擴展元組

2、訪問元組

/**
 * @author Gjing
 **/
object TupleApp {
  def main(args: Array[String]): Unit = {
    val t1 = (1, "呢", 1.1)
    // 獲取元組第一個內容
    println(t1._1)
    // 獲取元組第二個內容
    println(t1._2)
  }
}

3、元組的迭代

/**
 * @author Gjing
 **/
object TupleApp {
  def main(args: Array[String]): Unit = {
    val t1 = (1, "呢", 1.1)
    t1.productIterator.foreach(e => println(e))
  }
}

4、元組轉字符串

/**
 * @author Gjing
 **/
object TupleApp {
  def main(args: Array[String]): Unit = {
    val t1 = (1, "呢", 1.1)
    println(t1.toString())
  }
}
?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

友情鏈接更多精彩內容