Scala学习之路四

Scala数组和集合

scala的集合分为了两类，一类是可变的集合（集合可以执行增删改查操作），另一类是不可变集合（集合元素在初始化的时候确定，后续只能进行查，有的可以进行修改，有的不可以）。二者可能名称一样，但是在不同的包下面，对应的包为：scala.collection.mutable和scala.collection.immutable。

​ scala默认使用的集合，或者默认导入的包是immutable。

​ 说明：这里提到的可变或者不可变，指的是容器内部的内容，以及容器的长度可变或者不可变。

1 Scala数组

1.1 不可变数组Array

scala中的Array可以理解为java中的数组。

1. 数组的定义

java中数组的定义：
	new int[5]; 
    int[] aa = {1, 2, 3}; 
    int[] bb = new int[]{1, 2, 3, 4}
scala中数组的定义：
    val array = new Array[类型（比如Int/Long）](5) --->定义了一个长度为5的Int/Long类型的数组，每一个元素都有默认值：0。
    val array = Array(1, 2, 3, 4, 5) -->定义类一个初始化内容为1， 2， 3， 4， 5的Int类型的数组。
	其中第二种的定义方式，没有new关键，其实是class Array的伴生对象的构建方式。

1. 获取数组中的元素

数组名(index) 比如： val ele = array(3)

3. 元素的遍历

for(ele <- 数组) {
    。。。    
}
for(i <- array) {
    println(i)
}

4. 数组的长度

array.length
array.size

5. 数组判断

判断元素是否包含
array.contains(ele)
eg:
println("判断元素-3时候在数组中存在：" + array.contains(-2))

6. 数组元素的拼接输出

使用数组的方法：mkString
//拼接数组元素，没有分隔符
println("数组元素：" + array.mkString)
//拼接数组元素，使用分隔符", "
println("数组元素：" + array.mkString(", "))
//拼接数组元素，使用分隔符", ",起始字符为[,终止字符为]
println("数组元素：" + array.mkString("[", ", ", "]"))

数组元素：123-35
数组元素：1, 2, 3, -3, 5
数组元素：[1, 2, 3, -3, 5]

1.2 可变数组ArrayBuffer

scala中的ArrayBuffer可以理解为java中的ArrayList。

1. 定义

//定义一个Int类型的可变数组
val arrayBuffer = new ArrayBuffer[Int]()
//定义一个String类型的可变数组
val arrayBuffer = ArrayBuffer[String]()
//定义一个String类型的初始长度为16的可变数组
val arrayBuffer = ArrayBuffer[String](16)

2. crud

//crud
//增
println("----------arraybuffer的增的操作--------------")
ab.append(1)
println("ab.append(1): " + ab)
ab.append(2, 3, 4)
println("ab.append(2, 3, 4): " + ab)
//insert(index, ele*)在指定的索引位置上插入一个或多个元素
ab.insert(2, -3, -2)
println("ab.insert(2, -3, -2): " + ab)
//查
//获取指定索引位置的元素
val ele = ab(5)
println("ab(5): " + ele)
//数组长度
println("可变数组ab的长度：" + ab.size)
//改
ab(5) = -5
println("修改之后的数组为：" + ab)
//删
ab.remove(3)//删除指定索引位置上的元素
println("ab.remove(3): " + ab)
ab.remove(2, 2)//remove(index, count)从指定索引index位置开始删除，删除count个元素
println("ab.remove(2, 2): " + ab)
//drop
var newAb = ab.drop(2)
println("ab.drop(2): " + ab)
println("ab.drop(2): " + newAb)
newAb = ab.dropRight(2)
println("ab.dropRight(2): " + ab)
println("ab.dropRight(2): " + newAb)

3. 遍历和长度
   遍历和Array方式一样。
   长度可以使用length，也可以使用size。

for (i <- ab) {
    print(i + "\t")
}

4. 拼接数组字符串

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

1.3 Array和ArrayBuffer的一些基本通用操作

1. 包含

ab.contains(ele)  //判断元素是否包含

2. 数组求和

//调用数组的函数sum
println("数组求和" + ab.sum)

3. 数组的最大值最小值

//调用数组的函数max和min
println("最大值：" + ab.max)
println("最小值：" + ab.min)

4. Array和ArrayBuffer之间的互相转换

类似java中数组和ArrayList之间的转换
java版本
	数组--->List：Arrays.asList(array)
	List--->数组：list.toArray(new Xxx[list.size()])
scala版本
	Array--->ArrayBuffer：array.toBuffer
	ArrayBuffer--->Array：ab.toArray

5. 数组内容的显示

mkString(start, sep, end)

2 Scala集合

2.1 Map映射

Map是一个对偶，映射的k-v键值对的集合，在一个map中可以包含若干组k-v映射关系，前提条件是k不能重复。同样map也有可变和不可变之分。

2.1.1 不可变Map

import scala.collection.immutable.Map

1. 定义
   因为Map是一个类似java中的接口，无法直接创建对象，所以需要使用它的伴生对象创建。

val map = Map[Type1, Type2]()
创建了一个key的类型为Type1，value的类型为Type2的map映射

2. 初始化

 不可变的map的数组，只能在初始化的时候指定
