Scala笔记整理（六）：Scala集合库

[TOC]

长乐网站建设公司创新互联公司,长乐网站设计制作，有大型网站制作公司丰富经验。已为长乐上1000+提供企业网站建设服务。企业网站搭建\成都外贸网站制作要多少钱，请找那个售后服务好的长乐做网站的公司定做！

Scala主要集合结构

1、Scala中的集合体系主要包括：Iterable、Seq（IndexSeq）、Set（SortedSet）、Map（SortedMap）。其中Iterable是所有集合trait的根trait。实际上Seq、Set、和Map都是子trait

Seq
是一个有先后次序的值的序列，比如数组或列表。IndexSeq允许我们通过×××的下表快速的访问任意元素。举例来说，ArrayBuffer是带下标的，但是链表不是。
Set
是一组没有先后次序的值。在SortedSet中，元素以某种排过序顺序被访问。
Map
是一组（键、值）对偶。SortedMap按照键的排序访问其中的实体。

2、 Scala中的集合是分成可变和不可变两类集合的，其中可变集合就是说，集合的元素可以动态修改，而不可变集合的元素在初始化之后，就无法修改了。分别对应scala.collection.mutable和scala.collection.immutable两个包。

3、Seq下包含了Range、ArrayBuffer、List等子trait。其中Range就代表了一个序列，通常可以使用“1 to10”这种语法来产生一个Range。 ArrayBuffer就类似于Java中的ArrayList。

List

List常用操作1

1、在Scala中，列表要么是Nil（及空表），要么是一个head元素加上一个tail，而tail又是一个列表

scala> val list = List(1, 2, 3, 4, 5)
list: List[Int] = List(1, 2, 3, 4, 5)

scala> list.head
res29: Int = 1

scala> list.tail
res30: List[Int] = List(2, 3, 4, 5)

scala> list.isEmpty
res31: Boolean = false

scala> list == Nil
res32: Boolean = false

下面是一个使用递归求list集合中和的例子：

def recursion(list:List[Int]):Int = {
    if(list.isEmpty) {
        return 0  // 使用return显式结束程序的运行，否则0只是该if语句的返回值，并不会结束程序的运行，当然如果用else不用return也行
    }
    list.head + recursion(list.tail)
}

List常用操作2

增加

//增
/*  A.++(B)  --> 在列表A的尾部对添加另外一个列表B,组成一个新的列表
 *  A.++:(B) --> 在列表A的首部对添加另外一个列表B,组成一个新的列表
 *  A.:::(B) --> 在列表A的首部对添加另外一个列表B,组成一个新的列表
 *  ------
 *  A.:+ (element) -->在列表A的尾部添加一个element，组成一个新的集合
 *  A.+: (element) -->在列表A的首部添加一个element，组成一个新的集合
 *  A.:: (element) -->在列表A的首部添加一个element，组成一个新的集合
 */

测试如下：

scala> val left = List(1, 2, 3, 4)
left: List[Int] = List(1, 2, 3, 4)

scala> val right = List(5, 6, 7)
right: List[Int] = List(5, 6, 7)

scala> left.++(right)
res33: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

scala> left.++:(right)
res34: List[Int] = List(5, 6, 7, 1, 2, 3, 4)

scala> left.:::(right)
res35: List[Int] = List(5, 6, 7, 1, 2, 3, 4)

scala> left.:+(10)
res36: List[Int] = List(1, 2, 3, 4, 10)

scala> left.+:(10)
res38: List[Int] = List(10, 1, 2, 3, 4)

scala> left.::(10)
res39: List[Int] = List(10, 1, 2, 3, 4)

删除

drop(n)         --->删除list的前n个元素(首部开始删除)
dropRight(n)    --->删除list的后n个元素(尾部开始删除)
dropWhile(p: A => Boolean)  --->逐个匹配去除符合条件的元素，直到不符合条件，之后的元素不再判断

测试如下：

scala> val list = List(1, 2, 3, 4, 5, 6, 7)
list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

scala> list.drop(2)
res52: List[Int] = List(3, 4, 5, 6, 7)

