《scala函数式编程》之循环和数组的运用

package com.lyzx.scalaLearn

import scala.collection.mutable.ArrayBuffer

class Day0302 {


  //在高级for循环中可以定义任意多个变量
  def f1(): Unit ={
    for(i <- 1 to 3;from =4-i ;j <- 1 to from)
      println("i="+i+",j="+j)

    val s = "abcd"
    val s2 = (for(c <- s) yield (c+1).toChar).toString
    println("s2:"+s2)
  }

  //如果for循环中以yield开头则会返回一个Vector集合这个叫for的推导式
  def f2(): Unit ={
    val arr = Array("A","B","C")
    val vv = for(v <- arr) yield v.toLowerCase
    for(v <- vv)  println("-"+v)
  }

  //带有默认值的方法
  def f3(middle:String,left:String="[",right:String="]"): String ={
    left+middle+right
  }

  def sum(args:Int*):Int ={
    println(">>>"+args.getClass.getName)
    var sum:Int = 0
    for(v <- args) sum += v
    sum
  }

  /**
    * 没有返回值/或者说返回值类型是Unit的函数叫过程
    * 我们使用过程的目的是为了它的副作用
    */
  def f4 (): Unit ={
    //可以使用lazy来申明一个变量
    lazy val x = scala.io.Source.fromFile("scalaQ")

  }

  //scala的异常处理机制
  def f5(): Unit ={
    try{
      val x = 1/0
    }catch {
      case ex:ArithmeticException =>ex.printStackTrace()
      case _ :IndexOutOfBoundsException=>println("数组下标")
    }
  }

  //ArrayBuffer是长度可变的数组类似于java中的ArrayList
  def f6(): Unit ={
    val ab = new ArrayBuffer[Int]()

    //在后面添加一个元素
    ab += 1

    //在后面添加多个元素
    ab += (2,4,6,8)

    //把一个数组中的元素(引用)添加到其后面，可以使用++=追加任何集合
    //其实在缓冲数组后面添加或者移除元素是一个高效的操作
    ab ++= Array(99,88)

    ab ++= List(100)

    //剪切后面的3个元素
    ab trimEnd(3)

    //在索引为2的位置插入999这个元素，当然后面元素都要平移
    ab.insert(2,999)

    //可以插入多个元素
    ab.insert(2,111,222,333)

    //删除索引为2的元素
    ab.remove(2)

    //从索引为2的位置开始,向后删除2位
    ab.remove(2,2)
    for(v <- ab){
      println(v)
    }
  }


  //对于数组和缓冲数组的遍历(其方法时一样的)
  def f7(): Unit ={
    val ab = new ArrayBuffer[Int]()
    ab ++= Array(10,9,8,7,6,5)

    //通过下标访问每一个索引
    for(i <- 1 until  ab.length){
      println(ab(i))
    }

    //类似于增强的for循环
    for(v <- ab){
      println(">>"+v)
    }
  }


  //对 to的是使用
  def f8(): Unit ={
    for(i <- 1 to (10,2)){
      println(i)
    }

    for(v <- (1 to 10).reverse){
      print(v+"-")
    }
  }

  //对(缓冲)数组做转换
  //通过对yield 对数组做转换 数组转换后还是数组  缓冲数组准换后得到的是缓冲数组
  def f9(): Unit ={
    val arr = Array(1,2,3,4,5,6,7,8,9,10)
    //可以通过守护过滤部分数据
    val vv = for(v <- arr if(v % 3 == 0)) yield v+1
    for(v <- vv){
      print(v+" ")
    }

    println()
    for(v <- arr if(v % 2 == 0)){
      print(v+" = ")
    }
  }

  //上述功能的另一种做法,只是会新产生一个数组,原数组没有影响
  def f10(): Unit = {
    val arr = Array(1,2,3,4,5,6,7,8,9,10)
    val a2 = arr.filter(_ % 3 == 0)
                .map(_ +1)
    for(v <- a2){
      println(v)
    }
  }
}

object Day0302{
  def main (args:Array[String]): Unit = {
    val t = new Day0302
//    t.f1()
//    t.f2()
//    println(t.f3("123","<"))

//    val sum = t.sum(1,2,3,4,5,6,7,8,9,10)
//    println("sum="+sum)
//
//    //可以通过在元组后面追加:_*
//    println(t.sum(1 to 5:_*))
//    t.f5
//    t.f6
//  t.f7()
//    t.f8()
//    t.f9()
    t.f10()

  }

}