val map = Map[Type1, Type2](
	(k1 -> v1),
	(k2 -> v2),
    。。。
)
或者
val map = Map[Type1, Type2](
	k1 -> v1,
	k2 -> v2,
    。。。
)

3. crud

//国家--->首都
val capital = Map[String, String](
    ("China" -> "BeiJing"),
    "Japan" -> "Tokyo",
    "South Korea" -> "汉城"
)

//crud
//增 不可变的map不能追加
//		capital += ("USA" -> "WC")
//		capital("USA") = "WC"
//删除
val ret = capital.drop(1)//原来的集合不会发生变化
println("capital.drop(1)返回值：" + ret)
println("capital.drop(1)之后的map：" + capital)
//该
//		capital("China") = "WC"
//查
/*
	map.get(key)
		返回值类Some或者None
		也就是如果key在map中存在返回Some，意思就是存在
		反之返回None
	总结：value也就是可能有值，也可能没有值
	scala中把这种可能有之，也可能没有值通过一个类Option[T]来表示
	Option有两个子类：Some(T)和None
*/
println("capital.get(\Jjapan\"): " + capital.get("Japan"))
println("capital.get(\"UK\"): " + capital.get("UK"))
/*
	既然get的返回值是Option，也就是无法直接过去value，要想获取value，就需要调用option.get()
	java.util.NoSuchElementException: None.get
	同时需要注意的是，get只能对some操作，对None操作会抛异常：NoSuchElementException
*/
println("capital.get(\"Japan\"): " + capital.get("Japan").get)

/*
	获取元素的方式二
	java.util.NoSuchElementException: key not found: uk
	key不存在会报错
*/
println("capital(\"Japan\"): " + capital("Japan"))
//println("capital(\"UK\"): " + capital("UK"))

//推荐使用，
val countryC = capital.getOrElse("China", "BeiJing")
println(countryC)
//判断
if(capital.contains("UK")) {
    println("capital(\"UK\"): " + capital("UK"))
}
//长度
capital.size

2.1.2 可变Map

import scala.collection.mutable.Map

1. 定义并初始化

val map = mutable.Map[Type1, Type2](
	(k1 -> v1),
	(k2 -> v2),
    。。。
)
创建了一个map，key的类型Type1，value的类型Type2，并且提供了初始化k-v键值对，当然可可以去掉其中的k-v，因为是可变的，那么便可以进行后续的元素追加。

2. crud

pc += ("广东" -> "粤")
pc += ("湖南" -> "湘")
pc += ("湖北" -> "鄂")
pc += ("广东" -> "粤")
pc("广西") = "桂"
println(pc)
//修改
pc("广西") = "桂桂"
//获取
println(pc.getOrElse("江西", "兰州"))
//删除
println(pc.remove("广东"))
println(pc)

2. map的通用操作

• 集合大小

map.size

• map的遍历

/**
 * java版本
 * for(Map.Entry<K, V> me : map.entrySet) {
 *     me.getKey
 *     me.getValue
 * }
 * for(K key : map.keySet()) {
 *     V v = map.get(key);
 * }
*/
for((k, v) <- pc) {
    println("key: " + k + ",value: " + v)
}
for(kv <- pc) {
    println(kv)
}
println("------foreach遍历---------")
//函数式编程的foreach遍历
pc.foreach(kv => {
    println(kv)
})

2.2 Tuple元组

1. 定义
   元组，其实就是一组对偶，也可以理解为是java中List。映射是键／值对偶的集合。对偶足是组( tuple)的最简单形态，元组是不同类型的值的聚集。元组的值是通过将单个的值包含在圆括号中构成的。例如：(1, 3.14, “Fred”)是一个元组，类型为：Tuple3 [Int, Double, java.lang.String]
2. 创建并初始化
   说明：元组Tuple是List，但是其长度是有范围的，最长可以容纳22个元素，也即Tuple22,其中Tuple1可以简写为Tuple。

//元组只能在创建的时候进行初始化
val tuple1 = new Tuple1[Int](1)
val tuple2 = new Tuple2[Int, Double](1, 3.14)

3. 操作

//获取元组的值
//获取第一个
println("tuple2._1: " + tuple2._1)
//获取第二个
println("tuple2._2: " + tuple2._2)
//获取第N(1 <= N <= 22)个
//		tuple2._N
//		tuple2._2 = 4.35 //不可以修改
//遍历 元组不可以直接进行遍历
for(t <- tuple2.productIterator) {
    println(t)
}

4. 比较常见的定义元组的方式

//更常见的元组的定义
val season = /*new Tuple4[String, String, String, String]*/("spring", "summer", "autumn", "winter")
season._2
//最常见的定义方式
val (spring, summer, autumn, winter) = ("spring", "summer", "autumn", "winter")
println(spring)
println(summer)

2.3 Zip拉链操作

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

val province = Array("山东", "河南", "陕西", "福建")
val capital = Array("济南", "郑州", "西安", "福州", "桂林")
//zip 拉链操作
val pcs = province.zip(capital)
for((p, c) <- pcs) {
    println(p + "--->" + c)
}

特点：
​ 在组合两个集合的时候，集合元素两两一一对应，如果两个集合的长度不一致，将超过的部分,或者没有匹配上的部分进行裁剪，丢弃。