scala的set和map、Tuple元组、函数式编程

使用set和map

1. set内容
   Scala 中创建集的方法与创建列表和数组的类似：通过调用 Set 伴生对象的名为 apply 的工厂方法
   向集合中添加新的变量，使用 + 方法，可变集将把元素加入自身，不可变集将创建并返回一个包含了添加元素的新集

   1）可变集举例：

    var setDemo = Set("Beijing", "Shanghai",1,2,1)	//创建一个可变的集
    println(setDemo)
    setDemo += "Tianjin"							//添加一个数据元素
    println(setDemo)
    println(setDemo.contains("Chongqing")) 		//查看集合中是否包含Chongqing
    
    输出结果:
    Set(Shanghai, 1, Beijing, 2)
    Set(Shanghai, 1, Beijing, 2, Tianjin)
    false
   

   由结果可知：Set集合中不能有重复的元素，重复元素指定剔除，乱序方式输出结果
   2）不可变集举例：
   使用不可变集需要手动引入 import scala.collection.mutable.Set

   import scala.collection.mutable.Set 
   val setDemo = Set("Beijing", "Shanghai",1,2,1)
       println(setDemo)
       setDemo += "Tianjin"   		//等同于 setDemo.+=("Tianjin")
       println(setDemo)
   

   3）想要显式的集合类，只要引用你需要的类，并使用它伴生对象的工厂方法即可。例如：

   import scala.collection.immutable.HashSet
       val hashSet = HashSet("hello", "world")
       println(hashSet + "namesBai")
   输出结果:
       Set(world, namesBai, hello)
   

2. map内容
   Map也分为可变集合和不可变集合两种

   val map =Map(1 -> "zhang" ,2 -> "san",3 -> "pang" )  // ->前面是key，后面是值
   	println(map(2))                                 //输出 map中 key=2的值
   val map1 = map + (5 -> "新数据")                   //添加 key=5 的新数据，产生一个新的 map1
   	println(map1)
       println(map1(5))
   val map2 = map1 - 5                              //删除 map1 中 key值等于5的值
       println(map2)
   

Tuple元组

元组也是不可变的，但与列表不同， 元组可以包含不同类型的元素。
举例：

 val pair = (50, "nihao")		//创建元组
    println(pair._1)			//访问_1字段，第一个元素数据
    println(pair._2)
输出结果:
    50
    nihao

元组的实际类型取决于它含有的元素数量和这些元素的类型。因此，(50, “nihao”) 的类型是Tuple2[Int, String]
注意：
1）_N 数字是基于 1 的，而不是基于 0 ，_N可以返回不同结果类型
2） tuple可以设置多个值，不是无限的，最多22个
3）两个值它的类型就是Tuple2，三个值它的类型就是Tuple3，最多到Tuple22

函数式编程

1.函数式编程的特点
函数式编程核心价值在于多核并行编程
1） 参数私有，没有线程安全问题，为分布式高并发提供了支持
2） 把函数做为参数
3） 把函数的返回值作为参数

注意：在scala中所有都是基于函数的，两者语义上区别很小，在类中定义的函数即是方法。
方法是组成类的一部分，函数则是一个完整的对象。val 语句可以定义函数，def 语句定义方法

2.格式：(参数：类型):返回值类型 => { 表达式； 表达式... }
函数可以被赋值给其他变量或常量，可以作为参数传递，也可以作为返回值

object TestFunction {
       def add(a:Int,b:Int) = { a+b }          		 //定义对象的方法
       def main(args: Array[String]): Unit = {
            val fnadd = (a:Int,b:Int) => { a+b } 	 //定义函数
            println(fnadd(10,20))
       }
}

3.函数式集合的foreach

集合遍历举例：
val list = List(1,2,3,4,5)
list.foreach { x => println(x) }

//源码说明：
  @inline final override def foreach[U](f: A => U) {  //f是一个函数，A、U都是泛型
    var these = this
    while (!these.isEmpty) {
      f(these.head)								 //.head获取到头元素也就是第一个元素
      these = these.tail						 //.tail获取到除第一元素后的所有元素
    }
  }

4. 案例 java和Scala之间的对比
   定义一个数字集合，按照奇偶数分成两个集合

//java实现代码:
List<Integer> list = new ArrayList<Integer>();
   	list.add(1); list.add(2); list.add(3); list.add(4); list.add(5);
List<Integer> a = new ArrayList<Integer>();
List<Integer> b = new ArrayList<Integer>();
    for(Integer n: list){
        if(n%2 == 0){
            a.add(n);
        }else{
            b.add(n);
        }
    }

//scala实现:
object list {
        def main(args: Array[String]): Unit = {
        //按奇偶数将集合划分为两个
        val f2 = (n:Int) => {n%2 != 0}       //函数遇到奇数返回true，偶数返回false
        val array = Array(1,2,3,4,5).toList  //初始化数组
        println(array.partition(f2))	     // 按照分f2结果进行 partition分区
        
        //还可以简写为
        println(array.partition((n:Int) => {n%2 != 0}))
        }
}

//输出结果:(List(1, 3, 5),List(2, 4))

函数式编程把代码写在一个一个小的函数中，想办法把业务化成一块一块的内容，组合起来完成一个业务。