做网站的有什么软件/梧州网站seo

一、前言：

人们常说，Scala是一个难掌握的语言，一是其面向函数和面向对象结合的原因，二是其丰富的语法和内置函数。

对于Conllection 这一章的内容，更多的是利用内置函数灵活地运用，避免自己重复造轮子（要求性能高除外）

对于集合，通常来说有以下几个常用操作是必须掌握的：

1.增删改查单个元素

2.单个集合的各种遍历方式

3.单个集合分拆组合与翻转

4.两个集合的拼接，删除等操作

ps(因为在官方文档中List是immutable的，所以对数组的所谓增上改查都是产生新的对象，并非在原来的集合上改动)

A class for immutable linked lists representing ordered collections of elements of type.

二、增删改查单个元素

2-1 源码

<span style="font-family: Arial, Helvetica, sans-serif;"></span><pre name="code" class="java">object ListBaseOps extends App {  /*** 1.增删改查单个元素*/val list = List("scala","spark","hadoop")println("test"::list) // 增 (返回新对象，源对象不变)println(list(0))      //取println(list apply 0) //取  （同上） // list(3) ="hadoop1";// 改  error （不能修改imutable的集合）println(list .updated(2,"hadoop1"))  //it worksprintln(list.last)    //取最后一个元素 }  

2-2 结果

List(test, scala, spark, hadoop)
scala
scala
List(scala, spark, hadoop1)
hadoop

二、单个集合的各种遍历方式

2-1例子

object Test6 extends App() {/*** 单个集合的各种遍历方式*/val lst = List(1,2,3,4,5);print("foreach遍历：")lst.foreach { x => print(x+",")}  //foreach遍历,这个是传统遍历，新手不熟无奈之下可以用它println("")var temp = lst.map { x => x+1 }   //遍历，与foreach的区别是返回值为List【B】println("map遍历："+temp.mkString(","));var temp1 = lst.reduceLeft((sum,i)=>sum +i) //遍历，返回值类型是一个与集合相同的Intprintln("reduce遍历返回Int："+temp1);var temp2 = lst.foldLeft(List[Int]())((x,y)=>y::x); //遍历,返回值是自定义类型//ps fold类函数还可以改成 ：\ ，/:的形式，代码精简了不少，但是可读性却减低了例如println("foldLeft遍历返回自定义类型："+temp2.mkString(","));var temp3=(   List[Int]() /: lst){(m,c)=>c::m} //遍历，实现反转println("foldLeft遍历实现反转："+temp2.mkString(","));}

2-1结果

foreach遍历：1,2,3,4,5,
map遍历：2,3,4,5,6
reduce遍历返回Int：15
foldLeft遍历返回自定义类型：5,4,3,2,1
foldLeft遍历实现反转：5,4,3,2,1

三、 单个集合分拆组合与翻转

3-1源码例子

object Test7 extends App() {/*** 单个集合的拆分组合与反转*/val list = List(1,2,3,4,5);//除了最后一个元素之外的所有元素  （用法有点怪）println(list.init+"----init除了最后一个元素之外的所有元素")//除了第一个元素之外的所有元素  （用法有点怪）println(list.tail+"----tail除了第一个元素之外的所有元素")//生成迭代对象，注意区分initprintln(list.inits+"----inits生成迭代对象，注意区分init")val data = List('a','b','c','d','e')  //取前n个元素 var take = data take 2 println(take.mkString(",")+"-----take取前n个元素 ")  //除去前n个元素  var drop = data drop 2println(drop.mkString(",")+"-----drop除去前n个元素 ") //返回元素的索引  println(data.indices+"----indices返回元素的索引  ")  //索引和数据组合长Tuplevar t = data.indices zip dataprintln(t.mkString +"----zip索引和数据组合长Tuple")  //数据和索引组合  println(data.zipWithIndex+"----zipWithIndex数据和索引组合")//grouped 分组  println(data.grouped(2).mkString(",")+"-----grouped分组");
}

3-2 结果

List(1, 2, 3, 4)----init除了最后一个元素之外的所有元素
List(2, 3, 4, 5)----tail除了第一个元素之外的所有元素
non-empty iterator----inits生成迭代对象，注意区分init
a,b-----take取前n个元素 
c,d,e-----drop除去前n个元素 
Range(0, 1, 2, 3, 4)----indices返回元素的索引  
(0,a)(1,b)(2,c)(3,d)(4,e)----zip索引和数据组合长Tuple
List((a,0), (b,1), (c,2), (d,3), (e,4))----zipWithIndex数据和索引组合
List(a, b),List(c, d),List(e)-----grouped分组

四、 两个集合的拼接，删除等操作

4-1源码：

object Test8 extends App() {/*** 集合间的链接交互*/val left = List(1,2,3)val right = List(4,5,6)//以下操作等价println(left ++ right)   // List(1,2,3,4,5,6)println(left ++: right)  // List(1,2,3,4,5,6)println(right.++:(left))    // List(1,2,3,4,5,6)println(right.:::(left))  // List(1,2,3,4,5,6)//以下操作等价println(0 +: left)    //List(0,1,2,3)println(left.+:(0))   //List(0,1,2,3)//以下操作等价println(left :+ 4 )   //List(1,2,3,4)println(left.:+(4) )  //List(1,2,3,4)//以下操作等价println(0 :: left )     //List(0,1,2,3)println(left.::(0) )    //List(0,1,2,3)}

4-2 总结：

++ ++[B](that: GenTraversableOnce[B]): List[B] 从列表的尾部添加另外一个列表

++: ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[List[A], B, That]): That 在列表的头部添加一个列表

+: +:(elem: A): List[A] 在列表的头部添加一个元素

:+ :+(elem: A): List[A] 在列表的尾部添加一个元素

:: ::(x: A): List[A] 在列表的头部添加一个元素

::: :::(prefix: List[A]): List[A] 在列表的头部添加另外一个列表

:\ :[B](z: B)(op: (A, B) ⇒ B): B 与foldRight等价

看到这里大家应该跟我一样有一点晕吧，怎么这么多奇怪的操作符，这里给大家一个提示，任何以冒号结果的操作符，都是右绑定的，即 0 :: List(1,2,3) = List(1,2,3).::(0) = List(0,1,2,3) 从这里可以看出操作::其实是右边List的操作符，而非左边Int类型的操作符