频道栏目
首页 > 网络 > 云计算 > 正文

Scala集合操作—List

2016-10-12 09:17:23           
收藏   我要投稿

Scala中列表是非常类似于数组,这意味着,一个列表的所有元素都具有相同的类型,但有两个重要的区别。首先,列表是不可变的,这意味着一个列表的元素可以不被分配来改变(在官方文档中List是immutable的,所以对List的所谓增上改查都是产生新的对象,并非在原来的集合上改动)。第二,列表表示一个链表,而数组平坦的。通常来说有以下几个常用点击打开链接操作是必须掌的:

 

1.增删改查单个元素

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

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

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

  /** 
  * 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 works  
  println(list.last)    //取最后一个元素
运行结果:

 

 

  List(test, scala, spark, hadoop)
  scala
  scala
  List(scala, spark, hadoop1)
  hadoop
  /** 
   * 2.单个集合的各种遍历方式 
   */  
   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) //遍历,返回值类型是一个与集合相同的Int  
    println("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(",")); 
   运行结果:

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.单个集合的拆分组合与反转 
   */  
   val list = List(1,2,3,4,5);  
  //除了最后一个元素之外的所有元素  (用法有点怪)  
   println(list.init+"----init除了最后一个元素之外的所有元素")  
  //除了第一个元素之外的所有元素  (用法有点怪)  
   println(list.tail+"----tail除了第一个元素之外的所有元素")  
   //生成迭代对象,注意区分init  
   println(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 2  
   println(drop.mkString(",")+"-----drop除去前n个元素 ")   
   //返回元素的索引    
   println(data.indices+"----indices返回元素的索引  ")    
   //索引和数据组合长Tuple  
   var t = data.indices zip data  
   println(t.mkString(" ") +"----zip索引和数据组合长Tuple")    
   //数据和索引组合    
   println(data.zipWithIndex+"----zipWithIndex数据和索引组合")  
    //grouped 分组    
   println(data.grouped(2).mkString(",")+"-----grouped分组");  
运行结果:  

 



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.集合间的链接交互 
   */  
  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(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)
运行结果:


List(1, 2, 3, 4, 5, 6) List(1, 2, 3, 4, 5, 6) List(1, 2, 3, 4, 5, 6) List(1, 2, 3, 4, 5, 6) List(4, 5, 6, 1, 2, 3) List(0, 1, 2, 3) List(0, 1, 2, 3) List(1, 2, 3, 4) List(1, 2, 3, 4) List(0, 1, 2, 3) List(0, 1, 2, 3)

 

 

总结:

++ :[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类型的操作符

相关TAG标签 Scala Scala集合 List
上一篇:最大熵模型TheMaximumEntropy
下一篇:用Option[T]来避免NullPointerException
相关文章
图文推荐

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站