【Scala】基本数据结构（数组、列表、元组、集、映射、迭代器）

1 数组（Array）

1.1 创建数组

1、new一个数组，指定长度和数据类型

val array = new Array[Int](3)

2、使用数组Array的伴生对象创建

val array = Array[String]("hello","world")

1.2 获取索引的值

array(1)

1.3 修改指定索引的值

array(1) = "abc"

1.4 判断元素是否存在

array.contains("hello")

1.5 长度

array.size

array.length

1.6 遍历

for(a <- array){
}

2 可变数组（ArrayBuffer）

2.1 创建

1、创建一个Int类型的可变数组，可变数组维护的定长数组初始化长度为3，超过进行扩容

val ab = new ArrayBuffer[Int](3)

2、创建一个String类型可变数组（不可赋值）

val ab = new ArrayBuffer[String]()

3、使用ArrayBuffer来创建对象

val ab = ArrayBuffer[String](1，2)

2.2 增加元素

1、普通增加

ab.append(5)
ab.append(1,2,3,4)

2、指定位置插入增加

例：在1位置插入两个元素 -1、-2

ab.insert(1,-1,-2)

2.3 获取指定索引的元素

ab.get(1)

2.4 修改指定索引的元素

ab(4)=-4

2.5 删除指定

1、remove

一个参数

//删除索引为2的元素并获取
ab.remove(2)

两个参数

//从索引为1开始删除3个元素
//例如：1、2、3、4、5 删除后为 1、5
ab.remove(1,3)

2、drop

//删除前2个元素
ab.drop(2)

2.6 判断

ab.contain()

2.7 长度

ab.size
ab.length

2.8 定长数组和可变数组之间的转换

val array = Array(-1,-2,-3,-4,-5,-6)

//数组转可变数组
val ab = array.toBuffer

//可变数组转数组
array = ab.toArray

//将集合中每一个元素按照指定分隔符拼接为字符串，同时添加起始和结束字符
array.mkString(",")

array.mkString("[",",","]")

2.9 遍历

for (i <- ab){
}

for-each函数

array.foreach(num => println(num))

2.10 求和、最值、排序

1、求和

ab.sum

2、最值

ab.max

ab.min

3、排序

//从小到大
ab.sorted

//从大到小
ab.sortWith((v1,v2) => v1 > v2)

3 映射（map）

Map是一个对偶，映射的k-v键值对的集合，k不重复

Scala中有可变Map和不可变Map

3.1 不可变Map

构造出一个不可变Map[String，Int]，其值不可变

val p = Map[String,Int](
	"Alice" -> 20,
	"job" -> 20
	)

3.1.1 获取值

1、p.get(key)如果有则输出，没有则返回none

val key = "job"

val age = p.get(key).get

2、直接获取

val age = p(key)

3.1.2 修改 增加

p("job")=20

//删除返回一个新集合，原集合不变
p.drop(1)

3.2 可变Map

val p = scala.collection.mutable.Map[String,Int](
	"Alice" -> 20,
	"job" -> 20
	)

3.2.1 添加元素

//添加
map("a")=14

//修改
map("job")=22

//添加
map.put("b",20)

//删除前两个元素，原集合不变
map.drop(2)

3.2.2 遍历

for((k,v) <- map){
}

for(kv <- map){
	println(kv.1)
	println(kv.2)
}

map.foreach(kv=>{
	println(kv.1)
	println(kv.2)
})

4 元组（Tuple）

映射是键/值对偶的集合，对偶是元组的最简单形态，元组是不同类型的值的聚集。元组的值是通过将单个的值包含在圆括号里构成的。例如：（1，3.14，“abc”）是一个元组

注意：元组的各组元从1开始

4.1 构建

1、第一种

val tuple = new Tuple2[String,Int]("zhang",13)

2、第二种

val tuple2 = ("zhang",13)

3、第三种

val (a,b,c,d) = ("a1","b1","c1","d1")
println((a,b,c)) //输出a1、b1、c1

4.2 获取值

val tuple = ("zhang",13)
val name = tuple._1
val age = tuple._2

4.3 遍历

for(t <- tuple.productIterator){
  println(t)
}

5 zip拉链操作

zip操作就是将两个单列的集合组合成双列的集合，集合中每一组元素就是上述学习过的tuple

1、a.zip(b)

val p = Array("山东","河南")
val c = Array("济南","郑州")

val pcs = p.zip(c)

for(pc <- pcs){
  val p = pc._1
  val c = pc._2
  println(p)
  println(c)
}

2、a.zipAll(b,"a","b")

对没有匹配上的值自动进行填充，第一个（a）和第二个集合中多余的元素进行配对

val p = Array("山东","河南")
val c = Array("济南","郑州")

val pcs = p.zipAll(c,"a","b")
for(pc <- pcs){
  val p = pc._1
  val c = pc._2
  println(p)
  println(c)
}

6 列表（List）

6.1 创建

val intList = List(1,2,3)

6.2 获取

头部：

//返回一个值--------1
intList.head

尾部：

//返回一个列表-----List(2, 3)
intList.tail

索引：

list()

6.3 增加元素

1、增加一个元素

• list.+:(A)：将元素A添加到list首部
• list.::(A)：将元素A添加到list首部
• list.:+(A)：将元素A添加到list尾部

2、增加一个集合

• list.:::(A)：将集合A添加到list首部
• list.++:(A)：将集合A添加到list首部
• list.++(A)：将集合A添加到list尾部

6.5 删除

//从尾部开始删除1个元素
list.dropRight(1)

6.6 union

//组合，相当于sql里面的union all
left.union(right)

6.7 intersect

//交集
left.intersect(right)

6.8 diff

//差集
left.diff(right)

6.9 take

//获取集合中的前n个元素，如果该集合有序就是top n
left.take(2)

7 集合（set）

set是没有先后次序的值，元素值不可重复

7.1 有序的集合

val sorted = SortedSet("abc","abcd","a","abcdf")

输出：“a” “abc” “abcd” “abcdf”

7.2 基于自定义数据构建有序的集合

需要让元素具备可比性，或者为容器提供比较器

1、让元素具备可比性（实现特质Ordered）

case class Person(name:String,age:Int,height:Double) extends Ordered[Person]{
	//定义比较规则：先按照年龄升序排序，后年龄，后身高
	override def compare(that:Person){
		var ret = this.age.compareTo(that.age)
		if(ret == 0){
			ret = that.height.compareTo(this.height)
		}
		ret
	}
}

2、为容器提供比较器（实现特质Ordering）

val person = SortedSet()(new Ordering[Person](){
	override def compare(that:Person){
			var ret = this.age.compareTo(that.age)
			if(ret == 0){
				ret = that.height.compareTo(this.height)
			}
			ret
		}
})

8 迭代器（Iterator）

迭代器包含两个基本操作：next和hasNext。next可以返回迭代器的下一个元素，hasNext用于检测是否还有下一个元素。

1、while循环

val iter = Iterator("Hadoop","Spark","Scala")
while (iter.hasNext) {
    println(iter.next())
}

2、for循环

val iter = Iterator("Hadoop","Spark","Scala")
for (elem <- iter) {
    println(elem)
}