scala编程(其四)集合(list set),lazy变量

集合：是一种框架 提供了一些数据结构来收集指定的类型数据！
     1,提供了一些高阶操作 如map filter reduce
     2,有着可变与不可变的集合类型层次体系,可以方便的在不可变类型(稳定性)与可变类型(必要时)之间进行转换
列表的说明:
      1,List是一种不可变的单链表
      2,list可以创建任何一个集合 包括 元组与map

package day01
object Test4 {
  def main(args: Array[String]): Unit = {
      //scala 的集合有三大类   Seq(序列),Set(集),Map(映射)
    //list 不可变
    val list=List(1,2,3)
    val list1=0::list //list 追加  0在最前面
    val list2=0+:list //同上
    val list3=list:+0 //list 追加 0在最后
    val list4=list1++list3 //两个list进行合并 生成新的list
    val list5=list1++:list3 //两个list合并 结果同上
    val list6=list1 ::: list3 //两个list合并 结果同上

    //不可变序列 也具有不可变的方法！ ::: :+ ++
    import scala.collection.mutable.ListBuffer
    val list7=ListBuffer(1,2,3)
    list7+=4  //追加 4
    list7.append(5) //追加5
    val list8 =ListBuffer(6,7,8)
    val list9 =(list7 ++ list8) //list 合并 生成新的list 不是追加
  }
}

set 的说明:
  1,set包含可变与不可变,只不过可变不可变是通过类的继承差别来进行实现的

package day01

object Test5 {
  def main(args: Array[String]): Unit = {
    val set0 = Set(2,3,4)  //此时的 set 是不可变的
    println(set0)
    import scala.collection.mutable.Set //可变集合
    val set1 = Set(1,2,3)
    val set2 = set1+=4 //追加 4
    val set5 =set1 ++ Set(45)  //生成新的set
    val set4 = set1 & set5 //查看交集
    set1.add(12)  //追加12
    set1.remove(12) //移除 12
    val set3 = set1 ++ Set(1,11,5) //两个set进行合并
  }
}

lazy:惰性加载
  1,scala 之中使用 lazy 进行定义的变量是惰性变量，会延时加载
  2,惰性变量只能是不可变的变量 ,只有调用惰性变量的时候，才会实例化变量！

package day01

object lazya{
  def init()={
    println("这是init 方法！")
  }
  def main(args: Array[String]): Unit = {
    val pre = init() //调用init 方法！
    println("after init !")

    lazy val pre1 =init() //使用 lazy进行修饰！
    println("after init !")
    println(pre1) //调用 lazy变量,此时才执行 init() 方法！
  }
}

 scala 常用方法集合

package day01

//静态类
object Test6 {
  def main(args: Array[String]): Unit = {

    val li0 = List(1, 2, 3, 4, 5, 7, 6)
    val list1 = li0.map(_ * 2) //所有的元素*2 赋值到 新的list
    println(list1)
    println(li0.filter(_ % 2 == 0)) // filter 过滤操作！

    val list3 = li0.sorted  //正向排序
    println(list3)

    val list4 = list3.reverse  //反转降序排列
    println(list4)

    val it = li0.grouped(4) //分组！
    val list6 = it.toBuffer //转换成 buffer类型！
    val list5 = list6.toList //buffer 转换成 list类型
    println(list5)
    val list7 = list5.flatten  //多个list 压扁成一个list
    println(list7)

    val lines = List("A Q","B Z","c d","C E")
    // 按照空格进行切割
//    val world = lines.map(_.split(" "))
//    println(world.flatten)  //将 所有单词进行压平!
    println(lines.flatMap(_.split(" "))) //与上两行相同的输出！

    val arr = Array(1,2,3,4,5,6,7,8,9,10)
    println(arr.sum)  // 按部就班的求和
    // 并行计算和空闲线程有关 ,每个线程计算一部分，然后进行汇总！
    val res = arr.par.sum  //并行求和
    println(res)
    // ((1+2)+3)+4 ........
    val res = arr.reduce(_+_) //累加 前一个_是1 后一个2 一次累加
    println(arr.par.reduce(_-_)) // 并行累减
  }
}

scala 用例 按照降序统计列表次数

package day01
object Test9 {
  def main(args: Array[String]): Unit = {
      val lines = List("1 a","2 b","3 c","4 d")
//      进行压平成list
      val words = lines.flatMap(_.split(" "))
      val tuples = words.map((_,1)) //元组
      // groupBy 每一个 tuple 按照 _1分组组成 map ,然后操作map的值
      val sum = tuples.groupBy(_._1).mapValues(_.size)
//    sum.toList     //相当于 List里面包含 k,v 组成的元组
    val all = sum.toList.sortBy(_._2) //升序排列
    println(all.reverse) // 进行反转！
    println(all)
  }
}

 

转载于:https://www.cnblogs.com/shi-qi/articles/10465947.html