scala> list.dropRight(3)
res53: List[Int] = List(1, 2, 3, 4)

scala> list.dropWhile(_ <= 3)
res54: List[Int] = List(4, 5, 6, 7)

scala> list.dropWhile(_ > 3)    // 第一个元素就不符合条件，后面的不再判断，所以一个也没有删除
res55: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

修改与查询

scala> val list = List(1, 2, 3, 4, 5, 6, 7)
list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

scala> list(0)
res57: Int = 1

scala> list(0) = 10
:9: error: value update is not a member of List[Int]
              list(0) = 10
              ^

默认的List是在：

scala> List
res59: scala.collection.immutable.List.type = scala.collection.immutable.List$@3e98fd35

所以不能修改，但是尝试导入可修改的List也不能进行导入：

scala> import scala.collection.mutable.List
:8: error: object List is not a member of package scala.collection.mutable
       import scala.collection.mutable.List

原因如下：

Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：
列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是。

List常用操作3

scala> val list = List(1, 2, 3, 4, 5, 6, 7)
list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

scala> list.take(5)
res60: List[Int] = List(1, 2, 3, 4, 5)

scala> list.takeWhile(_ <= 3)
res61: List[Int] = List(1, 2, 3)

scala> list.takeWhile(_ > 3)
res62: List[Int] = List()

scala> list.mkString
res63: String = 1234567

scala> list.count(_ % 2 == 0)
res64: Int = 3

scala> val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))  // ::操作符从给定的头和尾部创建一个新的列表
fruit: List[String] = List(apples, oranges, pears)

scala> val list1 = List(1, 2, 3)
list1: List[Int] = List(1, 2, 3)

scala> val list2 = List(4, 5, 6)
list2: List[Int] = List(4, 5, 6)

scala> list1 ++ list2   // ++两个集合之间的操作
res70: List[Int] = List(1, 2, 3, 4, 5, 6)

scala> list1.sum
res72: Int = 6

Set

1、数据集是不重复元素的集合。尝试将已有元素加入进来是没有效果的。比如

def setOps:Unit ={
    (Set(2,0,1) + 1).foreach(println(_))
}

2、Set不保留元素插入的顺序。缺省情况下，集是以哈希集实现的，其元素根据hashCode方法的值进行组织。

Set(1,2,3,5,7,8).foreach(println(_))

3、链式哈希集可以记住元素被插入的顺序。它会维护一个链表来达到这个目的。

val weeks= scala.collection.mutable.LinkedHashSet("Mo","Tu","We","Th","Fr")
weeks.foreach(println(_))

4、按照已排序的顺序来访问其中的元素

scala.collection.immutable.SortedSet(1,2,3,4,5,6).foreach(println(_))

set集合顺序说明

直接看下面的测试代码及注释：

package cn.xpleaf.bigdata.p4.collection

import scala.collection.mutable.SortedSet

object _02CollectionOps {
  def main(args: Array[String]): Unit = {
    setOps1
  }

  /**
    * 关于scala集合顺序的说明
    *     测试1：按照年龄进行升序，年龄相等，姓名降序
    *     测试2：要按照姓名升序比较，按照年龄升序比较
    * SortedSet在添加普通对象Person之类，报错
    *   No implicit Ordering defined for Person
    *   要想在有序集合中添加元素，必须要让元素具备比较性，要和给集合提供比较器
    *   在java中前者是要类实现Comparator，后者需要给集合提供一个比较器Comparator
    *   在scala中，前者需要让类扩展Ordered的特质，后者给集合传递一个Ordering比较器
    *
    *   当两个比较都实现的话，优先使用集合的比较器
    */
  def setOps1: Unit = {
    var set = SortedSet[Person]()(new Ordering[Person] {
      override def compare(x: Person, y: Person):Int = {
        var ret = x.getName.compareTo(y.getName)
        if(ret == 0) {
          ret = x.getAge.compareTo((y.getAge))
        }
        ret
      }
    })
    set.+= (new Person("王立鹏", 19))
    set.+= (new Person("冯 剑", 18))
    set.+= (new Person("刘银鹏", 15))
    set.+= (new Person("李小小", 19))
    // println(set)
    set.foreach(println(_))
  }
}

