Scala--数组

  数组存储相同类型元素的连续集合。在JVM中,scala以java数组的方式实现,Array[Int],Array[String]等分别对应着java的基本类型数组int[]、String[]。

数组语法

  • 语法

    1
    2
    3
    val|var 变量名:Array[变量类型] = new Array[变量类型](长度)  #数组的定义
    val|var 变量名 = new Array[变量类型](长度)  #简化形式(常用)
    val|var 变量名 = Array(初始化值)  #直接初始化值,自动会进行类型推断
  • 示例一:定义了一个长度为5的String数组,然后可以看见该数组被默认初始化为5个null值在数组中

    1
    2
    3
    4
    5
    6
    scala> var array: Array[String] = new Array[String](5)
    array: Array[String] = Array(null, null, null, null, null)

    ###然后定义五个Int类型的数组,默认初始化为0
    scala> var array1 = new Array[Int](5)
    array1: Array[Int] = Array(0, 0, 0, 0, 0)
  • 示例二:定义数组并初始化值,如果没有指定数组类型,会自动进行类型推断

    1
    2
    3
    4
    5
    scala> var array2 = Array(8989,"xiaoxiaomo")
    array2: Array[Any] = Array(8989, xiaoxiaomo)

    scala> var array3 = Array(8989,77.5)
    array3: Array[Double] = Array(8989.0, 77.5)
  • 从上面的例子中可以看到:

    1. 当我们定义数组时,如果没有初始化值它会根据数据的长度自动初始化,设置默认参数;
    2. 数组可以自己进行类型推断,当类型不一致时,会为Any类型
    3. 提供了初始值就不需要new;
    4. 定长数组必须指定数组长度

还需要注意的是,如果数组声明为val那么该数组的值是可以改变的;只是该变量不能重新被赋值,即变量指定的数组对象地址不能改变,数组对象的值可以变

  • 变长数组

  • 变长数组,使用ArrayBuffer也叫数组缓冲。就是定义一个可以改变的数组,在定义时可以不指定数组长度,如下示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    scala> val ab = new scala.collection.mutable.ArrayBuffer[Int]()
    ab: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

    scala> ab += 12; ##虽然是val定义的变量,但是我们还是可以修改值。
    res0: ab.type = ArrayBuffer(12)

    scala> ab += (34,45)
    res1: ab.type = ArrayBuffer(12, 34, 45)

    scala> res0 ++=ab
    res2: res0.type = ArrayBuffer(12, 34, 45, 12, 34, 45)

    scala> ab.toArray
    res3: Array[Int] = Array(12, 34, 45, 12, 34, 45)

    scala> res0.toArray
    res4: Array[Int] = Array(12, 34, 45, 12, 34, 45)

    scala> res1.toArray
    res5: Array[Int] = Array(12, 34, 45, 12, 34, 45)

    scala> res2.toArray
    res6: Array[Int] = Array(12, 34, 45, 12, 34, 45)
  • 注意

  1. 定义变长数组时,“()”可以省略。记住省略“()”后就不能省略new,省略new就不能省略“()”在下图事例中,第一种定义就无效;

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    scala> val abc = scala.collection.mutable.ArrayBuffer[Int]  ##`括号和new至少要有一样`
    <console>:7: error: missing arguments for method apply in class GenericCompanion;
    follow this method with `_' if you want to treat it as a partially applied function
    val abc = scala.collection.mutable.ArrayBuffer[Int]
    ^

    scala> val abc = scala.collection.mutable.ArrayBuffer[Int]()
    abc: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

    scala> val abc = new scala.collection.mutable.ArrayBuffer[Int]
    abc: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
  2. 给数组赋值时,可以使用“+=单个参数|(多个)”,“++=数组”在尾部追加数据;

  3. 赋值完成后,可以使用toArray方法转为数组,当然也可使用toArrayBuffer转回去
  4. 数组常用方法,remove(…),insert(…),trimEnd;

数值遍历

  •   之前我们已经讲过for循环,使用上面定义的ab数组做一下遍历
    1
    2
    3
    4
    5
    6
    7
    scala> for( i <- 0 until ab.length ){
    | print( " " + ab(i) )
    | }
    12 34 45 12 34 45
    scala> for( i <- 0 until ab.length if ab(i) % 4 ==0 )
    | yield ab(i)-6
    res9: scala.collection.immutable.IndexedSeq[Int] = Vector(6, 6)

注意

  1. 数组的小标从0开始,所以最大小标为length-1,不然会越界,通常使用unitl
  2. 获取数组元素的时候使用“()”,和java不同;
  3. 使用yield可以创建一个新的集合,原始集合并不受影响,注意yield在“{}”的后面,“{}”也可省略;
  4. 当然同样可使用“带刀侍卫”(●’◡’●),侍卫也能获取元素;

常用算法

具体内容可阅读scaladoc文档,这里简单的举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
scala> Array(8,92,32,53).sum
res11: Int = 185

scala> Array(8,92,32,53).max
res12: Int = 92

scala> Array(8,92,32,53).sorted
res13: Array[Int] = Array(8, 32, 53, 92)

scala> Array(8,92,32,53).sortWith(_ > _)
res14: Array[Int] = Array(92, 53, 32, 8)

scala> Array(8,92,32,53).count(_ > 0 )
res15: Int = 4

多维数组

多位数组和java的数组类似,里面也是使用了数组。二维数组使用关键只ofDim方法:

1
2
3
4
5
6
7
8
9
scala> val dim = Array.ofDim[Int](2,3)
dim: Array[Array[Int]] = Array(Array(0, 0, 0), Array(0, 0, 0))

scala> dim(0)(1) = 1

scala> dim(1)(2) = 3

scala> dim
res18: Array[Array[Int]] = Array(Array(0, 1, 0), Array(0, 0, 3))

与java互转

与java互转操作,在后面应该会常用。在scala中Scala.collection.JavaConversions里的有隐式转换方法。

下面来写一个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.ArrayList;
import java.util.List;

/**
* 一个简单的java代码demo
* Created by xiaoxiaomo on 2016/3/26.
*/

public class JavaArraList {

public List<String> getListStr(){ //会返回一个List<String>类型的集合
List<String> list = new ArrayList<String>() ;
list.add("Hello");
list.add("word");
return list ;
}

public void setListStr(List<String> arrList){//需要传递一个List集合
for ( String str : arrList )
System.out.print(" " + str);
System.out.println();
}
}

scala操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import scala.collection.JavaConversions
import scala.collection.mutable.ArrayBuffer

/**
* Created by xiaoxiaomo on 2016/3/25.
*/

object TestDemo {

def main(args: Array[String]): Unit = {
val sca = ArrayBuffer("Hl", "ooo", "woddd") ;
//
println("scala转java")
new JavaArraList().setListStr(JavaConversions.bufferAsJavaList(sca));
//
println("java转scala")
val j2s =JavaConversions.asScalaBuffer(new JavaArraList().getListStr()) ;
for( i <- 0 until j2s.length ) print( " " + j2s(i) )
}
}

  • 运行结果
    1
    2
    3
    4
    scala转java
    Hl ooo woddd
    java转scala
    Hello word

当前网速较慢或者你使用的浏览器不支持博客特定功能,请尝试刷新或换用Chrome、Firefox等现代浏览器