scala开发快速入门 | 第四篇 数据结构

一、集（Set）

Scala中的集合分为可变的集合、不可变的集合。Set中的数据是无序的，不重复的。

默认情况下，Scala使用的是不可变的集合，默认引用的是 scala.collection.immutable.Set。

                    如果你想使用可变的集合，需要引用 scala.collection.mutable.Set 包。

区别：

1）可变集合可以修改，添加，移除一个集合的元素；原集合会发生变化。

2）而不可变集合类，相比之下，永远不会改变。仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。

 

object Operator_Set {
  def main(args: Array[String]): Unit = {
    /*不可变集合操作*/
    val set=Set(1,2,3);
    println(set.getClass.getName)//scala.collection.immutable.Set$Set3 默认是不可变的集合
    println(set.exists(_ % 2 == 0)) //true
    println(set.drop(1)) //Set(2,3)
    println(set) //Set(1,2,3)
    /*可变集合*/
    import scala.collection.mutable.Set // 可以在任何地方引入 可变集合
    val mutableSet = Set(1,2,3)
    println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet
    mutableSet.add(4)
    println(mutableSet) // Set(1, 2, 3, 4)
    mutableSet.remove(1)
    println(mutableSet) // Set(2, 3, 4)
  }
}

集合基本操作

Scala集合有三个基本操作：

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

val setOperator=Set("google","baidu","netcloud")
val setContainsInt:Set[Int]=Set()
println(setOperator.head)//google
println(setOperator.tail)//Set(netcloud, baidu)
println(setOperator.isEmpty)//false
println(setContainsInt.isEmpty)//true

集合的连接

可以使用++运算符和Set中的 .++() 方法来连接两个集合，如果两个集合中存在重复的元素就会移除。

val site1 = Set("Runoob", "Google", "Baidu","kugou")

val site2 = Set("Faceboook", "Taobao","kugou")
// ++ 作为运算符使用
var site = site1 ++ site2
println( "site1 ++ site2 : " + site )
//  ++ 作为方法使用
site = site1.++(site2)
println( "site1.++(site2) : " + site )

site1 ++ site2 : Set(Google, Faceboook, Runoob, Baidu, Taobao, kugou)
site1.++(site2) : Set(Google, Faceboook, Runoob, Baidu, Taobao, kugou)
查找集合中最大最小值

val num=Set(1,2,3,4,5)
println(num.max)//5
println(num.min)//1

交集

可以使用 Set.& 方法或 Set.intersect 方法来查看两个集合的交集元素

val num1=Set(1,2,3,4,5)
val num2=Set(4,5,6,7,8)
println(num1.&(num2))
// 交集
println( "num1.&(num2) : " + num1.&(num2) ) //num1.&(num2) : Set(5, 4)
println( "num1.intersect(num2) : " + num1.intersect(num2) ) //num1.intersect(num2) : Set(5, 4)

遍历集合

val iterator=Set("Spark","Scala","Hive","Impala")
for(i <- iterator){
  println(i)
}

Scala集合Set中常用的方法

下表列出了 Scala Set 常用的方法：

