【scala】数组和列表
一、数组Array
1.创建数组
隐式：val greetStrings = new Array[String](3);
显式：val greetStrings ： Array[String] = new Arrray[String](3);
2.赋值
（1）greetStrings(0) = "hello";
greetStrings(1) = ",";
greetStrings(2) = "world\n"; //注意，后边是括号（），并不是[ ]
（2）val greetStrings = Array("hello",",","world\n");//编译器会推断出数组的类型为Array[String],同样后边是（）并不是[ ]
（3）greetStings.update(0,"Hello");//改变0位置的元素
3.遍历
for(i <- 0 until greetStrings.length)
println(i + ":" + greetingString(i));
4.多维数组
var myMatrix = ofDim[Int](3,3) //创建一个3x3的Int类型的多维数组
for (i <- 0 to 2；j <- 0 to 2) {
myMatrix(i)(j) = 1; //可以通过matrix(i)(j)来访问数组
print(myMatrix(i)(j));
}
5.一些常用方法
| 1 |
def apply( x: T, xs: T* ): Array[T] 创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。 |
| 2 |
def concat[T]( xss: Array[T]* ): Array[T] 合并数组 |
| 3 |
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit 复制一个数组到另一个数组上。相等于 Java's System.arraycopy(src, srcPos, dest, destPos, length)。 |
| 4 |
def empty[T]: Array[T] 返回长度为 0 的数组 |
| 5 |
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] 返回指定长度数组，每个数组元素为指定函数的返回值。 以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1： scala> Array.iterate(0,3)(a=>a+1)
res1: Array[Int] = Array(0, 1, 2)
|
| 6 |
def fill[T]( n: Int )(elem: => T): Array[T] 返回数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。 |
| 7 |
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] 返回二数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。 |
| 8 |
def ofDim[T]( n1: Int ): Array[T] 创建指定长度的数组 |
| 9 |
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] 创建二维数组 |
| 10 |
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] 创建三维数组 |
| 11 |
def range( start: Int, end: Int, step: Int ): Array[Int] 创建指定区间内的数组，step 为每个元素间的步长 |
| 12 |
def range( start: Int, end: Int ): Array[Int] 创建指定区间内的数组 |
| 13 |
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] 返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。 以上实例返回 3 个元素： scala> Array.tabulate(3)(a => a + 5)
res0: Array[Int] = Array(5, 6, 7)
|
| 14 |
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] 返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。 |
二、列表list
1.创建列表
val oneTwoThree = List(1,2,3);
val oneTwoThree：List[Int] = List(1,2,3); //注意，因为list不可变不能向数组那样，先实例再赋值，必须实例的时候就进行赋值。
2.遍历
(1)for(i <- 0 until oneTwoThree.length)
println(i + ":" + oneTwoThree(i));//同数组，随机访问是list(i),不是list[i]
(2)println(oneTwoThree); //注意数组不能这么直接打印
(3)oneTwoThree.foreach(print)
3.列表拼接
（1）List有个办法叫“：：：”用于两个列表拼接。
val one = List(1,2);
val two = List(3,4);
var oneAddTwo = one ::: two;
（2）在已有列表前添加一个元素 “：：”
val three = 5 :: one ;
val one = 1 :: 2 :: Nil; //创建一个one = List(1,2);Nil代表一个空List。
有同学要问，为什么不在list表尾添加元素呢，非要在表头添加呢？其实List.append（或 + ）方法提供了在list表尾添加元素的功能。
但是在结尾添加元素的操作时间随着列表的大小线性增加，而使用：：在表头添加的话只需要常量时间。
如果非要在表尾添加元素，我们可以通过依次在表头添加，然后调用list.reverse方法反序列表，达成高效建表。
（3）一些常用方法
| 1 |
def +:(elem: A): List[A] 为列表预添加元素 scala> val x = List(1)
x: List[Int] = List(1)
scala> val y = 2 +: x
y: List[Int] = List(2, 1)
scala> println(x)
List(1)
|
| 2 |
def ::(x: A): List[A] 在列表开头添加元素 |
| 3 |
def :::(prefix: List[A]): List[A] 在列表开头添加指定列表的元素 |
| 4 |
def :+(elem: A): List[A] 复制添加元素后列表。 scala> val a = List(1)
a: List[Int] = List(1)
scala> val b = a :+ 2
b: List[Int] = List(1, 2)
scala> println(a)
List(1)
|
| 5 |
def addString(b: StringBuilder): StringBuilder 将列表的所有元素添加到 StringBuilder |
| 6 |
def addString(b: StringBuilder, sep: String): StringBuilder 将列表的所有元素添加到 StringBuilder，并指定分隔符 |
| 7 |
def apply(n: Int): A 通过列表索引获取元素 |
| 8 |
def contains(elem: Any): Boolean 检测列表中是否包含指定的元素 |
| 9 |
def copyToArray(xs: Array[A], start: Int, len: Int): Unit 将列表的元素复制到数组中。 |
| 10 |
def distinct: List[A] 去除列表的重复元素，并返回新列表 |
| 11 |
def drop(n: Int): List[A] 丢弃前n个元素，并返回新列表 |
| 12 |
def dropRight(n: Int): List[A] 丢弃最后n个元素，并返回新列表 |
| 13 |
def dropWhile(p: (A) => Boolean): List[A] 从左向右丢弃元素，直到条件p不成立 |
| 14 |
def endsWith[B](that: Seq[B]): Boolean 检测列表是否以指定序列结尾 |
| 15 |
def equals(that: Any): Boolean 判断是否相等 |
| 16 |
def exists(p: (A) => Boolean): Boolean 判断列表中指定条件的元素是否存在。 判断l是否存在某个元素: scala> l.exists(s => s == "Hah")
res7: Boolean = true
|
| 17 |
def filter(p: (A) => Boolean): List[A] 输出符号指定条件的所有元素。 过滤出长度为3的元素: scala> l.filter(s => s.length == 3)
res8: List[String] = List(Hah, WOW)
|
| 18 |
def forall(p: (A) => Boolean): Boolean 检测所有元素。 例如：判断所有元素是否以"H"开头： scala> l.forall(s => s.startsWith("H")) res10: Boolean = false |
| 19 |
def foreach(f: (A) => Unit): Unit 将函数应用到列表的所有元素 |
| 20 |
def head: A 获取列表的第一个元素 |
| 21 |
def indexOf(elem: A, from: Int): Int 从指定位置 from 开始查找元素第一次出现的位置 |
| 22 |
def init: List[A] 返回所有元素，除了最后一个 |
| 23 |
def intersect(that: Seq[A]): List[A] 计算多个集合的交集 |
| 24 |
def isEmpty: Boolean 检测列表是否为空 |
| 25 |
def iterator: Iterator[A] 创建一个新的迭代器来迭代元素 |
| 26 |
def last: A 返回最后一个元素 |
| 27 |
def lastIndexOf(elem: A, end: Int): Int 在指定的位置 end 开始查找元素最后出现的位置 |
| 28 |
def length: Int 返回列表长度 |
| 29 |
def map[B](f: (A) => B): List[B] 通过给定的方法将所有元素重新计算 |
| 30 |
def max: A 查找最大元素 |
| 31 |
def min: A 查找最小元素 |
| 32 |
def mkString: String 列表所有元素作为字符串显示 |
| 33 |
def mkString(sep: String): String 使用分隔符将列表所有元素作为字符串显示 |
| 34 |
def reverse: List[A] 列表反转 |
| 35 |
def sorted[B >: A]: List[A] 列表排序 |
| 36 |
def startsWith[B](that: Seq[B], offset: Int): Boolean 检测列表在指定位置是否包含指定序列 |
| 37 |
def sum: A 计算集合元素之和 |
| 38 |
def tail: List[A] 返回所有元素，除了第一个 |
| 39 |
def take(n: Int): List[A] 提取列表的前n个元素 |
| 40 |
def takeRight(n: Int): List[A] 提取列表的后n个元素 |
| 41 |
def toArray: Array[A] 列表转换为数组 |
| 42 |
def toBuffer[B >: A]: Buffer[B] 返回缓冲区，包含了列表的所有元素 |
| 43 |
def toMap[T, U]: Map[T, U] List 转换为 Map |
| 44 |
def toSeq: Seq[A] List 转换为 Seq |
| 45 |
def toSet[B >: A]: Set[B] List 转换为 Set |
| 46 |
def toString(): String 列表转换为字符串 |
三、数组和列表的联系与区别
Scala数组是一个拥有相同类型的对象的可变序列，也就是说一个数组中只能包含相同类型的元素。虽然无法在数组实例化以后改变其长度，但是却可以改变它的元素值，因此，数组是可变的对象
Scala列表，跟数组类似只能包含相同类型的元素，但是列表是不可变的，每次改变List的操作都会返回一个新的List，这有点类似于JAVA里的String呀有木有。
注意，Scala中的List和JAVA中的List虽然拥有相同的名字，但是可不是一个东西，区别很大。
优质内容筛选与推荐>>1、德鲁克：管理自己
2、Fiddler 抓包工具总结（转）
3、push类型消息中间件-消息订阅者(一)
4、nginx配置
5、js 打开新窗口