0.Scala数据结构关系图

scala数据结构关系图.jpg

Scala中的集合类可以分为三大类：

• Seq，是一组有序的元素。
• Set，是一组没有重复元素的集合。
• Map，是一组k-v对。

1.List-有序的对象集合

1.1定义

Scala 列表类似于数组，它们所有元素的类型都相同，但是列表是不可变的，值一旦被定义了就不能改变。
Nil代表空List。
列表的元素类型 T 可以写成 List[T]。
例如，以下列出了多种类型的列表：

// 字符串列表
val site: List[String] = List("FangDD", "Google", "Baidu")
// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)
// 空列表
val empty: List[Nothing] = List()
// 二维列表
val dim: List[List[Int]] =
    List(
        List(1, 0, 0),
        List(0, 1, 0),
        List(0, 0, 1)
   )

1.2常用操作

• 创建List

//------------------创建List------------------
val feeds1 = List("blog.toolshed.com", "pragdave.me", "blog.agiledeveloper.com")
val feeds2 = "blog.toolshed.com"::("pragdave.me"::( "blog.agiledeveloper.com"::Nil))
val feeds3 = Nil
print("feeds1:")
feeds1.foreach(x=>print(x+" "))
println("")
print("feeds2:")
feeds2.foreach(x=>print(x+" "))

• 元素操作
  head 返回列表第一个元素。
  tail 返回一个列表，包含除了第一元素之外的其他元素。
  isEmpty 在列表为空时返回true。
  ListName(index)可取列表的指定元素，实际调用的是ListName的apply方法。

//------------------元素操作------------------
val site = "FangDD" :: ("Google" :: ("Baidu" :: Nil))
val nums = Nil
println( "第一元素 : " + site.head )
println( "第一元素 : " + site(0) )
println( "另外一种方式取第一元素 : " + site.apply(0) )
println( "尾部元素 : " + site.tail )
println( "查看列表 site 是否为空 : " + site.isEmpty )
println( "查看 nums 是否为空 : " + nums.isEmpty )

• List操作
  ::: 运算符、 List.:::() 方法、 List.concat() 方法 来连接两个或多个列表。
  List常用for循环遍历、foreach循环遍历。

//------------------List连接------------------
val list1 = "FangDD" :: ("Google" :: ("Baidu" :: Nil))
val list2 = "Facebook" :: ("Taobao" :: Nil)
// 使用 ::: 运算符
var myList = list1 ::: list2
println( "list1 ::: list2 : " + myList )
// 使用 List.:::() 方法
myList = list1.:::(list2)
println( "list1.:::(list2) : " + myList )
// 使用 concat 方法
myList = List.concat(list1, list2)
println( "List.concat(list1, list2) : " + myList  )
//------------------List遍历------------------
val list4 = "FangDD" :: ("Google" :: ("Baidu" :: Nil))
print("\nfor循环:")
for(e <- list4)print(e+" ")
print("\nforeach循环:")
list4.foreach(e => print(e+" "))

1.3其他操作

def +:(elem: A): List[A]
为列表预添加元素
def ::(x: A): List[A]
在列表开头添加元素
def :::(prefix: List[A]): List[A]
在列表开头添加指定列表的元素
def :+(elem: A): List[A]
复制添加元素后列表。
def addString(b: StringBuilder): StringBuilder
将列表的所有元素添加到 StringBuilder
def addString(b: StringBuilder, sep: String): StringBuilder
将列表的所有元素添加到 StringBuilder，并指定分隔符
def apply(n: Int): A
通过列表索引获取元素
def contains(elem: Any): Boolean
检测列表中是否包含指定的元素
def distinct: List[A]
去除列表的重复元素，并返回新列表
def drop(n: Int): List[A]
丢弃前n个元素，并返回新列表
......

2.Set-无序的集合

2.1定义

Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。
Scala 集合分为可变的和不可变的集合，分别在scala.collection.mutable.Set 包和scala.collection.immutable.Set包下面，默认引用 scala.collection.immutable.Set。