序号	方法及描述
1	def +(elem: A): Set[A] 为集合添加新元素，x并创建一个新的集合，除非元素已存在
2	def -(elem: A): Set[A] 移除集合中的元素，并创建一个新的集合
3	def contains(elem: A): Boolean 如果元素在集合中存在，返回 true，否则返回 false。
4	def &(that: Set[A]): Set[A] 返回两个集合的交集
5	def &~(that: Set[A]): Set[A] 返回两个集合的差集
6	def +(elem1: A, elem2: A, elems: A*): Set[A] 通过添加传入指定集合的元素创建一个新的不可变集合
7	def ++(elems: A): Set[A] 合并两个集合
8	def -(elem1: A, elem2: A, elems: A*): Set[A] 通过移除传入指定集合的元素创建一个新的不可变集合
9	def addString(b: StringBuilder): StringBuilder 将不可变集合的所有元素添加到字符串缓冲区
10	def addString(b: StringBuilder, sep: String): StringBuilder 将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11	def apply(elem: A) 检测集合中是否包含指定元素
12	def count(p: (A) => Boolean): Int 计算满足指定条件的集合元素个数
13	def copyToArray(xs: Array[A], start: Int, len: Int): Unit 复制不可变集合元素到数组
14	def diff(that: Set[A]): Set[A] 比较两个集合的差集
15	def drop(n: Int): Set[A]] 返回丢弃前n个元素新集合
16	def dropRight(n: Int): Set[A] 返回丢弃最后n个元素新集合
17	def dropWhile(p: (A) => Boolean): Set[A] 从左向右丢弃元素，直到条件p不成立
18	def equals(that: Any): Boolean equals 方法可用于任意序列。用于比较系列是否相等。
19	def exists(p: (A) => Boolean): Boolean 判断不可变集合中指定条件的元素是否存在。
20	def filter(p: (A) => Boolean): Set[A] 输出符合指定条件的所有不可变集合元素。
21	def find(p: (A) => Boolean): Option[A] 查找不可变集合中满足指定条件的第一个元素
22	def forall(p: (A) => Boolean): Boolean 查找不可变集合中满足指定条件的所有元素
23	def foreach(f: (A) => Unit): Unit 将函数应用到不可变集合的所有元素
24	def head: A 获取不可变集合的第一个元素
25	def init: Set[A] 返回所有元素，除了最后一个
26	def intersect(that: Set[A]): Set[A] 计算两个集合的交集
27	def isEmpty: Boolean 判断集合是否为空
28	def iterator: Iterator[A] 创建一个新的迭代器来迭代元素
29	def last: A 返回最后一个元素
30	def map[B](f: (A) => B): immutable.Set[B] 通过给定的方法将所有元素重新计算
31	def max: A 查找最大元素
32	def min: A 查找最小元素
33	def mkString: String 集合所有元素作为字符串显示
34	def mkString(sep: String): String 使用分隔符将集合所有元素作为字符串显示
35	def product: A 返回不可变集合中数字元素的积。
36	def size: Int 返回不可变集合元素的数量
37	def splitAt(n: Int): (Set[A], Set[A]) 把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38	def subsetOf(that: Set[A]): Boolean 如果集合中含有子集返回 true，否则返回false
39	def sum: A 返回不可变集合中所有数字元素之和
40	def tail: Set[A] 返回一个不可变集合中除了第一元素之外的其他元素
41	def take(n: Int): Set[A] 返回前 n 个元素
42	def takeRight(n: Int):Set[A] 返回后 n 个元素
43	def toArray: Array[A] 将集合转换为数组
44	def toBuffer[B >: A]: Buffer[B] 返回缓冲区，包含了不可变集合的所有元素
45	def toList: List[A] 返回 List，包含了不可变集合的所有元素
46	def toMap[T, U]: Map[T, U] 返回 Map，包含了不可变集合的所有元素
47	def toSeq: Seq[A] 返回 Seq，包含了不可变集合的所有元素
48	def toString(): String 返回一个字符串，以对象来表示

二、数组（Array）

Scala中的数组分为定长的数组和变长的数组；定长的数组在数组定义的时候长度需要被确定，在运行的时候数组的长度不会发生改变，而变长的数组内存存储长度会随着程序运行的需要而动态的扩容。

1）定长数组

定长数组定义的方式有两种，一种是new Array[T](length)方式‘另一种是无new操作’ 即：Array(element)

 

def main(args: Array[String]): Unit = {
  //定义一个长度10的数值数组
  val numberArray=new Array[Int](10)//numberArray: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  //定义一个长度为10的String类型的数组
  val stringArray=new Array[String](10)//stringArray: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)
 /*数组元素赋值*/
  numberArray(0)=666  // res1: Array[Int] = Array(666, 0, 0, 0, 0, 0, 0, 0, 0, 0)
  stringArray(1)="Scala" // res3: Array[String] = Array(null, Scala, null, null, null, null, null, null, null, null)
  /*无new操作的方式 定义数组 需要给数组进行赋值*/
  val stringArray2=Array("Scala","Spark","Hive")

2)变长的数组 ArrayBuffer

变长数组在程序的运行过程中，其数组的长度可以随着程序的运行的需要而增加。最常用的变长数组为ArrayBuffer，它在scala.collection.mutable中被使用的时候需要显式的引入。

String类型的变长数组的定义和操作

 

import scala.collection.mutable.ArrayBuffer
/*变长数组定义*/
//创建String类型的变长数组
val ab=ArrayBuffer[String]()
// += 表示在尾部追加一个数组元素
ab+="hello"
// += 后面还可以在尾部追加多个数据元素
ab+=("Spark","hive","Scala")
//++= 在尾部追加数组
ab++=Array("Kafka","Impala","Hadoop")
//++= 在尾部追加List
ab++=List("Flume","MapReducer","Storm")
//删除末尾2数据元素
 ab.trimEnd(2)
//在指定的索引位置插入数据元素
ab.insert(0,"Test")
//删除指定索引位置的元素
ab.remove(0)
//删除指定索引位置的元素以及后面多个数据元素
ab.remove(0,2)
/*将变长的数组和定长数组相互转换*/
//变长的数组转为定长的数组
ab.toArray
//将定长的数组转为变长的数组
numberArray.toBuffer

