//list中的Map中用一个函数表达式-->实则是对list进行操作,_可以表示一个函数或者表达式

        List(1, 2, 3, 4, 6) map (_ + 1)   //> res0: List[Int] = List(2, 3, 4, 5, 7)

    val data = List("Scala", "Hadoop", "Spark")   //> data  : List[String] = List(Scala, Hadoop, Spark)

    //计算List中元素的长度

    data map (_.length)                           //> res1: List[Int] = List(5, 6, 5)

    //把Lis元素转换为list并t倒置后又组成list输出

    data map (_.toList.reverse.mkString)          //> res2: List[String] = List(alacS, poodaH, krapS)

    //把list中元素转换为list

    data.map(_.toList)                            //> res3: List[List[Char]] = List(List(S, c, a, l, a), List(H, a, d, o, o, p), L

    //flatMap把list元素转换为list后，再连接成新的list输出         //| ist(S, p, a, r, k))

    data.flatMap(_.toList)                        //> res4: List[Char] = List(S, c, a, l, a, H, a, d, o, o, p, S, p, a, r, k)

    //range是左臂右开的，[1,10) -->flatMap组成元素

    List.range(1, 10) flatMap (i => List.range(1, i) map (j => (i, j)))

                                                  //> res5: List[(Int, Int)] = List((2,1), (3,1), (3,2), (4,1), (4,2), (4,3), (5,1

                                                  //| ), (5,2), (5,3), (5,4), (6,1), (6,2), (6,3), (6,4), (6,5), (7,1), (7,2), (7,

                                                  //| 3), (7,4), (7,5), (7,6), (8,1), (8,2), (8,3), (8,4), (8,5), (8,6), (8,7), (9

                                                  //| ,1), (9,2), (9,3), (9,4), (9,5), (9,6), (9,7), (9,8))

    var sum = 0                                   //> sum  : Int = 0

    List(1, 2, 3, 4, 5) foreach (sum += _)

    println("sum : " + sum)                       //> sum : 15

    //filter过滤

    println(List(1, 2, 3, 4, 6, 7, 8, 9, 10) filter (_ % 2 ==0))

                                                  //> List(2, 4, 6, 8, 10)

    println(data filter (_.length == 5))          //> List(Scala, Spark)

 //partition按照表达式进行拆分为两个list

    println(List(1, 2, 3, 4, 5) partition (_ % 2 ==0))

                                                  //> (List(2, 4),List(1, 3, 5))

     //find查找list中符合表达式的元素有几个

    println(List(1, 2, 3, 4, 5) find (_ % 2 ==0)) //> Some(2)

    println(List(1, 2, 3, 4, 5) find (_  <=0))    //> None

    //takeWhile表示list满足表示式组成list

    println(List(1, 2, 3, 4, 5) takeWhile (_  < 4))

                                                  //> List(1, 2, 3)

      //dropWhile表示list中满足表达式形成新的list与其相反

    println(List(1, 2, 3, 4, 5) dropWhile (_  < 4))

                                                  //> List(4, 5)

     //span是上面两者的组合

    println(List(1, 2, 3, 4, 5) span (_  < 4))    //> (List(1, 2, 3),List(4, 5))

    //exists表示组成元素是否存在该表达式的元素-->如果有则返回true否则返回false

    def hastotallyZeroRow(m: List[List[Int]]) = m exists (row => row forall (_ == 0))

                                                  //> hastotallyZeroRow: (m: List[List[Int]])Boolean

    val m= List(List(1,0,0), List(0,1,0), List(0,0,1))

                                                  //> m  : List[List[Int]] = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 1))

    println(hastotallyZeroRow(m))                 //> false

  //foldLeft源码中可以看出定义了两个函数进行求和计算
　def /:[B](z: B)(op: (B, A) => B): B = foldLeft(z)(op)

  def :\[B](z: B)(op: (A, B) => B): B = foldRight(z)(op)

  def foldLeft[B](z: B)(op: (B, A) => B): B = {

    var result = z

    this foreach (x => result = op(result, x))

    result

  }

      //两个等价 从零开始相加

    println((1 to 100).foldLeft(0)(_+_) )         //> 5050

    println((0 /: (1 to 100))(_+_))               //> 5050

    //从1到5进行相减

    println((1 to 5).foldRight(100)(_-_))         //> -97

    println(((1 to 5):\100)(_-_))                 //> -97

    //对list进行排序

    println(List(1, -3, 4, 2, 6) sortWith (_ < _))//> List(-3, 1, 2, 4, 6)

  //List.apply()=List()

    println(List(1, 2, 3))                        //> List(1, 2, 3)

    //List.make复制同样的元素

   // List.make(3, 5)

   //range 左闭右开

    println(List.range(1, 5))                     //> List(1, 2, 3, 4)

    //计算间距为-3的元素

    println(List.range(9, 1, -3))                 //> List(9, 6, 3)

    //abcde转换为list后进行组合

    val zipped = "abcde".toList zip List(1, 2, 3, 4, 5)

                                                  //> zipped  : List[(Char, Int)] = List((a,1), (b,2), (c,3), (d,4), (e,5))

    println(zipped)                               //> List((a,1), (b,2), (c,3), (d,4), (e,5))

    //把zipped转换为反向的

    println(zipped.unzip)                         //> (List(a, b, c, d, e),List(1, 2, 3, 4, 5))

    //fatter把list中的list转换为一个list

    println(List(List('a', 'b'), List('c'), List('d', 'e')).flatten)

     //把list组合转换为list                             //> List(a, b, c, d, e)

    println(List.concat(List(), List('b'), List('c')))

                                                  //> List(b, c)

         //map2两个list按照最后一个表达式进行计算

    //println(List.map2(List(10, 20), List(10, 10)) (_ * _))