zoukankan      html  css  js  c++  java
  • Scala学习(三)----数组相关操作

    数组相关操作

    摘要:

    本篇主要学习如何在Scala中操作数组。Java和C++程序员通常会选用数组或近似的结构(比如数组列表或向量)来收集一组元素。在Scala中,我们的选择更多,不过现在我们先假定不关心其他选择,而只是想马上开始用数组。本篇的要点包括:

    1. 若长度固定则使用Array,若长度可能有变化则使用ArrayBuffer

    2. 提供初始值时不要使用new

    3. 用()来访问元素

    4. 用for (elem<-arr)来遍历元素

    5. 用for (elem<-arr if…)…yield…来将原数组转型为新数组

    6. Scala数组和java数组可以互操作;用AnayBuffer,使用scalacollection.JavaConversions中的转换函数

    定长数组

    如果你需要一个长度不变的数组,可以用Scala中的Array。例如:

    val nums=new Array[Int] (10) //长度为10的整数数组,所有元素初始化为0

    val a=new Array [String] (10) //长度为10的字符串数组,所有元素初始化为null

    val s= Array("Hello", "World") //长度为2的Array[String]类型是推断出来的,已提供初始值就不需要new

    S (0) ="Goodbye" //Array("Goodby ","World"),使用()而不是[]来访问元素

    在JVM中,Scala的Array以Java数组方式实现。示例中的数组在JVM中的类型为java.lang.String[]。Int、Double或其他与Java中基本类型对应的数组都是基本类型数组。

    举例来说,Array(2,3,5,7,11)在JVM中就是一个int[]。

    变长数组:缓冲

    尾端操作缓冲数组

    对于那种长度按需要变化的数组,Java有ArrayList,C++有vector。Scala中的等效数据结构为ArrayBuffer

    import scala.collection.mutable.ArrayBuffer

    val b=ArrayBuffer[lnt]() // 或者new ArrayBuffer [int],一个空的数组缓冲,准备存放整数

    b+=1 // ArrayBuffer (1),用+=在尾端添加元素

    b+=(1,2,3,5) // ArrayBuffer(1,1,2,3,5),在尾端添加多个元素,以括号包起来

    b++= Array(8, 13, 21) // ArrayBuffer(1, 1, 2, 3, 5, 8,13, 21) //用++=操作符追加任何集合

    b.trimEnd(5) // ArrayBuffer(1, 1, 2),移除最后5个元素

    在数组缓冲的尾端添加或移除元素是一个高效的操作

    任意位置操作缓冲数组

    你也可以在任意位置插入或移除元素,但这样的操作并不那么高效。所有在那个位置之后的元素,都必须被平移。举例如下:

    b.insert (2,6) //ArrayBuffer(1, 1, 6, 2),在下标2之前插入

    b.insert (2,7,8,9) // ArrayBuffer(1, 1,7,8,9, 6,2),你可以插入任意多的元素

    b.remove(2) // ArrayBuffer(1,1,8,9,6,2)

    b.remove (2,3) //ArrayBuffer(1,1, 2),第2个参数的含义是要移除多少个元素

    有时你需要构建一个Array,但不知道最终需要装多少元素。在这种情况下,先构建一个数组缓冲,然后调用:

    b.toArray //Array(1, 1,2)

    反过来,调用乱toBuffer可以将一个数组a转换成一个数组缓冲

    遍历数组和数组缓冲

    全遍历

    在Java和C++中,数组和数组列表/向量有一些语法上不同,Scala则更加统一。大多数时候,你可以用相同的代码处理这两种数据结构。以下是for循环遍历数组或数组缓冲的语法:

    for (i <- 0 until a.length) //变量i的取值从0到a length -1

    println(i+":"+a(i))

    utiI是Richlnt类的方法,返回所有小于但不包括上限的数字。例如:

    0 until 10 // Range(0,1,2,3,4,5,6,7,8, 9)

    需要注意的是,0 until 10实际上是一个方法调用:0.until(10)

    条件遍历

    如下结构:

    for(I <- 区间)

    会让变量i遍历该区间的所有值。拿本例来说,循环变量i先后取值0、1,等等,直到但不包含a.length。如果想要每两个元素一跳,可以让i这样来进行遍历:

    0 until (a.length,2) //Range(0,2,4,…)

    如果要从数组的尾端开始,遍历的写法为:

    (0 until a.length) .reverse //Range(...,2,1,0)

    如果在循环体中不需要用到数组下标,我们也可以直接访问数组元素,就像这样:

    for (elem <- a)

    println (elem)

    这和Java中的"增强版"for循环,或者C++中的"基于区间的"for循环很相似。变量elem先后被设为a(0),然后a(1),依此类推

    数组转换

    for中的推导式和守卫

    在前面,你看到了如何像Java或C++那样操作数组。不过在Scala中,你可以走得更远。从一个数组或数组缓冲出发,以某种方式对它进行转换是很简单的。这些转换动作不会修改原始数组,而是产生一个全新的数组。像这样使用for推导式

    val a=Array(2, 3, 5, 7, 11)

    val result=for (elem <- a) yield 2*elem //result是Array(4,6,10, 14, 22)

    for(…)yield循环创建了一个类型与原始集合相同的新集合。如果你从数组出发,那么你得到的是另一个数组。如果你从数组缓冲出发,那么你在for(…)yield之后得到的也

    是数组缓冲

    结果包含yield之后的表达式的值,每次迭代对应一个。通常,当你遍历一个集合时,你只想处理那些满足特定条件的元素。这个需求可以通过守卫:for中的if来实现。在这里我们对每个偶数元素翻倍,并丢掉奇数元素:

    for (elem <- a if elem%==0) yield 2*elem

    请留意结果是个新的集合,原始集合并没有受到影响

    一种等价方法

    除上述之外,还有另一种做法是

    a.filter (_%2==0).map(2*_)

    甚至

    a.filter { _%2 == 0 } map {2*_ }

    某些有着函数式编程经验的程序员倾向于使用filter和map而不是守卫和yield,这不过是一种风格罢了与for循环所做的事完全相同。你可以根据喜好任意选择。

    高效数组操作

    考虑如下示例:给定一个整数的数组缓冲,我们想要移除除第一个负数之外的所有负数。传统的依次执行的解决方案会在遇到第一个负数时置一个标记,然后移除后续出现的负数元素

    var first=true

    var n=a.length

    var i=0

    while ( i<n ) {

    if (a(i) >= 0)

    i+=1

    else{

    if (first) {

    first=false

    i+=1

    } else {

    a.remove (i)

    n-=1

    }

    }

    }

    但这个方案其实并不那么好:从数组缓冲中移除元素并不高效,把非负数值拷贝到前端要好得多。

    首先收集需要保留的下标:

    var first= true

    val indexes=for (i <- 0 until a.length if first || a(i)>=0) yield {

    if (a(i)<0)

    first=false;

    i

    }

    然后将元素移动到该去的位置,并截断尾端:

    for(j <- 0 until indexes.length)

    a(j)= a(indexes(j))

    a.trimEnd (a.length -indexes.length)

    这里的关键点是,拿到所有下标好过逐个处理

    常用算法

    求和与排序

    有一种说法,很大比例的业务运算不过是在求和与排序。还好Scala有内建的函数来处理这些任务

    Array(1,7,2, 9).sum // 19,对ArrayBuffer同样适用

    要使用sum方法,元素类型必须是数值类型:要么是整型,要么是浮点数或者Biglnteger/BigDecimal。

    同理,min和max输出数组或数组缓冲中最小和最大的元素。

    ArraryBuffer("Mary", "had","a","little", "lamb").max // "little"

    sorted方法将数组或数组缓冲排序并返回经过排序的数组或数组缓冲,这个过程并不会修改原始版本:

    val b=ArrayBuffer(1,7,2, 9)

    val bSorted=b.sorted(_ < _) // b没有被改变,bSorted是ArrayBuffer(1,2,7,9)

    还可以提供一个比较函数,不过你需要用sortWith方法:

    val bDescending=b.sorted(_ > _) // ArrayBuffer(9,7,2, 1)

    可以直接对一个数组排序,但不能对数组缓冲排序:

    val a=Array(1,7,2,9)

    scala.util. Sorting.quickSortIa(a) // a现在是Array(1,2,7,9)

    关于num、max和quickSort方法,元素类型必须支持比较操作,这包括了数字、字符串以及其他带有Ordered特质的类型。

    显示数组内容

    最后,如果你想要显示数组或数组缓冲的内容,可以用mkString方法,它允许你指定元素之间的分隔符。该方法的另一个重载版本可以让你指定前缀和后缀。例如:

    a.mkString("and") // "1 and 2 and 7 and 9"

    a.mkString("<" , "," , ">") // "<1,2,7,9>"

    和toString相比:

    a.toString // " [I@85b8d",这里被调用的是Java的毫无意义的toString方法

    b.toString // "ArrayBuffer(l,7,2, 9)",toString方法报告了类型,便于调试

    解读Scaladoc

    数组和数组缓冲有许多有用的方法,我们可以通过浏览Scala文档来获取这些信息。对Array类的操作方法列在ArrayOps相关条目下。从技术上讲,在数组上应用这些操作之前,数组都会被转换成ArrayOps对象。

    由于Scala的类型系统比java更丰富,在浏览Scala的文档时,你可能会遇到一些看上去很奇怪的语法。所幸,你并不需要理解类型系统的所有细节就可以完成很多有用

    的工作。你可以把下表用做"解码指环"。

    多维数组

    和Java一样,多维数组是通过数组的数组来实现的。举例来说,Double的二维数组类型为:

    Array[Array[Double]]

    要构造这样一个数组,可以用ofDim方法:

    val matrix=Array.ofDim[Double](3,4) //三行,四列要访问其中的元素,使用两对圆括号:

    matrix (row) (column) =42

    你可以创建不规则的数组,每一行的长度各不相同:

    val triangle=new ArraylArray [Int] (10)

    for (i <- 0 until triangle.length)

    triangle(i)=new Array[lnt] (i+1)

    与Java互操作

    由于Scala数组是用java数组实现的,你可以在Java和Scala之间来回传递。如果你调用接受或返回java.utiI.List的Java方法,则当然可以在Scala代码中使用Java的ArrayList但那样做没什么意思。你完全可以引入scala.collection.JavaConversions里的隐式转换方法。这样你就可以在代码中使用Scala缓冲,在调用Java方法时,这些对象会被自动包装成Java列表。

    举例来说,java.lang.ProcessBuilder类有一个以List<String>为参数的构造器。以下是在Scala中调用它的写法:

    import scala.collection.JavaConversions.bufferAsJavaList

    import scala.collection.mutable.ArrayBuffer

    val command = ArrayBuffer("ls", "-al", "/home/cay")

    val pb = new ProcessBuilder(command) // Scala到Java的转换

    Scala缓冲被包装成了一个实现了java.util.List接口的Java类的对象。反过来讲,当Java方法返回java.util.List时,我们可以让它自动转换成一个Buffer:

    import scala.collection.JavaConversions.asScalaBuffer

    import scala.collection.mutable.Buffer

    val cmd: Buffer[String] = pb.command() // Java到Scala的转换

    需要注意的是,不能使用ArrayBuffer——包装起来的对象仅能保证是个Buffer。如果Java方法返回一个包装过的Scala缓冲,那么隐式转换会将原始的对象解包出来。拿本例来说,cmd == command。☆☆

  • 相关阅读:
    ftp的虚拟用户的使用
    系统进程与线程
    mysql 100%占用的解决
    两张神图介绍python3和 2.x与 3.x 的区别
    python3中__get__,__getattr__,__getattribute__的区别
    Python 数据图表工具的比较
    Spark入门(Python)
    别学框架,学架构
    Python垃圾回收机制
    pyextend库-accepts函数参数检查
  • 原文地址:https://www.cnblogs.com/zzmmyy/p/8508111.html
Copyright © 2011-2022 走看看