学习scala的那五天__第二天

学习scala的那五天__第一天
http://www.aboutyun.com/forum.php?mod=viewthread&tid=22957
(出处: about云开发)

第一天的作业答案会在后面楼层发布

2数组、映射、元组、集合     2.1数组
   2.1.1定长数组和变长数组
    //初始化一个长度为8的定长数组，其所有元素均为0

        val arr1 = new Array[Int](8)

        //直接打印定长数组，内容为数组的hashcode值

        println(arr1)

        //将数组转换成数组缓冲，就可以看到原数组中的内容了

        //toBuffer会将数组转换长数组缓冲
        println(arr1.toBuffer)

         //注意：如果不new，相当于调用了数组的apply方法，直接为数组赋值
        //初始化一个长度为1的定长数组
        val arr2 = Array[Int](10)
         println(arr2.toBuffer)

         //定义一个长度为3的定长数组
        val arr3 = Array("hadoop", "storm", "spark")
         //使用()来访问元素
        println(arr3(2))

         //////////////////////////////////////////////////
        //变长数组（数组缓冲）
        //如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
        val ab = ArrayBuffer[Int]()
         //向数组缓冲的尾部追加一个元素
        //+=尾部追加元素
        ab += 1
         //追加多个元素
        ab += (2, 3, 4, 5)
         //追加一个数组++=
        ab ++= Array(6, 7)
         //追加一个数组缓冲
        ab ++= ArrayBuffer(8,9)
         //打印数组缓冲ab

        //在数组某个位置插入元素用insert
        ab.insert(0, -1, 0)
         //删除数组某个位置的元素用remove
        ab.remove(8, 2)
         println(ab)

   2.1.2遍历数组

   1.增强for循环

         2.好用的until会生成脚标，0 until 10 包含0不包含10

                    //初始化一个数组

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

                   //增强for循环
                   for(i <- arr)
                     println(i)

                   //好用的until会生成一个Range
                   //reverse是将前面生成的Range反转
                   for(i <- (0 until arr.length).reverse)
                     println(arr(i))

   2.1.3数组转换

   yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

      

                 //定义一个数组

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

                 //将偶数取出乘以10后再生成一个新的数组

                 val res = for (e <- arr if e % 2 == 0) yield e * 10

                 println(res.toBuffer)

                 //更高级的写法,用着更爽

                //filter是过滤，接收一个返回值为boolean的函数

                 //map相当于将数组中的每一个元素取出来，应用传进去的函数

               val r = arr.filter(_ % 2 == 0).map(_ * 10)
                println(r.toBuffer)

   2.1.3数组常用算法

      在Scala中，数组上的某些方法对数组进行相应的操作非常方便！

      

  2.2映射
           2.2.1构建映射
           2.2.2获取和修改映射中的值
           
           好用的getOrElse
           
           注意：在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变

           例子：

           

           注意：通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内 容是不是可变，取决于这个引用指向的集合的类型

  2.3元组

    映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值。

           2.3.1创建元组

           

创建元组

           2.3.2获取元组中的值

           

获取元组中的值

           2.3.3将对偶的集合转换成映射

           

将对偶的集合转换成映射

           2.3.4拉链操作

           

拉链操作

    zip命令可以将多个值绑定在一起

    注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数  

   篇幅原因放在下面了

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云开发)

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

有编辑按钮

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

看到咯,正在搞,谢谢了

[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]