scala基础篇·数组

scala基础篇·数组

object TestArray {
  def main(args: Array[String]): Unit = {
    testArray
    testArrayBuffer
    testYield
    testAlgorithmMethodOfArray
  }

  /**
    * 打印
    *
    * @param t
    * @param v
    */
  def pt(t: String, v: AnyVal): Unit = {
    print(t + ":  ")
    println(v)
  }

  /**
    * 打印
    *
    * @param t
    * @param arr
    */
  def printIntArr(t: String, arr: Int*): Unit = {
    print(t + ":  ")
    for (a <- arr) print(a + "  ")
    println()
  }

  /**
    * 反向打印
    *
    * @param t
    * @param arr
    */
  def printIntArrReverse(t: String, arr: Int*): Unit = {
    print(t + ":  ")
    for (i <- (0 until arr.length).reverse)
      print(arr(i) + "  ")
    println()
  }

  /**
    * 打印
    *
    * @param t
    * @param arr
    */
  def printStrArr(t: String, arr: String*): Unit = {
    print(t + ":  ")
    for (a <- arr) print(a + "  ")
    println()
  }

  /**
    * 定长数组
    */
  def testArray(): Unit = {
    println
    println("-- testArray START --")
    //初始化定长为10的int数组，初始值为0
    val arr1 = new Array[Int](10)
    printIntArr("初始打印整型数组arr1", arr1: _*)

    val arr2 = new Array[String](10)
    printStrArr("初始打印字符串数组arr2", arr2: _*)


    val arr3 = Array(1, 5, 7)
    printIntArr("初始打印整型数组arr3", arr3: _*)

    val arr4 = Array("alice", "bob")
    printStrArr("初始打印字符串数组arr4", arr4: _*)


    arr1(1) = 10
    arr1(9) = 10
    printIntArr("赋值后打印整型数组arr1", arr1: _*)


    arr2(1) = "ellen"
    arr2(9) = "frank"
    printStrArr("赋值后打印字符串数组arr2", arr2: _*)

    println("-- testArray END --")

  }


  /**
    * 变长数组
    */
  def testArrayBuffer(): Unit = {
    println
    println("-- testArrayBuffer START --")

    val buffer = ArrayBuffer[Int]()
    //val buffer = new ArrayBuffer[Int]()

    buffer += 5
    printIntArr("追加一个元素", buffer.toArray[Int]: _*)

    buffer += 4
    printIntArr("再追加一个元素", buffer.toArray[Int]: _*)

    buffer += (6, 7, 10, 5, 4)
    printIntArr("追加多个元素", buffer.toArray[Int]: _*)

    buffer ++= Array(2, 9, 7, 6, 3)
    printIntArr("追加集合", buffer.toArray[Int]: _*)

    buffer.trimEnd(2)
    printIntArr("移除倒数2个元素", buffer.toArray[Int]: _*)

    printIntArr("去重后", buffer.distinct.toArray[Int]: _*)

    buffer.insert(2, 3, 3, 3, 3)
    printIntArr("插入", buffer.toArray[Int]: _*)

    printIntArrReverse("逆向打印", buffer.toArray[Int]: _*)

    println("-- testArrayBuffer END --")


  }

  /**
    * yield测试
    */
  def testYield(): Unit = {
    println
    println("-- testYield START --")

    val arr1 = Array(1, 2, 3, 4)
    printIntArr("arr1各项", arr1: _*)

    val arr2 = for (e <- arr1) yield e * 2
    printIntArr("arr1各项翻倍", arr2: _*)


    val buffer1 = ArrayBuffer[Int](1, 2, 4, 5, 6, 7)
    printIntArr("buffer1各项", buffer1.toArray[Int]: _*)

    val buffer2 = for (e <- buffer1) yield e + 10
    printIntArr("buffer1各项加10", buffer2.toArray[Int]: _*)

    val buffer3 = for (e <- buffer1 if e > 4) yield e + 10
    printIntArr("buffer1大于4的各项加10", buffer3.toArray[Int]: _*)


    /** 移除buffer的负数 */
    val buffer4 = ArrayBuffer(5, -3, -6, -7, 9, 11, -2, -9, 0)
    printIntArr("buffer4各项", buffer4.toArray[Int]: _*)
    //锁定非负数索引
    val buffer5 = for (i <- buffer4.indices if buffer4(i) >= 0) yield i
    printIntArr("buffer5各项,即buffer4非负数的索引", buffer5.toArray[Int]: _*)
    //将非负数向前移动，覆盖负数
    for (i <- buffer5.indices) buffer4(i) = buffer4(buffer5(i))
    buffer4.trimEnd(buffer4.length - buffer5.length)
    printIntArr("buffer4非负数各项", buffer4.toArray[Int]: _*)

    println("-- testYield END --")
  }

