3-数组

1. Array

Array是scala对java底层数组元素做的一层封装，Array是一个scala类，创建通过new 或者apply方法，代码反编译后也可以查看到本来的数据类型，都是String[],Array创建时需要声明类型和长度，并且是不支持修改长度的。

package cn.chapter6_array

/**
 * scala数组案例：
 * 1.数组定义：通过new Array[泛型](长度)，或者使用Array()的apply方法，泛型可以自动类型推断。
 *  scala的数组类型，是一个Array类，底层仍然是jvm的数组类型[String这种，就是对其封装了一次，
 *  使其有操作方法。
 *
 * @author: mahao
 * @date: 2020/10/25 18:10
 */
object Array1 {

  def main(args: Array[String]): Unit = {
    //1.数组的创建，Array传入泛型，和数组长度，数组是不可变的。
    val arr1: Array[String] = new Array[String](3)

    //2.scala中的数组是类型，不同数组是泛型定义的，可以直接使用apply方法创建。
    /*
    def apply[T: ClassTag](xs: T*): Array[T] = {
    val array = new Array[T](xs.length)
    var i = 0
    for (x <- xs.iterator) { array(i) = x; i += 1 }
    array
  }
     */
    val arr2: Array[Any] = Array(1, 2, 3, "aa")

    //3. 数组增删改查
    println(s"获取数组的长度与第二个元素：${arr2.length} , ${arr2(1)}")
    println(s"修改索引为1的数组值为18，${arr2(1) = 18}, 修改后的结果是${arr2(1)}")
    arr2.update(4,10)//修改操纵,数组操作不可越界。


  }
}

2.ArrayBuffer

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xlJ44FGS-1603641025710)(…/…/image/image-20201025192806296.png)]

• ArrayBuffer是一个类，长度是可变的，元素也是可变的，获取通过索引获取了
• 数组的遍历方式
• Array和ArrayBuffer之间互相转换

package cn.chapter6_array

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

/**
 * 数组操作2：可变数组.
 * 1. 创建，通过apply方法，或者new
 * 2. array和ArrayBuffer之间的互相转换。
 * 3. array的遍历(seq的遍历)
 *
 * @author: mahao
 * @date: 2020/10/25 18:30
 */
object Array2_buffer {

  def main(args: Array[String]): Unit = {
    //1.scala使用ArrayBuffer可以是可变的数组。
    var arr1 = new ArrayBuffer[String]()
    arr1.append("00", "11") //添加一个或者多个元素
    arr1.+=("22") //添加一个元素
    arr1.++=(Seq("33", "44")) //添加一个序列，可以添加其他数组。
    println(arr1.toString())

    //2.删除元素
    arr1.remove(2) //删除指定索引的元素
    println(arr1.toString())
    arr1.trimEnd(2) //截取掉后面的元素。
    println(arr1)

    //3.使用insert插入元素,指定索引位置插入
    arr1.insertAll(2, Array("22", "33"))
    println(arr1)

    //4. 在Array与ArrayBuffer之间互换
    val array: Array[String] = arr1.toArray
    val buffer: mutable.Buffer[String] = array.toBuffer
    println(array.hashCode())
    println(buffer.hashCode())
    println(arr1.hashCode())

    //vector是不可变集合，元素值也不可以改变
    val v = Vector[Int](1, 2, 3)
    println(v)
    val i: Int = v(1)
    println(i)

    //5.数组遍历
    //通过for循环，通过索引遍历
    for (i <- 0.until(arr1.length, 1)) {
      print(arr1(i) + " ")
    }
    println()
    //逆序遍历，间隔为2
    for (i <- 0.until(arr1.length).reverse) {
      print(arr1(i) + " ")
    }
    
  }
}

3. 数组转换

• 数组之间通过过滤或者其他操作,转换为一个新的数组的过程.
• 通过for循环和yield关键字,实现新数组的创建,结合守卫过滤数组,yield之后可以进行每个选项的其他操作.
• 通过Traverseable接口,使用里面的map,filter等函数式方法。

package cn.chapter6_array

import scala.collection.mutable.ArrayBuffer

/**
 * 数组案例:
 * 使用yield和函数编程剔除除第一个负数外的所有负数.
 * 两种实现：
 * 1.yield保存要留下的数据的索引，然后覆盖原数组
 * 2.Traverable的filter实现过滤。
 *
 * @author: mahao
 * @date: 2020/10/25 23:18
 */
object Array_example {

  def main(args: Array[String]): Unit = {
    val ints: Array[Int] = fun1(1, 2, 3, -1, -3, 4, 5)
    println(ints.toBuffer)

    val ints2: Array[Int] = fun2(1, 2, 3, -1, -3, 4, 5)
    println(ints2.toBuffer)
  }

  //2.第二种实现方式，使用yield记录需要保留的数据，之后在覆盖原数组。
  def fun2(as: Int*): Array[Int] = {

    //因为要覆盖写，包装成可变数组。
    val ints: ArrayBuffer[Int] = ArrayBuffer(as: _*)
    //for循环，结合守卫，获取所有需要保留的数据索引
    var flag = true
    val keep: IndexedSeq[Int] = for (i <- 0.until(ints.length) if (ints(i) > 0) || flag) yield {
      if (ints(i) < 0) flag = false //yield每次循环通过都会经过这个。
      i
    }
    for (i <- 0.until(keep.length)) {
      ints(i) = ints(keep(i)) //覆写操作
    }
    ints.trimEnd(ints.length - keep.length)
    ints.toArray
  }

  //1.第一种实现方式，使用filter过滤实现。
  def fun1(as: Int*): Array[Int] = {
    val arrays: Array[Int] = Array(as: _*)
    var flag = true
    val ints: Array[Int] = arrays.filter((n) => {
      if (n > 0) {
        true
      } else if (flag) {
        flag = false
        true
      } else {
        false
      }
    })
    ints
  }

}