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

 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)

   }

 }