《scala函数式编程》之for推导和Map操作

package com.lyzx.scalaLearn

import scala.collection.mutable.ArrayBuffer

class Day04 {

  /**
    * 对于for推到和守护的高级用法
    */
  def f1(): Unit ={
      val arr = Array(1,2,3,4,-7,8,9,-10,-11,-12,34,55)
      var isFirst = true

      //把arr集合中的第一个负数和全部的正数保留下来
    /**
      *对于守护(过滤条件)的理解:
      * 通过for推到每次遍历arr集合中的一个元素,首先看满足不满足守护的条件如果满足就传到yield后面的{}中做处理
      * 如果不满足守护的条件则进行下一次的迭代
      */
      val newArr = for(v <- arr if isFirst || v > 0) yield { if(v < 0) isFirst = false;v}
      for(v <- newArr){
        println(v)
      }

      //把前N个负数和所有正数选择出来
      val N:Int = 3
      var index = 0
      val newArr2 = for(i <- 0 until  arr.length if(index <= N-1 || arr(i) > 0)) yield {if (arr(i) < 0){index += 1};if(arr(i) > 0 || index <= N) arr(i)}
      for(v <- newArr2){
        println(">>:"+v)
      }
  }

  def f2(): Unit ={
    val arr = Array(1,6,5,4,3,88,99,77)
    val sum = arr.sum
    val min = arr.min
    val max = arr.max
    println("sum:"+sum+" min:"+min+" max:"+max)

    val ab = ArrayBuffer(1,6,4,99)
    for(v <- ab.sorted)
      println(v)
  }

  def f3(): Unit ={
    import  scala.util.Sorting.quickSort
     val arr = Array(1,2,3,6,5,4)
     //快速排序,这个方法没有返回值,这是一个带有副作用的方法,直接对数组做操作
     quickSort(arr)

    //把数组转换为字符串
     val str1 = arr.mkString(",")
     println(str1)

     val str2 = arr.mkString("<",",",">")
     println(str2)
  }


  def f4(): Unit ={
    //这是一个不可变的映射 scala.collection.immutable.Map$Map3
    var m1 = Map("one"->1,"two"->2,"three"->3)
    m1 += ("ten"->10)
    m1.keys.foreach(x=>println(m1.get(x).getOrElse(0)))

    var m2 = scala.collection.mutable.Map("four"->4,"five"->5)
    //获取某个键对应的值
    println(m2("five"))
    m2 += ("six"->6)
    //修改一个值
    m2("six")=66

    //去掉一个值
    m2 -= "five"
    println(m2.mkString("#"))
  }


  /**
    * 对于Map的迭代和翻转
    */
  def f5(): Unit ={
    val m1 = scala.collection.mutable.HashMap("one"->1,"two"->2)
    for((k,v) <- m1)  println(":"+k+"  "+v)

    for(v <- m1.values) println("::"+v)

    for(k <- m1.keys) println(":::"+m1.get(k).getOrElse(0))

    for(k <- m1.keySet) println("::::"+m1.getOrElse(k,0))

    //可以通过这种方式翻转一个map
    val reverseMap = for((k,v) <- m1) yield (v,k)
    for((k,v) <- reverseMap) println(k+"-"+v)
  }


  //排序的Map
  def f6(): Unit ={
    val sortMap = scala.collection.immutable.SortedMap("D"->4,"C"->3,"A"->1,"B"->2)
    for((k,v) <- sortMap){
       println(k+"-"+v)
    }

    val properties = System.getProperties
    println(properties.getClass.getName)
  }

  def f7(): Unit ={
    //字符串的partition方法把满足条件的和不满足条件的分为两组返回一个元组
    val ss = "A bc D ef".partition(_.isUpper)
    println(ss._1+"--"+ss._2)

    val arr1 = Array("one","two","three","four")
    val arr2 = Array(1,2,3,4,5)

    //通过zip方法可以把两个数组前前N项两两组合为一个对偶并放入数组
    val arr3 = arr1.zip(arr2)
    for((k,v) <- arr3){
      println(k+"="+v)
    }

  }


}

object Day04{

  def main(args: Array[String]): Unit = {
    val t = new Day04
//    t.f1()
//    t.f2()
//    t.f3()
//    t.f4()
//    t.f5()
//    t.f6()
    t.f7()


  }
}