Int类型的变长数组的定义和操作

 

/*Int类型的变长数组的定义和操作*/
var intArrayVar=ArrayBuffer(1,2,3)
//在数组索引0号位置插入数据元素4
intArrayVar.insert(0,4)
//在数组索引0号位置插入元素5，6,7
intArrayVar.insert(0,5,6,7)
//从索引0开始，删除4个元素
intArrayVar.remove(0,4)

定长数组与变长数组的相互转换

 

//变长的数组转为定长的数组
ab.toArray
//将定长的数组转为变长的数组
numberArray.toBuffer

3）数组的遍历

数组遍历的方式：一种是通过索引的方式遍历；另一种是直接遍历数组的方式（实际开发中，推荐使用）。

 

/*遍历数组的两种方式*/
//1、通过索引的方式遍历
for(i<- 0 to ab.length-1){
  println("Array Element: "+ab(i))
}
for(i<- 0 until ab.length){
  println("Array Element: "+ab(i))
}
//2、通过直接数组遍历  实际开发中推荐使用
for(i<- ab){
  println("Array Element: "+i)
}

4）遍历数组生成新的数组

 

 /*无论是定长的数组还是变长的数组，在遍历的时候都可以生产新的数组，生成新的数组时，原来的数组内容保持不变*/
//定长数组遍历生成后的数组仍然是定长数组，原数组不变
 val numArrayVar=Array(1,2,3,4)
 var newArrayVar=for(i<- numArrayVar) yield i*2//Array(2, 4, 6, 8)
 //加入过滤条件
 var newArrayVar2=for(i<- numArrayVar if i>2) yield i*2//Array(6, 8)

5）数组的常用方法

 

/* 常用方法*/
//求最小值
numArrayVar.min
//求最大值
numArrayVar.max
//求和
numArrayVar.sum
//toString()方法
numArrayVar.toString
//mkString()
numArrayVar.mkString(",")//res30: String = 1,2,3,4

6）多维数组

定义一个二行三列的数组

 

//定义一个二行三列的数组
var multiDimArr=Array(Array(1,2,3),Array(4,5,6))
//获取第一行，第二列的数组元素 通过索引的方式获取数据元素
println(multiDimArr(0)(2))
//通过for循环遍历数组
for(i<- multiDimArr){
  println("multiDimArr's elemennts :"+i.mkString(","))
}
//multiDimArr's elemennts :1,2,3
//multiDimArr's elemennts :4,5,6
/*通过双重for循环遍历数组*/
for(i<- multiDimArr)
  for(j<- i){
    println(j)
  }

三、列表(List)

1)创建列表常用的两种方式

 //    字符串类型List
var  listStr1=List("Spark","Hive","Flink")
 //    等同于上面List创建方式
val listStr2=List.apply("Spark","Hive","Flink")

//  数值类型List
val doubleList=List(1.0,2.0,3.0)

2）List常用方法

list: List[Int] = List(-3, -2, 0, 1, 2, 3, 4)

//获取某个元素(类似于下标, 从0开始)

scala> list(1)

res0: Int = -2

//过滤元素(按条件, 传入的是一个 => Boolean)

scala> list.filter(_>0)

res1: List[Int] = List(1, 2, 3, 4)

//判断是否存在

scala> list.exists(_<0)

res2: Boolean = true

//遍历

scala> list.foreach(println)

-3

-2

0

1

2

3

4

//取第一个

scala> list.head

res4: Int = -3

//取最后一个

scala> list.last

res5: Int = 4

//取最后一个之前的

scala> list.init

res6: List[Int] = List(-3, -2, 0, 1, 2, 3)

//删除第一个

scala> list.drop(1)

res7: List[Int] = List(-2, 0, 1, 2, 3, 4)

//取第一个之后的

scala> list.tail

res11: List[Int] = List(-2, 0, 1, 2, 3, 4)

//删除第最后一个之前的(自右开始)

scala> list.dropRight(1)

res13: List[Int] = List(-3, -2, 0, 1, 2, 3)

//求和

scala> list.sum

res15: Int = 5

//元素个数

scala> list.length

res16: Int = 7

//添加到第一个

scala> 9::list

res18: List[Int] = List(9, -3, -2, 0, 1, 2, 3, 4)

//添加到第一个

scala> list.+:(10)

res21: List[Int] = List(10, -3, -2, 0, 1, 2, 3, 4)

//分片

scala> list.partition(_>0)

res23: (List[Int], List[Int]) = (List(1, 2, 3, 4),List(-3, -2, 0))

//左折叠

scala> list.foldLeft(0)((sum, i) => sum +i )

res24: Int = 5

//元素个数

scala> list.size

res31: Int = 7

3）List伴生对象方法