  /**
    * 测试Array的算法方法
    */
  def testAlgorithmMethodOfArray(): Unit = {
    println
    println("-- testAlgorithmMethodOfArray START --")
    val arr = Array(3, 8, 6, 7, 1, 4, 2)
    pt("sum", arr.sum)
    pt("max", arr.max)
    pt("min", arr.min)

    printIntArr("arr.head:" , arr.head)
    printIntArr("arr.tail:" , arr.tail:_*)

    printIntArr("arr.takeWhile(value>2)", arr.takeWhile(v => {v > 2}): _*)
    printIntArr("arr.takeWhile(value<4)", arr.takeWhile(v => {v < 4}): _*)

    val arr2 = Array(3, 8, 6, 7, 1, 4, 2)

    scala.util.Sorting.quickSort(arr2)
    printIntArr("快排arr2", arr2: _*)

    val buffer = ArrayBuffer[Int](3, 8, 6, 7, 1, 4, 2)
    val s1 = buffer.sorted
    val s2 = buffer.sortWith(_ < _)
    val s3 = buffer.sortWith(_ > _)
    val s4 = buffer.sortWith((x, y) => {
      x > y
    })

    println(s1.mkString("sorted  =>  [", ",", "]"))
    println(s2.mkString("sortWith(_ < _)  =>  [", ",", "]"))
    println(s3.mkString("sortWith(_ > _)  =>  [", ",", "]"))
    println(s4.mkString("sortWith((x, y) => {x > y})  =>  [", ",", "]"))


    println("-- testAlgorithmMethodOfArray END --")
  }
}

运行结果:

-- testArray START --
初始打印整型数组arr1:  0  0  0  0  0  0  0  0  0  0  
初始打印字符串数组arr2:  null  null  null  null  null  null  null  null  null  null  
初始打印整型数组arr3:  1  5  7  
初始打印字符串数组arr4:  alice  bob  
赋值后打印整型数组arr1:  0  10  0  0  0  0  0  0  0  10  
赋值后打印字符串数组arr2:  null  ellen  null  null  null  null  null  null  null  frank  
-- testArray END --

-- testArrayBuffer START --
追加一个元素:  5  
再追加一个元素:  5  4  
追加多个元素:  5  4  6  7  10  5  4  
追加集合:  5  4  6  7  10  5  4  2  9  7  6  3  
移除倒数2个元素:  5  4  6  7  10  5  4  2  9  7  
去重后:  5  4  6  7  10  2  9  
插入:  5  4  3  3  3  3  6  7  10  5  4  2  9  7  
逆向打印:  7  9  2  4  5  10  7  6  3  3  3  3  4  5  
-- testArrayBuffer END --

-- testYield START --
arr1各项:  1  2  3  4  
arr1各项翻倍:  2  4  6  8  
buffer1各项:  1  2  4  5  6  7  
buffer1各项加10:  11  12  14  15  16  17  
buffer1大于4的各项加10:  15  16  17  
buffer4各项:  5  -3  -6  -7  9  11  -2  -9  0  
buffer5各项,即buffer4非负数的索引:  0  4  5  8  
buffer4非负数各项:  5  9  11  0  
-- testYield END --

-- testAlgorithmMethodOfArray START --
sum:  31
max:  8
min:  1
arr.head::  3  
arr.tail::  8  6  7  1  4  2  
arr.takeWhile(value>2):  3  8  6  7  
arr.takeWhile(value<4):  3  
快排arr2:  1  2  3  4  6  7  8  
sorted  =>  [1,2,3,4,6,7,8]
sortWith(_ < _)  =>  [1,2,3,4,6,7,8]
sortWith(_ > _)  =>  [8,7,6,4,3,2,1]
sortWith((x, y) => {x > y})  =>  [8,7,6,4,3,2,1]
-- testAlgorithmMethodOfArray END --