scala学习笔记08_集合操作

scala学习笔记08_集合操作

1. 前置操作符、中置操作符、后置操作符

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//前置操作符
  }

2. 高级函数

/**
 * 高阶函数，参数为函数,一般情况下用于多步骤运算
 * 跟数学中二阶极限类似
 */
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. 集合操作

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函数

/**
 * final def map[B](f: (A) ⇒ B): List[B]
Permalink
[use case]
Builds a new collection by applying a function to all elements of this list.

B:the element type of the returned collection.

f:the function to apply to each element.

returns:a new list resulting from applying the given function f to each element of this list and collecting the results.

 将list的int元素补零后存到新的list
 */
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

/**
 * def
flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Map[B]
[use case] Builds a new collection by applying a function to all elements of this map and using the elements of the resulting collections.
 */
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
   }

}

3. 4 Fold

/**
 * reduce()——规约操作，包含reduceLeft()和reduceRight()两种操作。

fold()——折叠操作，包含foldLeft()和foldRight()两种操作。

两者功能相似，不同之处在于：

fold()操作需要从一个初始值开始，并以该值作为上下文，处理集合中的每个元素。
————————————————
版权声明：本文为优快云博主「不想当小白」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/qq_38813668/article/details/89738550
 */
object FoldDemo {
  def main(args: Array[String]): Unit = {
    val ints = List(1, 2, 3);

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

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


    /**
     * foldLeft和foldRight 缩写方法分别是：/:和:\
     */

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

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

3. 5 iterator 迭代器

/**
 * 迭代器，与java类似
 */
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)
    }
  }

}

3. 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
  }
}

3. 7 Scan

object ScanDemo {
  /**
   * 扫描，即对某个集合的所有元素做fold操作，但是会把产生的所有中间结果放置于一个集合中保存
   * @param args
   */
  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

  }
}

3. 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)
  }
}

3. 9 Zip 合并

/**
 * 将两个list 合并为一个元组
 */
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. Stream

4.1 创建

/**
 * 流是一个惰性列表。它仅在需要时评估元素。这是scala的功能。 Scala支持延迟计算。它可以提高程序的性能。
 *
 *  #::   Construct a stream consisting of a given first element followed by elements
 *  from a lazily evaluated Stream.
 */
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

  /*
   * map :
   * Returns the stream resulting from applying the given function `f` to each
   * element of this stream.  This returns a lazy `Stream` such that it does not
   * need to be fully realized.
   */
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. 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
  }

}