Scala学习——集合的使用和“_”的一些使用（中）

1、空格加_可以表示函数的原型

命令行代码：

scala> def fun1(name:String){println(name)}
fun1: (name: String)Unit

scala> val f = fun1 _
f: String => Unit = $$Lambda$1095/23837627@ae3764

scala> f("spark")
spark

2、其他_的使用

 package com.dtspark.scala.basics
 /**
  * 1,在Scala的集合体系中Iterable是共同的trait，Iterable要求继承者实现一些共同的方法，例如对元素的遍历
  * 2，Array是一个非常基础的数据结构，不从属于Scala集合的体系；
  * 3，Scala的集合体系中集合分为可变集合和不可变集合
  * 不可变的集合在Scala.collection.immutable包中，
  * 可变的集合在Scala.collection.mutable包中
  * 4,list是元素的列表集合，是不可变的
  * 第一点，list中的head是指第一个元素，tail是指剩下的元素构成的list集合
  * 第二点，使用::这个操作符来把list和其他的元素进行组拼来构建新的List
  * 第三点,如果集合中没有元素的话，此时为Nil；如果list中只有一个元素，那么head就是这个元素本身，tail操作就会放回Nil
  * 5，LinkedList是元素可变的列表
  * 6,set是元素不可重复的集合，且元素是无序的,hashSet中的元素不可变，不可重复，不能保证顺序
  * 7，LinkedHashSet维护元素的插入顺序
  * 8,sortedSet是排序的集合
  * 9,"_"在map中的使用
  * 10,map与flatMap的区别
  */
 object Functional_Iterable {
   def main(args: Array[String]): Unit = {
      val range = 1 to 10
      val list = List(1,2,3,4,5)
      println(list.head)
      println(list.tail)//tail是指剩下的元素构成的list集合
      println(0::list)//把0加在list前

      var linkedList=scala.collection.mutable.LinkedList(1,2,3,4,5)
      println(linkedList.elem)//取第一个元素
      println(linkedList.tail)

      while(linkedList!=Nil){
        println(linkedList.elem)
        linkedList=linkedList.tail
      }

      println(linkedList)
      val copied = linkedList.+:(9)
      println(copied)
      val set =Set(1,2,3,5,4)
      println(set)

      val setMore =set+1//还是原来的set，因为元素不能重复
      println(setMore)

      val hashSet = scala.collection.mutable.HashSet(1,2,3)//hashSet中的元素不可变，不可重复，不能保证顺序
      hashSet+=5
      hashSet+=50
      println("hashSet:"+hashSet)

      val linkedHashSet = scala.collection.mutable.LinkedHashSet(1,2,3)//LinkedHashSet维护元素的插入顺序
      linkedHashSet+=5
      linkedHashSet+=50
      linkedHashSet+=4
      println(linkedHashSet)

      val sortedSet=scala.collection.mutable.SortedSet(1,2,3,5,56,4)//自动排序
      println(sortedSet)
      println(List("He is into Spark","Scala is powerful").map { x => x.split(" ")})//一个对象返回一个列表
      //.map{}.flatten 等于 .flatMap
      /**
       *Spark 中 map函数会对每一条输入进行指定的操作，然后为每一条输入返回一个对象
       *而flatMap函数则是两个操作的集合——正是“先映射后扁平化”
       *操作1：同map函数一样：对每一条输入进行指定的操作，然后为每一条输入返回一个对象
       *操作2：最后将所有对象合并为一个对象
       */
      println(List("He ","spark").map { x => x.split(" ")}.flatten)
      println(List("He is into Spark","Scala is powerful").flatMap { x => x.split(" ")}.map { x => (x,1) }.map(x=>x._2).reduce((x,y)=>x+y))
      println(List("He is into Spark","Scala is powerful").flatMap { _.split(" ")}.map { (_,1) }.map(x=>x._2).reduce(_+_))
      println(List("He is into Spark","Scala is powerful").flatMap { x => x.split(" ")}.map { x => (x,1) }.map(_._2).reduce(_+_))
      println(List("He is into Spark","Scala is powerful").flatMap { x => x.split(" ")}.map { x => (x,1) }.map(x=>x._2).reduce(_+_))

      //"_"占位符操作，当=>后面只有一个元素时，可以省略x=>和后面的x，用"_"来表示；    x => x.split(" ")可变成_.split(" ")
      List(0,1,2,3).foreach { x => println(x) }
      List(0,1,2,3).foreach {  println(_) }
      List(0,1,2,3).foreach {  println _ }
      List(0,1,2,3).foreach {  println }
      List(0,1,2,3).foreach (println)

   }
 }