class Person extends Ordered[Person] {
  private var name:String = _

  private var age:Int = _

  def this(name:String, age:Int) {
    this()
    this.name = name
    this.age = age
  }

  def getAge = age

  def getName = name

  override def toString: String = {
    s"[$name, $age]"
  }

  /**
    * 按照年龄进行升序，年龄相等，姓名降序
    * 升序：前面比后面
    * 降序：后面比前面
    */
  override def compare(that: Person) = {
    var ret = this.age.compareTo(that.age)
    if(ret == 0) {
      ret = that.name.compareTo(this.name)
    }
    ret
  }
}

输出结果如下：

[冯 剑, 18]
[刘银鹏, 15]
[李小小, 19]
[王立鹏, 19]

集合的函数式编程

1、集合的函数式编程非常之重要，这是我们以后工作中每天都在使用的编程方式。

2、必须完全掌握和理解Scala的高阶函数是什么意思，Scala的集合类的map、flatMap、reduce、reduceLeft、foreach等这些函数，就是高阶函数，因为可以接收其他函数作为参数（部分高阶函数可以参考前面整理的函数式编程笔记）

3、高阶函数的使用，也是Scala与Java最大的一点不同！！！因为Java在1.8之前是没有函数式编程的，也肯定没有高阶函数，也肯定无法直接将函数传入一个方法，或者让一个方法返回一个函数

4、对Scala高阶函数的理解、掌握和使用，可以大大增强你的技术，而且也是Scala最有诱惑力、最有优势的一个功能。

5、在Spark源码中，有大量的函数式编程，所以必须掌握，才能看懂spark源码。

foreach方法可以将某个函数应用到集合中的每个元素并产生结果的集合

scala> val names = List("Peter","Paul","Mary")
names: List[String] = List(Peter, Paul, Mary)

scala>  names.map(_.toUpperCase).foreach(println(_))
PETER
PAUL
MARY

Map函数每个后面都加上一个==》

scala> List("Peter","Paul","Mary").map(_ + "===>name").foreach(println(_))
Peter===>name
Paul===>name
Mary===>name

Flatmap按照空格进行划分

scala> List("Peter Glad","Paul Hello","Mary Your").flatMap(_.split(" ")).foreach(println)
Peter
Glad
Paul
Hello
Mary
Your

当前文章：Scala笔记整理（六）：Scala集合库
当前链接：http://chengdu.cdxwcx.cn/article/ieccio.html

甜橘子，专注成都网站制作网站设计与营销型网站建设与优化

首页

网站建设

网站制作案例

解决方案

网站设计报价

网站制作动态

关于我们

联系我们

成都网站建设设计将想法与焦点和您一起共享

Scala笔记整理（六）：Scala集合库

Scala主要集合结构

List

List常用操作1

List常用操作2

增加

删除

修改与查询

List常用操作3

Set

set集合顺序说明

集合的函数式编程

其他资讯

android密码管理安卓好用的密码管理器

linux启动侦听命令 linux启动监听命令

抖音小程序发布成功抖音发小程序流量会高吗

百度小程序下线百度小程序中心怎么关闭?

贴吧ios开发贴吧开放平台

甜橘子，专注成都网站制作网站设计与营销型网站建设与优化

成都网站建设设计 将想法与焦点和您一起共享

Scala笔记整理（六）：Scala集合库

Scala主要集合结构

List

List常用操作1

List常用操作2

增加

删除

修改与查询

List常用操作3

Set

set集合顺序说明

集合的函数式编程

其他资讯

android密码管理 安卓好用的密码管理器

linux启动侦听命令 linux启动监听命令

抖音小程序发布成功 抖音发小程序流量会高吗

百度小程序下线 百度小程序中心怎么关闭?

贴吧ios开发 贴吧开放平台

成都网站建设设计将想法与焦点和您一起共享

android密码管理安卓好用的密码管理器

抖音小程序发布成功抖音发小程序流量会高吗

百度小程序下线百度小程序中心怎么关闭?

贴吧ios开发贴吧开放平台