Scala2.11.7学习笔记（四）常用数据结构
鲁春利的工作笔记，好记性不如烂笔头
1、Array
http://www.scala-lang.org/api/current/#scala.Array
Arrays are mutable, indexed collections of values. Array[T] is Scala's representation for Java's T[].
var array = new Array[数据类型](数组长度);
说明：数组成员初始化，Int类型默认会初始化为0，String类型会初始化为Null。
var array = Array[数据类型](数组元素值);
说明：数组声明时若给出初值，Scala能够进行类型推断，因此可以不用声明数组类型和长度。
package com.lucl.scala
import scala.collection.mutable.ArrayBuffer
/**
* @author luchunli
*/
object ArrayDataStructure {
def main(args: Array[String]): Unit = {
/**
* 定长数组
*/
// new时指定类型及长度,指定变量类型: Array[Int]，可以省略
var array1 = new Array[Int](5);
{
for (i <- 0 until 5) array1(i) = i + 1;
}
// 5, 4, 3, 2, 1,
for (i <- array1.reverse) print(i + ", ");
println();
// 直接赋固定值，Scala能够进行类型推导
var array2 = Array(1, 2, 3, 4, 5);
// 1, 2, 3, 4, 5,
array2.foreach { x => print(x + ", ") }
println();
println(array2.max + "\t" + array2.min) // 5 1
/**
* 变长数组，scala.collection.mutable包
*/
var arrBuffer = new ArrayBuffer[String](5);
println(arrBuffer.length) // 0
arrBuffer ++= Array("hello");
println(arrBuffer.length) // 1
/**
* 定长数组转变长数组
*/
println(array2.toBuffer);
/**
* 变长数组转定长数组
*/
println(arrBuffer.toArray);
/**
* zip操作
*/
var array3 = Array(1, 2, 3);
var array4 = Array("a", "b", "c");
var tuple = array3 zip array4; // 得到tuple
// (1,a) (2,b) (3,c)
for (i <- tuple) print(i + " "); //
println();
//
val array5 = Array("hello you", "hello me");
val retVal = array5.flatMap { x => x.split(" ") }
// hello you, hello me
println(array5.mkString(", "));
// hello, you, hello, me
println(retVal.mkString(", "));
}
}
多维数组
val matrix = Array.ofDim[Int](3, 4); // 三行四列的二维数组
matrix(2)(1) = 42;
val triangle = new Array[Array[Int]](10);
for (i <- 0 until triangle.length) {
triangle(i) = new Array[Int](i + 1);
}
2、Lists
http://www.scala-lang.org/api/current/#scala.collection.immutable.List
Scala中提供了List类，和Java的List不同，Scala的List对象是不可修改的。
A class for immutable linked lists representing ordered collections of elements of type.
构建列表的两个基础是：
scala.Nil表示空列表;
scala.::从已有的列表构建新列表。
::读作cons，cons操作符有两个参数：一个类型为T的元素和一个类型为List（T）的对象，它会把两个参数合到一起创建一个新的List(T)值。
val list = List(元素值列表);
说明：元素必须为同一类型。
package com.lucl.scala
import scala.collection.mutable.ListBuffer
/**
* @author luchunli
*/
object ListDataStructure {
def main(args: Array[String]): Unit = {
// : List[String] 是可以省略的
val list : List[String] = List("hello", "you", "hello", "me");
/**
* 代码块
*/
list.foreach
{ x =>
{
if (x.equals("hello"))
{
print(x + ", ");
}
}
}
println();
println("----------------------------");
println();
/**
* Nil空列表和::构建新的列表
*/
val list2 = 1 :: 2 :: 3 :: Nil; // 只能用在尾部
val list3 = "hello you" :: "hello me" :: List();
val retVal = list3.flatMap
{ x =>
{
x.split(" ");
}
}
// List(hello, you, hello, me)
println(retVal);
val retMap = retVal.map { x => (x, 1) }
/**
hello : 1
you : 1
hello : 1
me : 1
*/
for ((k, v) <- retMap) println(k + " : " + v);
/**
* 可变List,ListBuffer
*/
var listBuf = ListBuffer(1, 2, 3, 4, 5);
}
}
3、Set
http://www.scala-lang.org/api/current/#scala.collection.mutable.Set
和java中Set类似，Key，分两个包定义：
可变： scala.collection.mutable
不可变： scala.collection.immutable
缺省情况Set为immutable Set 。package com.lucl.scala
/**
* @author luchunli
*/
object SetDataStructure {
def main(args: Array[String]): Unit = {
// 说明：Set中数据是会去重的，也就是两个hello实际使用的时候只会有一个
val sset = Set("hello", "world", "hello", "me");
// hello, world, me,
sset.foreach { x => print(x + ", "); }
println();
sset.+("new"); // 不可对sset重新赋值，这里实际返回了一个新的set
// 不可变set
var iset = scala.collection.mutable.Set("hello", "world", "hello", "me");
iset += "new"; // 可调用+=
}
}
4、Map
scala.collection.Map scala.collection.immutable.Map # 可变映射 scala.collection.immutable.HashMap scala.collection.mutable.Map # 不可变映射 scala.collection.mutable.HashMap
说明：默认为不可变映射。
// 不可变映射 val map = Map(key1 -> value1, key2 -> value2, key3->value3); // val map = Map((key1, value1), (key2, value2), (key3, value3)) // 可变映射需指定全类名 val map = scala.collection.mutable.Map((key1, value1), (key2, value2), (key3, value3)); // val map = new scala.collection.mutable.Map[T1, T2]()
获取对应键的值
val value = Z(key); // 返回值 val value = Z.get(key); // 返回对象
说明：
当映射中不包含对应的键时，会抛出异常。
利用contains方法检查映射中是否有某个键，val c = Z.contains(key); // 返回boolean值
或者通过组合调用val d = Z.getOrElse(key, 0); 存在则返回否则返回0
package com.lucl.scala
/**
* @author luchunli
*/
object MapDataStructure {
def main(args: Array[String]): Unit = {
/**
* 不可变 ，scala.collection.immutable.Map
*/
val map1 = Map( 1-> "I", 2 -> "II", 3 -> "III", 4 -> "IV");
for ((k, v) <- map1) println(k + " : " + v); // 显示key和value
for ((k, _) <- map1) println(k); // 只显示key
for ((_, v) <- map1) println(v); // 只显示value
val map2 = Map[String, Int]();
map2 + (("zhangsan", 18), ("wangwu", 21)); // 可以添加元素，但是不能+=
map2 + ("lisi" -> 20, "zhaoliu" -> 19);
/**
* 可变
*/
val hm = scala.collection.mutable.HashMap(1 -> "hi", 2 -> "there");
hm += ((3, "three"), (4, "four")); // 增加元素
hm -= 1; // 删除元素
map2.keys.foreach { x => println(x); } // 获取key
map2.values.foreach { x => println(x); } // 获取value
}
}
5、Tuples
Scala 中另外一个很有用的容器类为Tuples，和List不同的Tuples可以包含不同类型的数据，而List只能包含同类型的数据。
一旦定义了一个元组，可以使用._和索引来访问员组的元素（矢量的分量，注意和数组不同的是，元组的索引从1开始）。
scala> val paris=(123, "abc") paris: (Int, String) = (123,abc) scala> println (paris._1); 123 scala> println (paris._2); abc scala> var tuple = (1, 2.1, "spark"); tuple: (Int, Double, String) = (1,2.1,spark) scala> val (first, second, third) = tuple; first: Int = 1 second: Double = 2.1 third: String = spark scala> val (fa, _, _) = tuple; fa: Int = 1 scala> "Rocky Spark".partition(_.isUpper); res0: (String, String) = (RS,ocky park) scala>
6、zip方法
把几个集合结合起来
scala> val one = Array('a', 'b', 'c');
one: Array[Char] = Array(a, b, c)
scala> val two = Array(1, 2, 3);
two: Array[Int] = Array(1, 2, 3)
// 生成一个新的数组
scala> val three = one zip two;
three: Array[(Char, Int)] = Array((a,1), (b,2), (c,3))
scala> val three01 = two zip one;
three01: Array[(Int, Char)] = Array((1,a), (2,b), (3,c))
// 生成一个以数组one为键，数组two为值的映射
scala> val four = one zip two toMap;
warning: there were 1 feature warning(s); re-run with -feature for details
four: scala.collection.immutable.Map[Char,Int] = Map(a -> 1, b -> 2, c -> 3)
scala> four.toMap;
res58: scala.collection.immutable.Map[Char,Int] = Map(a -> 1, b -> 2, c -> 3)