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)
     
  }
}