[mw_shl_code=scala,true]//第一天的练习答案

    //创建一个List
    val list0 = List(3,4,6,2,1,7,8,9,5)


    //将list0中每个元素乘以2后生成一个新的集合
//    val f1 = (x: Int) => x * 2
//    val res = list0.map(f1)
//    val res = list0.map(_ * 2)


    //将list0的偶数取出来生成一个新的集合
//    val res = list0.filter(_ % 2 == 0)


    //将list0排序后生成一个新的集合
//    val res = list0.sorted


    //反转排序顺序
//    val res = list0.sorted.reverse


    //将list0中的元素4个一组,类型为Iterator[List[Int]]
    val grouped: Iterator[List[Int]] = list0.grouped(4)


    //将Iterator转换成List
//    val res = grouped.toList


    //将多个list压扁成一个List
    val list2 = List(List(1,2,3), List(4,5,6), List(7,8,9))

//    val res = list2.flatten

    //先按空格切分，再压平
    val list3 = List("hello java", "hello scala hello", "hello php", "hello python")

//    val res = list3.map(_.split(" ")).flatten
    val res = list3.flatMap(_.split(" "))


    println(res)




val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    // 求和
    //    val res = arr.sum

    //并行计算求和
    // (1+2+3+4)+(5+6+7)+(8+9+10)
    //    val res = arr.par.sum

    // reduce进行聚合
    //    val res = arr.reduce((x, y) => x + y)
    //    val res = arr.reduce(_ + _)
    //    val res = arr.reduceLeft(_ + _) // ((1+2)+3)+4 ...

    // reduce进行聚合（按照非特定顺序）,并行聚合
    //    val res = arr.par.reduce(_+_)

    // 例外
    //    val res = arr.par.reduceLeft(_+_) // ((1+2)+3)+4 ...
    //    val res = arr.par.reduceRight(_+_) // ((10+9)+8)+7 ...

    // 并行求差
    //    val res = arr.reduce(_-_)
    //    val res = arr.par.reduce(_-_)


    //折叠：有初始值（有特定顺序）
    //    val res = arr.fold(0)(_+_)
    //    val res = arr.fold(10)(_+_)


    //折叠：有初始值（无特定顺序）
    //    val res = arr.par.fold(0)(_+_)
    // 例如三个线程执行任务：(10+1+2+3+4)+(10+5+6+7)+(10+8+9+10)
    //    val res = arr.par.fold(10)(_+_)
    //    val res = arr.par.fold(10)(_-_)


    //聚合

    val list1 = List(List(1, 2, 3), List(3, 4, 5), List(2), List(0))

    //    val res = list1.flatten.reduce(_+_)
    //    val res = list1.flatten.fold(0)(_ + _)
    //    val res = list1.aggregate(0)(_+_.sum, _+_) // 内部其实还是调用的foldLeft（有特定顺序聚合）
    //    val res = list1.par.aggregate(10)(_+_.sum, _+_)


    // 聚合,需求：结果为有个元组，元组里的第一个值是arr1的总和，第二个值是有多少个数参与聚合运算,(数组聚合的值，数组的长度)
    val arr1 = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

//    val res = arr1.aggregate((0, 0))(
//      (acc, num) => (acc._1 + num, acc._2 + 1),
//      (par1, par2) => (par1._1 + par2._1, par1._2 + par2._2)
//    )


    val l1 = List(5, 6, 4, 7)
    val l2 = List(1, 2, 3, 4)

    //求并集
//    val res = l1 union l2


    //求交集
//    val res = l1 intersect l2


    //求差集
//    val res = l1.diff(l2)
//    val res = l2.diff(l1)


//    println(res)[/mw_shl_code]

pig2 发表于 2017-10-20 20:16
有编辑按钮

看到咯,正在搞,谢谢了

ABCDer丶Bi 发表于 2017-10-20 19:55
噗...还没整理好,一个回车就出去了

有编辑按钮

2.4集合

   Scala的集合有三大类：序列Seq、集合Set、映射Map，所有的集合都扩展自Iterable特质

    在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区 别）

          2.4.1序列Seq
    不可变的序列 import scala.collection.immutable._

    在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。

    9 :: List(5, 2)  :: 操作符是将给定的头和尾创建一个新的列表

    注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

    //创建一个不可变的集合

       val lst1 = List(1,2,3)

       //将0插入到lst1的前面生成一个新的List

       val lst2 = 0 :: lst1

       val lst3 = lst1.::(0)

       val lst4 = 0 +: lst1

       val lst5 = lst1.+:(0)

     //将一个元素添加到lst1的后面产生一个新的集合

      val lst6 = lst1 :+ 3

       val lst0 = List(4,5,6)

       //将2个list合并成一个新的List

       val lst7 = lst1 ++ lst0

       //将lst0插入到lst1前面生成一个新的集合

       val lst8 = lst1 ++: lst0

       //将lst0插入到lst1前面生成一个新的集合

       val lst9 = lst1.:::(lst0)

       println(lst9)

    可变的序列 import scala.collection.mutable._

    //构建一个可变列表，初始有3个元素1,2,3

     val lst0 = ListBuffer[Int](1,2,3)

   //创建一个空的可变列表

   val lst1 = new ListBuffer[Int]

     //向lst1中追加元素，注意：没有生成新的集合

   lst1 += 4

     lst1.append(5)

     //将lst1中的元素追加到lst0中， 注意：没有生成新的集合

     lst0 ++= lst1

   //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合

   val lst2= lst0 ++ lst1

     //将元素追加到lst0的后面生成一个新的集合

   val lst3 = lst0 :+ 5

          2.4.2集合Set
    不可变的Set
     val set1 = new HashSet[Int]()

    //将元素和set1合并生成一个新的set，原有set不变

    val set2 = set1 + 4

      //set中元素不能重复

    val set3 = set1 ++ Set(5, 6, 7)

      val set0 = Set(1,3,4) ++ set1

    println(set0.getClass)

           可变的Set

   //创建一个可变的HashSet

   val set1 = new mutable.HashSet[Int]()

   //向HashSet中添加元素

  set1 += 2

  //add等价于+=

  set1.add(4)

  set1 ++= Set(1,3,5)

  println(set1)

//删除一个元素

  set1 -= 5

  set1.remove(2)

  println(set1)

      2.4.3映射Map                       val map1 = new mutable.HashMap[String, Int]()

           //向map中添加数据

           map1("spark") = 1

           map1 += (("hadoop", 2))

           map1.put("storm", 3)

           println(map1)

           //从map中移除元素

           map1 -= "spark"

           map1.remove("hadoop")

           println(map1)

好吧,今天也就到这里了,被自己的排版折服




补充内容 (2017-10-21 09:30):
由于之前不是很会用这些东西,没有来得及审查,排版问题以及文字中间出现的错误,希望大家看的时候推敲一下,深表歉意.

补充内容 (2017-10-21 15:09):
学习scala的那五天__第二天缺失版
http://www.aboutyun.com/forum.php?mod=viewthread&tid=22961
(出处: about云开发)