Scala数组

在scala中的数组和JAVA中的数组都是定长的，一旦初始化就不可改变（Scala数据底层是直接变成JAVA的数组）

Array

定义即初始化，并分配空间

//声明类型和长度 
val arr = new Array[Int](10)
arr: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

//直接使用构造函数构建(调用apply函数) 
val arr1 = Array("123", 1)
arr1: Array[Any] = Array(123, 1)

ArrayBuffer(JAVA无):由ArrayList实现？

相似于JAVA中的ArrayList(ArrayList数组实现，每次中间插入删除慢，而LinkedList[火车]由对象实现，查找慢)，变长数组

1.定义

import scala.collection.mutable.ArrayBuffer

var arrBuf = ArrayBuffer[Int]()
arrB: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

2.写入

// 尾部追加 += **奇葩语法又来了**,其实就是定义了+=函数
arrBuf += 1
arrBuf += (1,2,3,4,5,6)

//追加整个数组
arrBuf ++= Array(1,2,3)

//源码
def +=:(elem: A): this.type = {
def ++=:(xs: TraversableOnce[A]): this.type = {

//指定位置追加(index,args: _*)
arrBuf.insert(3,args)

3.删除

//尾部删除,删除指定长的元素
arrBuf.trimEnd(3)

//指定位置删除(index,lenth)
arrBuf.remove(2)
arrBuf.remove(2,3)

Array和ArrayBuffer转换

B.toArray()
A.toBuffer()

数组遍历

• arr[]
• arrBuf()

1.加强for循环

for (e <- arrBuf){
    println(e)
}

2.for until（无上界限）

//for (i <- arrBuf.indices){            //新API

//全遍历（从0开始）
for (i <- 0 until arrBuf.length){
  println(arrBuf(i))
}

//基数遍历（从0开始）
for (i <- 0 until (arrBuf.length,2)){
  println(arrBuf(i))
}

//偶数遍历（从1开始）
for (i <- 1 until (arrBuf.length,2)){
  println(arrBuf(i))
}

//逆序(新API)
for (i <- arrBuf.indices.reverse){
  println(arrBuf(i))
}

常见操做

//求和
arr.sum

//最大，最小
arr.max
arr.min

//克隆
arr.clone()

//排序
util.Sorting.quickSort(arr)

//mkstring(组装字符串)
arr.mkString                //res0: String = 56783456
arr.mkString(",")           //res1: String = 5,6,7,83,4,5,6
arr.mkString("<",",",">")   //res2: String = <5,6,7,83,4,5,6>

//toString
arr.toString                //res0: String = [I@6f8cf218

//hashCode
arr.hashCode()              //res0: Int = 1556830203

使用yield和函数式编程实现数组转换

yield转换

//转换后类型与原类型相同，原值不变
for (a <- arr) yield a*a

//增减if守护过滤
for (a <- arr if a%2 == 0) yield a*a

函数式编程

//使用filter做为过滤器
arr.filter(_ % 2 == 0).map(_ * 2)       // _表示占位符，第一个表示Array里的每个元素，第二个表示过滤后的一个元素

//能够将()变成{}，不经常使用
arr.filter{_ % 2 == 0}.map{_ * 2}

算法实战

import scala.collection.mutable.ArrayBuffer

/*
删除第一个负数以后的负数
 */
var arr = ArrayBuffer[Int](1, 2, 3, 4, -1, -2, -4, 5)
var foundFirstNegative = false
var index = 0
var arr_length = arr.length

////不能够用for由于删了就少了，就会出现之后的几遍就不能比较了
//for (i <- arr.indices) {
//  if (arr(i) > 0) {

/*
//低效率版,remove频繁移动数组，当数组全是负数时，复杂度为O((n+n^2)/2)
while (index < arr_length) {
  if (arr(index) > 0) {
    index += 1
  } else {
    if (foundFirstNegative) {
      arr.remove(index)
      arr_length -= 1
    } else {
      foundFirstNegative = true
      index += 1
    }
  }
}
arr.mkString
*/

//高效率版，把留下的index作标志，一次性删除其余的，最坏的状况，复杂度为O(n)
//这里的if守卫，刚开始的时候都能放行，当找到第一个负数以后就把别的负数拦在门外了
val keepIndexArr = for (i <- arr.indices if !foundFirstNegative || arr(i) >= 0) yield {
  if (arr(i) < 0) {
    foundFirstNegative = true
  }
  i
}
//先装
for (i <- keepIndexArr.indices) {
  arr(i) = arr(keepIndexArr(i))
}
//后删
arr.trimEnd(arr_length - keepIndexArr.length)
print(arr.mkString)