scala学习笔记08

object ExpressDemo {
  def main(args: Array[String]): Unit = {
    val n1 = 1
    val n2 = 2
    val r1 = n1 - n2   //中置操作符相当于操作符是方法名，可以直接省略点调用
    val r2 = n1.-(n2) //看Int的源码即可说明
    println("r1=" + r1 + " r2=" + r2)


    val op = new Opreate
    println(op+++)//后置操作符
    !op//前置操作符
  }

object HigherOrderFunction {

  def main(args: Array[String]): Unit = {

    val finalResult = step2(step1, 5)
    println(finalResult)
  }

  def step1(originalParam:Int):Int = {
    println("compute step1")
    originalParam*originalParam

  }

  def step2(f: Int => Int, originalParam: Int): Int ={
    println("compute step2")
    val step1Result = step1(originalParam)
    step1Result*step1Result

  }
}

3.1 过滤函数 Filer

object FilerDemo {

  def main(args: Array[String]): Unit = {

    val score = List(33, 44, 55, 66, 99, 100)
    val passedScore = score.filter(isPassed)
    println(passedScore)
  }

  def isPassed(score:Int):Boolean={
    score>60
  }
}

3.2 Map函数

object MapDemo {
  def main(args: Array[String]): Unit = {

    val ints = List(2, 4, 666)

    val strings = ints.map(f1)
    println(strings)


  }
//左边补零
  def f1(int:Int): String ={
     f"$int%3d".replaceAll(" ", "0")
  }

}

3.3 FlatMap

object FlatMapDemo {

  def main(args: Array[String]): Unit = {
    val ints = List("abc")
    val chars = ints.flatMap(f2);
    println(chars)


  }

  def f2(orginalChar:String):String = {
    orginalChar.toUpperCase
   }

}

4 Fold

object FoldDemo {
  def main(args: Array[String]): Unit = {
    val ints = List(1, 2, 3);

    println(ints.fold(111)(_-_))

    println(ints.fold(6)(sumF));


    

    var sumVar = (100 /:ints)(sumF)
    println(sumVar)
  }

  def sumF( num1 : Int, num2 : Int ): Int = {
    println("num1 "+num1)
    println("num2 "+num2)
    num1 + num2
  }
}

5 iterator 迭代器

object IteratorDemo {
  def main(args: Array[String]): Unit = {
    val ints = List(1, 2, 3)
    val iterator = ints.iterator
    while(iterator.hasNext){
      val item = iterator.next()
      println(item)
    }
    println(iterator.hasNext)//已经迭代过了，需要重新获取一个
    val iterator1 = ints.iterator
    for(item<-iterator1){
      println(item)
    }
  }

}

6 Reduce

object ReduceDemo {
  def main(args: Array[String]): Unit = {

    //reduceLeft与reduceRight结果相同
    val words = List("I","love","you");
    val sentence = words.reduceLeft(appendF); 0
    println(sentence)

    val sentence2 = words.reduceRight(appendF);
    println(sentence2)

    //reduceLeft与reduceRight结果不同
    val ints = List(101, 202, 3, 666);
    println(ints.reduceLeft(subtraction));
    println(ints.reduceRight(subtraction));
  }
  def appendF(word:String,word2:String):String = {
    word+" "+word2
  }

  def subtraction(number1:Int,number2:Int):Int={
        number1-number2
  }
}

7 Scan

object ScanDemo {
  
  def main(args: Array[String]): Unit = {
    val ints = List(2, 4, 666)
    val resultInts = ints.scan(5)(sumFunction)
    println(resultInts)  //List(5, 7, 11, 677)
  }

  def sumFunction(num1:Int,num2:Int): Int ={
    num1+num2

  }
}

8 Parallel 并行化

object ParallelDemo {
  def main(args: Array[String]): Unit = {
   (1 to 5).foreach(showItemAndThread(_))   //main
    (1 to 5).par.foreach(
      showItemAndThread(_)   //ForkJoinPool

    )

   }

  def showItemAndThread(i:Int):Unit={
    println(i)
    println(Thread.currentThread.getName)
  }
}

9 Zip 合并

object ZipDemo {
  def main(args: Array[String]): Unit = {
    val code = List("010", "021", "020")
    val citys = List("beijing", "shanghai", "guangzhou")
    val tuples = code.zip(citys)
    println(tuples)
  }
}

4.1 创建

object MainObject{
  def main(args:Array[String]){
    var stream = 100 #:: 200 #:: 85 #:: Stream.empty
    println(stream)
    var stream2 = (1 to 10).toStream
    println(stream2)
    var firstElement = stream2.head
    println(firstElement)
    println(stream2.take(10))
    println(stream.map{_*2})
  }
}

4.2 关于tail

object StreamTail {
  def main(args: Array[String]): Unit = {
    //创建Stream
    def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)  //死递归，但是Stream是懒加载
    val stream1 = numsForm(1)
    println(stream1) //Stream(1, ?)
    //取出第一个元素
    println("head=" + stream1.head) //1
    println(stream1.tail) //Stream(2, ?)

    println(stream1) //Stream(1, 2, ?)
    println(stream1.tail.tail) //Stream(3, ?)
    println(stream1) //Stream(1, 2, 3, ?)

  }
}

4.3 map

  
object StreamDemo3 {
  def main(args: Array[String]): Unit = {
    //创建Stream
    def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)


    def multi(x:BigInt) : BigInt = {
      x * x
    }
    var stream3 = numsForm(5)
    stream3.tail
    println(stream3) //Stream(5, 6, ?)
    println(stream3.map(multi)) // Stream(25, ?)
    println(stream3.tail.map(multi)) //Stream(36, ?)

  }
}

4 view 实现懒加载

object StreamDemo4 {
  def main(args: Array[String]): Unit = {

    val stream = numberToStream(5)
    println(stream)
    val stream2 = stream.map(multi)
    println(stream2)

    val ints = numberToStream(5).map(multi)
    println(ints)

    //Stream的懒加载特性，也可以对其他集合应用view方法来得到类似的效果
    val viewDemo = (1 to 10).view

    println(viewDemo.iterator.next())
    println(viewDemo)

  }

  def numberToStream(n:Int):Stream[Int]={
    n #:: numberToStream(n+1)
  }

  def multi(x:Int) : Int = {
    x * x
  }

}