2.2常用操作

• 创建Set

//------------------创建Set------------------
val set = Set(1,2,3)
println(set.getClass.getName)   // scala.collection.immutable.HashSet
import scala.collection.mutable.Set // 可以在任何地方引入 可变集合
val mutableSet = Set(1,2,3)
println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet
mutableSet.add(4)
mutableSet.remove(1)
mutableSet += 5
mutableSet -= 2
println(mutableSet) // Set(5, 3, 4)
val another = mutableSet.toSet
println(another.getClass.getName) // scala.collection.immutable.Set

• 元素操作
  head 返回集合第一个元素。
  tail 返回一个集合，包含除了第一元素之外的其他元素。
  isEmpty 在集合为空时返回true。

//------------------元素操作------------------
val site = Set("FangDD", "Google", "Baidu")
val nums: Set[Int] = Set()
println( "第一元素是 : " + site.head )
println( "尾部元素 : " + site.tail )
println( "查看列表 site 是否为空 : " + site.isEmpty )
println( "查看 nums 是否为空 : " + nums.isEmpty )

• Set操作
  ++ 运算符、 Set.++() 方法来连接两个集合，如果元素有重复的就会移除重复的元素。
  Set遍历，for循环遍历、foreach循环遍历。

//------------------Set连接------------------
val site1 = Set("FangDD", "Google", "Baidu")
val site2 = Set("Faceboook", "Taobao")
// ++ 作为运算符使用
var site3 = site1 ++ site2
println( "site1 ++ site2 : " + site3 )
//  ++ 作为方法使用
site3 = site1.++(site2)
println( "site1.++(site2) : " + site3 )
//------------------Set遍历------------------
val site4 = Set("FangDD", "Google", "Baidu")
print("\nforeach循环:")
site4.foreach(e => print(e+" "))
print("\nfor循环:")
for(e <- site4)print(e+" ")

2.3其他操作

def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在 
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合  
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
def &(that: Set[A]): Set[A]
返回两个集合的交集   
def &~(that: Set[A]): Set[A]
返回两个集合的差集
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合    
def ++(elems: A): Set[A]
合并两个集合
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合    
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
def apply(elem: A)
检测集合中是否包含指定元素
......

3.Map-键值对字典

3.1定义

Map(映射)是一种可迭代的键值对（key/value）结构，其中键都是唯一的。
Map 有可变与不可变两种类型，分别在scala.collection.mutable.Map包和scala.collection.immutable.Map包下面，默认引用scala.collection.immutable.Map包。

3.2常用操作

• 创建Map

//------------------创建Map------------------
var A1:Map[Char,Int] = Map()
println(A1.getClass.getName)   //scala.collection.immutable.Map$EmptyMap$
    import scala.collection.mutable.Map
val A2 = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
println(A2.getClass.getName)   //scala.collection.mutable.HashMap

• 元素操作
  keys ,返回 Map 所有的键(key)。
  values,返回 Map 所有的值(value)。
  isEmpty,判断 Map 是否为空。

//------------------元素操作------------------
val map = Map("red" -> "#FF0000",
      "azure" -> "#F0FFFF",
      "peru" -> "#CD853F")
val nums: Map[Int, Int] = Map()
println( "map 中的键为 : " + map.keys )
println( "map 中的值为 : " + map.values )
println( "检测 map 是否为空 : " + map.isEmpty )
println( "检测 nums 是否为空 : " + nums.isEmpty )

• Map操作
  ++ 运算符、 Map.++() 方法来连接两个 Map，Map 合并时会移除重复的 key。
  Map常用key值遍历、foreach遍历。

//------------------Map连接------------------
 val map1 = Map("red" -> "#FF0000",
      "azure" -> "#F0FFFF",
      "peru" -> "#CD853F")
val map2 = Map("blue" -> "#0033FF",
      "yellow" -> "#FFFF00",
      "red" -> "#FF0000")
