scala的几个小程序

import java.util.function.BiConsumer

import scala.io.Source
import scala.util.Random

/**
  * Created by fhqplzj on 16-7-16 at 上午10:47.
  */
object Hammock {
  val sep = Array.fill(50)('*').mkString
  var count = 0

  def separate: Unit = {
    println()
    count += 1
    println(s"${sep}example $count$sep")
    println()
  }

  def main(args: Array[String]): Unit = {
    /**
      * 过滤所有的偶数
      */
    separate
    println((1 to 10).filter(_ % 2 == 0).mkString(" "))

    /**
      * 对序列中所有元素求和
      */
    separate
    println((1 to 10).reduce(_ + _))
    println((1 to 10).fold(0)(_ + _))
    println((1 to 10).sum)

    /**
      * 统计单词出现次数
      */
    separate
    val s = "hello world hello spark hello hadoop welcome to spark".split(" ")
    println(s.groupBy(x => x).mapValues(_.length))

    /**
      * 将单词首字母大写
      */
    separate
    println(s.map(_.capitalize).mkString("\t"))

    /**
      * 最大值，最小值，求和
      */
    separate
    val list = List(2, 7, 1, 0, 5, 4)
    println(list.max)
    println(list.min)
    println(list.sum)

    /**
      * 读取文件
      */
    separate
    val path = "/home/fhqplzj/temp/BeHappy/module2/src/main/scala/Hammock.scala"
    Source.fromFile(path).getLines().toList.take(10).foreach(println)

    /**
      * 并行计算
      */
    separate
    println((1 to 100).par.sum)

    /**
      * 两个List求点积
      */
    separate
    val list1 = List.tabulate(10)(i => Random.nextInt(20))
    val list2 = List.tabulate(10)(i => Random.nextInt(20))
    println("list1 = " + list1)
    println("list2 = " + list2)
    val dotSum = (list1, list2).zipped.map(_ * _).sum
    println("dotSum = " + dotSum)

    /**
      * 读取环境变量
      */
    separate
    System.getenv().forEach(new BiConsumer[String, String] {
      override def accept(t: String, u: String): Unit = println(s"key=$t,value=$u")
    })

    /**
      * 计算2到1000的所有素数
      */
    separate
    def sieve(xs: List[Int]): List[Int] = xs match {
      case Nil => Nil
      case x :: xs1 => List(x) ::: sieve(xs1.filter(_ % x != 0))
    }
    val nums = (2 to 1000).toList
    val primes = sieve(nums)
    println("primes = " + primes)

    /**
      * 快速排序
      */
    separate
    def qsort[T](xs: List[T])(implicit ord: Ordering[T]): List[T] = xs match {
      case Nil => Nil
      case x :: xs1 =>
        val (left, right) = xs1.partition(ord.lt(_, x))
        qsort(left)(ord) ::: List(x) ::: qsort(right)(ord)
    }
    println("list1 = " + list1)

    /**
      * 升序
      */
    println(qsort(list1))

    /**
      * 降序
      */
    println(qsort(list1)(Ordering.Int.reverse))
  }
}