scalaのsliding windowの多種の実現とbenchMark

5466 ワード

需要
午後暇なのは小さいコードを書いて1つのsliding windowの効果を実現するために、そして最終的にこれらの要素を平らにします
[3 1 4 1 5 9]
[3,1]
[1,4]
[4,1]
[1,5]
[5,9]
[3,1,1,4,4,1,1,5,5,9]

構想
  • init zip tailを直接使用し、flatMapまたはfoldLeft
  • javaの方法でindexによって
  • を実現する
    コード#コード#
    import java.time.{Duration, Instant}
    
    /**
      * @author todd.chen at 9/23/16 1:33 PM.
      *         email : todd.chen@ximalaya.com
      */
    object Test {
      def main(args: Array[String]): Unit = {
        val list = (1 to 1000000).map(i ⇒ i).toList
        val vectorList = list.toVector
        Thread sleep 5000
    
        (1 to 100).flatMap { i ⇒
          val first = benchMark(testIteratorBySam(list))
          val second = benchMark(testFlatList(list))
          val third = benchMark(testIterator(list))
          val purse = benchMark(testPurseJava(vectorList))
          Map("sam" → first, "list" → second, "iterator" → third, "pures" → purse)
        }.groupBy(_._1).map { case (k, v) ⇒
          k -> v.map(_._2).sum
        }.toSeq.sortBy(_._2).foreach(println)
    
        /*        val x = List(1, 2, 3, 4)
                testPurse(x).foreach(println)*/
    
      }
    
    
      def testPurseJava = (vectorList: Vector[Int]) ⇒ {
        val length = (vectorList.length - 1) * 2
        val result = new Array[Int](length)
        result(0) = vectorList.head
        (1 to vectorList.length - 2).foreach { i ⇒
          val x = vectorList(i)
          result(i * 2) = x
          result(i * 2 - 1) = x
        }
        result(length - 1) = vectorList.last
        result
    
      }
    
      def testFoldLeft = (xs: List[Int]) ⇒ {
        (xs.init zip xs.tail).foldLeft(List.empty[Int]) {
          case (ls, s) ⇒
            ls :+ s._1 :+ s._2
        }
      }
    
    
      def testIteratorBySam = (xs: List[Int]) ⇒ {
        (xs.init zip xs.tail).flatMap { l ⇒
          //l._1 :: l._2 :: Nil
          //l.productIterator
          new Iterator[Int]() {
            var f: Boolean = true
    
            override def hasNext: Boolean = f
    
            override def next(): Int = if (f) {
              f = false
              l._1
            } else {
              l._2
            }
          }
        }
      }
    
      def testFlatList = (xs: List[Int]) ⇒ {
        (xs.init zip xs.tail).flatMap { l ⇒
          l._1 :: l._2 :: Nil
        }
      }
    
      def testIterator = (xs: List[Int]) ⇒ {
        (xs.init zip xs.tail).flatMap { l ⇒
          //      l._1 :: l._2 :: Nil
          l.productIterator
        }
      }
    
      def benchMark(testFunc: ⇒ Traversable[Any]) = {
        val start = Instant.now()
        testFunc
        val end = Instant.now()
        Duration.between(start, end).toNanos
      }
    }
    

    結果
    JAva版の効果はとても良くて、それから私のleader samが与えたので、それから直接productorIteratorを呼び出して、最後にflatMapのlistで、foldLeftの性能はあまりにも悪いです