//  ++ 作为运算符
var map3 = map1 ++ map2
println( "map1 ++ map2 : " + map3 )
//  ++ 作为方法
map3 = map1.++(map2)
println( "map1.++(map2) : " + map3 )
//------------------Map遍历------------------
val map4 = Map("red" -> "#FF0000",
      "azure" -> "#F0FFFF",
      "peru" -> "#CD853F")
println("\nkey循环:")
map4.keys.foreach(key => {
      val v = map4(key)
      val kv = s"key: $key,  value: $v"
      println(kv)
    })
println("\nforeach循环:")
map4.foreach(println)

3.3其他操作

def ++(xs: Map[(A, B)]): Map[A, B]
返回一个新的 Map，新的 Map xs 组成 
def -(elem1: A, elem2: A, elems: A*): Map[A, B]
返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems。    
def --(xs: GTO[A]): Map[A, B]
返回一个新的 Map, 移除 xs 对象中对应的 key    
def get(key: A): Option[B]
返回指定 key 的值
def iterator: Iterator[(A, B)]
创建新的迭代器，并输出 key/value 对 
def addString(b: StringBuilder): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符 
def addString(b: StringBuilder, sep: String): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符 
def apply(key: A): B
返回指定键的值，如果不存在返回 Map 的默认方法   
def clear(): Unit
清空 Map
def clone(): Map[A, B]
从一个 Map 复制到另一个 Map
def contains(key: A): Boolean
如果 Map 中存在指定 key，返回 true，否则返回 false。
......

4.元组Tuple

4.1定义

与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。
元组的值是通过将单个的值包含在圆括号()中构成的，目前Scala 支持的元组最大长度为 22。

4.2常用操作

• 创建Tuple

    //------------------创建Tuple------------------
    println("\n------------------创建Tuple------------------")
    val t1 = (1, 3.14, "Fred")
    val t2 = new Tuple3(1, 3.14, "Fred")
    val funTuple = createTuple
    println("funTuple:"+funTuple._1+":"+funTuple._2+":"+funTuple._3)

• 元素操作

    //------------------元素操作------------------
    println("\n------------------元素操作------------------")
    val t3 = (4,3,2,1)
    val sum = t3._1 + t3._2 + t3._3 + t3._4
    println( "元素之和为: "  + sum )
    val t4 = new Tuple3(1, "hello", "FANGDD")
    println("连接后的字符串为: " + t4.toString() )

• Tuple操作

    //------------------Tuple连接------------------
    println("\n------------------Tuple连接------------------")
    val t5 = (4,3,2,"6")
    val t6 = (7,8,9,"10")
    //待定
    //------------------Tuple遍历------------------
    println("\n------------------Tuple遍历------------------")
    val t8 = (4,3,2,1,"FANGDD")
    t8.productIterator.foreach{ i =>println("Value = " + i )}

5.Array

5.1定义

Scala中的数组是用来存储固定大小的同类型元素，数组中某个指定的元素是通过索引来访问的，数组的第一个元素索引为0，最后一个元素的索引为元素总数减1。

5.2常用操作

• 创建Array

    //------------------创建Array------------------
    println("\n------------------创建Array------------------")
    //创建类型为String长度为3的数组
    val arr2 = Array[String]("s100","s200","s300")
    // 创建类型为Int 长度为3的数组
    val arr1 = new Array[Int](3)

• 元素操作

    //------------------元素操作------------------
    println("\n------------------元素操作------------------")
    val arr4 = new Array[Int](3)
    // 赋值
    arr4(0) = 100
    arr4(1) = 200
    arr4(2) = 300

• Array操作

    //------------------Array遍历------------------
    println("\n------------------Iterator遍历------------------")
    // 遍历两种方式
    val arr3 = Array[String]("s100","s200","s300")
    for(i <- arr3){
      print(i+" ")
    }
    println("")
    arr3.foreach(i => {
      print(i+" ")
    })

文本资源来自于互联网和书本整理，仅供学习，有侵权联系删除。