精华内容
下载资源
问答
  • 数组 / 映射 / 元组 一、数组 1、定长数组 声明数组的两种形式: 声明指定长度的数组 val 数组名= new Array[类型](数组长度)   提供数组初始值的数组,无需new关键字   Scala声明数组时...
    • 数组  /  映射  /  元组

      一、数组

      1、定长数组

      声明数组的两种形式:

      声明指定长度的数组 val 数组名= new Array[类型](数组长度)

        \

      提供数组初始值的数组,无需new关键字

        \

      Scala声明数组时,需要带有Array类名,且使用 () 来指明长度或提供初始值序列。

      在JVM中,Scala的Array以Java数组的方式实现。如arr在JVM中的类型对应java.lang.String[],charArr对应char[]。

      2、变长数组

        \

      ArrayBuffer,全称scala.collection.mutable.ArrayBuffer,类似于Java中的ArrayList和C++中的vector,是长度可变数组类型的结构,称为数组缓冲。

      通过:val 名 = ArrayBuffer[类型]() 来声明,声明ArrayBuffer时需要指明类型。

      通过 += 操作符来添加元素或序列,++= 操作符来拼接数组。

      【在ArrayBuffer的尾端添加或删除元素是一个高效的操作。】 ArrayBuffer还支持在指定位置插入、删除元素。

      ArrayBuffer到数组的转换: toArray方法

        \

      3、数组遍历

      通过for循环来遍历数组

        \

      指定遍历数组的步长——通过until(上界, 步长)

        \

        \

      通过reverse函数逆序遍历数组:

        \

      4、可以通过 for循环+yield 来获得新的数组或ArrayBuffer

        \

        \

      通过for+yield操作数组或ArrayBuffer之后将得到新的数组或ArrayBuffer。

      5、操作数组/数组缓冲常用函数

        \

      求和、求最大最小值、数组排序。通过sorted函数对数组或ArrayBuffer排序时,返回的是一个新的数组或ArrayBuffer,原有的不变。

      可以直接对数组调用排序算法,但是不能对ArrayBuffer排序。

        \

      quickSort是直接修改原数组,而sorted方法是返回新数组

      6、多维数组

      Scala中的多维数组同Java中一样,多维数组都是数组的数组。

      通过 Array.ofDim[类型](维度1, 维度2, 维度3,....)来声明多维数组,如声明二维数组;

        \

        从二维数组的初始化中,我们可以看到,多维数组在Scala中也是数组的数组。

      通过 Array[ Array[Int]](维度1) 来声明数组,可以声明不规则数组;

        \

        多维数组是数组的数组,按照这种性质来声明多维数组,如例子中的二维数组,声明时,需要指定最外围的数组大小。

      【注:可以通过scala.collection.JavaConversions包中隐式转换方法来实现Scala容器类与Java中类的转换。】

      二、映射

      1、映射构造

      对偶,即名值对。可以通过 -> 操作符来定义对偶, 名->值 运算的结果是( 名, 值 ); 

        \

      也可以声明对偶形式的变量

        \

      映射是由对偶构成的,映射是对偶的集合。

      声明不可变映射,直接使用Map来声明时,默认是不可变映射类型。

        \

        【注: 不可变映射维持元素插入顺序。】

      声明可变映射(scala.collection.mutable.Map)

        \

        【注:放入可变映射中的值并未按照放入顺序来排序的。】

        通过for循环来修改可变Map中的值;

        \

        【注:映射可变、不可变指的是整个映射是否可变,包括元素值、映射中元素个数、元素次序等。】

      声明空映射

        直接通过 new Map[类型1, 类型2]() 来定义映射会报错,因为Map是抽象的,无法实例化。

        定义空映射时,需要指定映射的实现类,通过new来定义;

        \

        分别定义不可变映射与可变映射。注,直接使用 new HashMap定义时会报错。

      2、映射常用操作

      判断映射中是否含有某个键: map.contains(键值)

        \

      使用 += 向可变映射中添加元素或拼接映射

        \

      使用 -= 移除可变映射中的键及对应元素

        \

      不可变映射可通过 + 操作符返回一个新的不可变映射;不可变映射可通过 - 操作符返回一个新的不可变映射;

        \

      映射遍历

        \

      获取映射的键集合keySet和值集合

        \

        通过映射的 keySet 方法可以获得映射的由键值构成的集合;通过 values 方法可以获得映射的值集合的Interable对象,应用于循环中。

        Scala的keySet / values 方法类似于Java中的映射方法。

      3、Scala中映射的底层实现要么基于哈希表,要么基于平衡树,其中基于平衡树的映射内部是有序的。

        \

        Scala目前基于平衡树的映射只提供了不可变版本。

        【注:构建可变有序映射可借助Java的TreeMap。】

      4、可变映射中,若穴ky"http://www.it165.net/qq/" target="_blank" class="keylink">qq5ub2ozqyz1tSqy9iy5cjry7PQ8rXE07PJ5L/Jzai5/UxpbmtlZEhhc2hNYXChozwvcD4KPHA+NaGizai5/XNjYWxhLmNvbGxlY3Rpb24uSmF2YUNvbnZlcnNpb25zLm1hcEFzU2NhbGFNYXC/yb2rSmF2YbXETWFw16q7u86qU2NhbGHA4NDNtcRNYXCju82ouf1zY2FsYS5jb2xsZWN0aW9uLkphdmFDb252ZXJzaW9ucy5tYXBBc0phdmFNYXC/yb2rU2NhbGG1xNOzyeTXqru7zqpKYXZhwODQzbXE07PJ5KGjPC9wPgo8cD42oaJ0b01hcLe9t6g8L3A+CjxwPqGhoaHKudPDdG9NYXC3vbeov8m9q7bUxbzX6bPJtcS8r7rP16q7r86q07PJ5KGjPC9wPgo8cD6hoaGhPGltZyBzcmM9"http://www.it165.net/uploadfile/files/2014/0920/20140920190600125.png" alt="\" />

      三、元组

      1、元组是不同类型的值的聚集;对偶是最简单的元组。

      2、元组表示

        通过将不同的值用小括号括起来,即表示元组。

        \

        上例中元组的类型就是 (Int, Double, Char, String) ;元组中可以存放不同类型的值。

      3、元组访问

      元组中的元素称为组元。可以通过 _1、 _2 、_3 的形式来访问对应下标的组元。

        \

        【注:元组中组元下标从1开始。】

      通过模式匹配来访问元组中的值

        \

        忽略不需穴ky"http://www.it165.net/qq/" target="_blank" class="keylink">qq1xNa1PC9zdHJvbmc+oaPU2sSjyr3GpcXkyrGjrM2ouf0gXyCjqM3yxNzGpcXkt/ujqcC0zqqyu9Do0qq78cih1rW1xNfp1KrVvM67o6zDv7j2IF8gvfa/ydLUzqrSu7j21+nUqtW8zruhozwvcD4KPHA+oaGhoTxpbWcgc3JjPQ=="http://www.it165.net/uploadfile/files/2014/0920/20140920190600129.png" alt="\" />

      4、元组可用于函数返回多个值的情形

        

        上例中,函数定义返回值类型为元组 (Int, String);

        

    展开全文
  • 数组 / 映射 / 元组   一、数组 1、定长数组 声明数组的两种形式: 声明指定长度的数组 val 数组名= new Array[类型](数组长度)   提供数组初始值的数组,无需new关键字   Scala声明数组时,...

    数组  /  映射  /  元组

     

    一、数组

    1、定长数组

    声明数组的两种形式:

    • 声明指定长度的数组 val 数组名= new Array[类型](数组长度)

      

    • 提供数组初始值的数组,无需new关键字

      

    Scala声明数组时,需要带有Array类名,且使用 () 来指明长度或提供初始值序列。

    在JVM中,Scala的Array以Java数组的方式实现。如arr在JVM中的类型对应java.lang.String[],charArr对应char[]。

    2、变长数组

      

    ArrayBuffer,全称scala.collection.mutable.ArrayBuffer,类似于Java中的ArrayList和C++中的vector,是长度可变数组类型的结构,称为数组缓冲。

    通过:val 名 = ArrayBuffer[类型]() 来声明,声明ArrayBuffer时需要指明类型。

    通过 += 操作符来添加元素或序列,++= 操作符来拼接数组。

    【在ArrayBuffer的尾端添加或删除元素是一个高效的操作。】 ArrayBuffer还支持在指定位置插入、删除元素。

    ArrayBuffer到数组的转换: toArray方法

      

    3、数组遍历

    通过for循环来遍历数组

      

    指定遍历数组的步长——通过until(上界, 步长)

      

      

    通过reverse函数逆序遍历数组:

      

    4、可以通过 for循环+yield 来获得新的数组或ArrayBuffer

      

      

    通过for+yield操作数组或ArrayBuffer之后将得到新的数组或ArrayBuffer。

    5、操作数组/数组缓冲常用函数

      

    求和、求最大最小值、数组排序。通过sorted函数对数组或ArrayBuffer排序时,返回的是一个新的数组或ArrayBuffer,原有的不变。

    可以直接对数组调用排序算法,但是不能对ArrayBuffer排序。

      

    quickSort是直接修改原数组,而sorted方法是返回新数组

    6、多维数组

    Scala中的多维数组同Java中一样,多维数组都是数组的数组。

    • 通过 Array.ofDim[类型](维度1, 维度2, 维度3,....)来声明多维数组,如声明二维数组;

      

      从二维数组的初始化中,我们可以看到,多维数组在Scala中也是数组的数组。

    • 通过 Array[ Array[Int]](维度1) 来声明数组,可以声明不规则数组;

      

      多维数组是数组的数组,按照这种性质来声明多维数组,如例子中的二维数组,声明时,需要指定最外围的数组大小。

    【注:可以通过scala.collection.JavaConversions包中隐式转换方法来实现Scala容器类与Java中类的转换。】

     

    二、映射

    1、映射构造

    对偶,即名值对。可以通过 -> 操作符来定义对偶, 名->值 运算的结果是( 名, 值 ); 

      

    也可以声明对偶形式的变量

      

    映射是由对偶构成的,映射是对偶的集合。

    • 声明不可变映射,直接使用Map来声明时,默认是不可变映射类型。

      

      【注: 不可变映射维持元素插入顺序。】

    • 声明可变映射(scala.collection.mutable.Map)

      

      【注:放入可变映射中的值并未按照放入顺序来排序的。】

      通过for循环来修改可变Map中的值;

      

      【注:映射可变、不可变指的是整个映射是否可变,包括元素值、映射中元素个数、元素次序等。】

    • 声明空映射

      直接通过 new Map[类型1, 类型2]() 来定义映射会报错,因为Map是抽象的,无法实例化。

      定义空映射时,需要指定映射的实现类,通过new来定义;

      

      分别定义不可变映射与可变映射。注,直接使用 new HashMap定义时会报错。

    2、映射常用操作

    • 判断映射中是否含有某个键: map.contains(键值)

      

    • 使用 += 向可变映射中添加元素或拼接映射

      

    • 使用 -= 移除可变映射中的键及对应元素

      

    • 不可变映射可通过 + 操作符返回一个新的不可变映射;不可变映射可通过 - 操作符返回一个新的不可变映射;

      

    • 映射遍历

      

    • 获取映射的键集合keySet和值集合

      

      通过映射的 keySet 方法可以获得映射的由键值构成的集合;通过 values 方法可以获得映射的值集合的Interable对象,应用于循环中。

      Scala的keySet / values 方法类似于Java中的映射方法。

    3、Scala中映射的底层实现要么基于哈希表,要么基于平衡树,其中基于平衡树的映射内部是有序的。

      

      Scala目前基于平衡树的映射只提供了不可变版本。

      【注:构建可变有序映射可借助Java的TreeMap。】

    4、可变映射中,若要构建维持元素插入顺序的映射可通过LinkedHashMap。

    5、通过scala.collection.JavaConversions.mapAsScalaMap可将Java的Map转换为Scala类型的Map;通过scala.collection.JavaConversions.mapAsJavaMap可将Scala的映射转换为Java类型的映射。

    6、toMap方法

      使用toMap方法可将对偶组成的集合转化为映射。

      

     

    三、元组

    1、元组是不同类型的值的聚集;对偶是最简单的元组。

    2、元组表示

      通过将不同的值用小括号括起来,即表示元组。

      

      上例中元组的类型就是 (Int, Double, Char, String) ;元组中可以存放不同类型的值。

    3、元组访问

    • 元组中的元素称为组元。可以通过 _1、 _2 、_3 的形式来访问对应下标的组元。

      

      【注:元组中组元下标从1开始。】

    • 通过模式匹配来访问元组中的值

      

      忽略不需要的值。在模式匹配时,通过 _ (万能匹配符)来为不需要获取值的组元占位,每个 _ 仅可以为一个组元占位。

      

    4、元组可用于函数返回多个值的情形

      

      上例中,函数定义返回值类型为元组 (Int, String);

      

     

    【积跬步,至千里。 _CrazySnail_】
    展开全文
  • spark笔记之数组映射、元组、集合

    千次阅读 2018-08-09 09:31:27
    1.1. 数组1.1.1. 定长数组和变长数组 (1)定长数组定义格式: val arr=new Array[T](数组长度) (2)变长数组定义格式: val arr = ArrayBuffer[T]() 注意需要导包:import scala.collection.mutable....

    1.1. 数组1.1.1. 定长数组和变长数组

    (1)定长数组定义格式:

    val arr=new Array[T](数组长度)

    (2)变长数组定义格式:

    val arr = ArrayBuffer[T]()

    注意需要导包:import scala.collection.mutable.ArrayBuffer

    [AppleScript] 纯文本查看 复制代码

    ?

    01

    02

    03

    04

    05

    06

    07

    08

    09

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    package cn.itcast.scala

    import scala.collection.mutable.ArrayBuffer

    object ArrayDemo {

      def main(args: Array[String]) {

     

        //初始化一个长度为8的定长数组,其所有元素均为0

        val arr1 = new Array[Int](8)

        //直接打印定长数组,内容为数组的hashcode值

        println(arr1)

        //将数组转换成数组缓冲,就可以看到原数组中的内容了

        //toBuffer会将数组转换长数组缓冲

        println(arr1.toBuffer)

     

        //注意:如果new,相当于调用了数组的apply方法,直接为数组赋值

        //初始化一个长度为1的定长数组

        val arr2 = Array[Int](10)

        println(arr2.toBuffer)

     

        //定义一个长度为3的定长数组

        val arr3 = Array("hadoop", "storm", "spark")

        //使用()来访问元素

        println(arr3(2))

     

        //变长数组(数组缓冲)

        //如果想使用数组缓冲,需要导入import scala.collection.mutable.ArrayBuffer包

        val ab = ArrayBuffer[Int]()

        //向数组缓冲的尾部追加一个元素

        //+=尾部追加元素

        ab += 1

        //追加多个元素

        ab += (2, 3, 4, 5)

        //追加一个数组++=

        ab ++= Array(6, 7)

        //追加一个数组缓冲

        ab ++= ArrayBuffer(8,9)

        //打印数组缓冲ab

     

        //在数组某个位置插入元素用insert,从某下标插入

        ab.insert(0, -1, 0)

        //删除数组某个位置的元素用remove  按照下标删除

        ab.remove(0)

        println(ab)

     

      }

    }

    1.1.2. 遍历数组

    1.增强for循环

    2.好用的until会生成脚标,0 until 10 包含0不包含10

    [AppleScript] 纯文本查看 复制代码

    ?

    01

    02

    03

    04

    05

    06

    07

    08

    09

    10

    11

    12

    13

    14

    15

    package cn.itcast.scala

    object ForArrayDemo {

      def main(args: Array[String]) {

        //初始化一个数组

        val arr = Array(1,2,3,4,5,6,7,8)

        //增强for循环

        for(i <- arr)

          println(i)

     

        //好用的until会生成一个Range

        //reverse是将前面生成的Range反转

        for(i <- (0 until arr.length).reverse)

          println(arr(i))

      }

    }

    1.1.3. 数组转换

    yield关键字将原始的数组进行转换会产生一个新的数组,原始的数组不变

    [AppleScript] 纯文本查看 复制代码

    ?

    01

    02

    03

    04

    05

    06

    07

    08

    09

    10

    11

    12

    13

    14

    15

    16

    17

    18

    package cn.itcast.scala

     

    object ArrayYieldDemo {

      def main(args: Array[String]) {

        //定义一个数组

        val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

        //将偶数取出乘以10后再生成一个新的数组

        val res = for (e <- arr if e % 2 == 0) yield e * 10

        println(res.toBuffer)

     

        //更高级的写法,用着更爽

        //filter是过滤,接收一个返回值为boolean的函数

        //map相当于将数组中的每一个元素取出来,应用传进去的函数

        val r = arr.filter(_ % 2 == 0).map(_ * 10)

        println(r.toBuffer)

     

      }

    }

    1.1.4. 数组常用算法

    在Scala中,数组上的某些方法对数组进行相应的操作非常方便!

    1.2. 映射

    在Scala中,把哈希表这种数据结构叫做映射。

    1.2.1. 构建映射

    (1)构建映射格式
    1、val map=Map(键 -> 值,键 -> 值....)

    2、利用元组构建  val map=Map((键,值),(键,值),(键,值)....)

    1.2.2. 获取和修改映射中的值

    (1)获取映射中的值:

    值=map(键)

    好用的getOrElse

    注意:在Scala中,有两种Map,一个是immutable包下的Map,该Map中的内容不可变;另一个是mutable包下的Map,该Map中的内容可变

    例子:

    注意:通常我们在创建一个集合是会用val这个关键字修饰一个变量(相当于java中的final),那么就意味着该变量的引用不可变,该引用中的内容是不是可变,取决于这个引用指向的集合的类型

    1.3. 元组

    映射是K/V对偶的集合,对偶是元组的最简单形式,元组可以装着多个不同类型的值。

    1.3.1. 创建元组

    (1)元组是不同类型的值的聚集;对偶是最简单的元组。

    (2)元组表示通过将不同的值用小括号括起来,即表示元组。

    创建元组格式:

    val tuple=(元素,元素...)

    1.3.2. 获取元组中的值

    (1) 获取元组中的值格式:

    使用下划线加脚标 ,例如 t._1  t._2  t._3

    注意:元组中的元素脚标是从1开始的

    1.3.3. 将对偶的集合转换成映射

    将对偶的集合转换成映射:

    调用其toMap 方法

    1.3.4. 拉链操作

    1.使用zip命令可以将多个值绑定在一起

    注意:如果两个数组的元素个数不一致,拉链操作后生成的数组的长度为较小的那个数组的元素个数

    2.如果其中一个元素的个数比较少,可以使用zipAll用默认的元素填充

    1.4. 集合

    Scala的集合有三大类:序列Seq、Set、映射Map,所有的集合都扩展自Iterable特质,在Scala中集合有可变(mutable)和不可变(immutable)两种类型,immutable类型的集合初始化后就不能改变了(注意与val修饰的变量进行区别)。

    1.4.1. List

    (1)不可变的序列 import scala.collection.immutable._

    在Scala中列表要么为空(Nil表示空列表)        要么是一个head元素加上一个tail列表。

    9 :: List(5, 2)  :: 操作符是将给定的头和尾创建一个新的列表        

    注意:: 操作符是右结合的,如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

    list常用的操作符:

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

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

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

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

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

    val left = List(1,2,3)

    val right = List(4,5,6)

    //以下操作等价

    left ++ right      // List(1,2,3,4,5,6)

    right.:::(left)     // List(1,2,3,4,5,6)

    //以下操作等价

    0 +: left    //List(0,1,2,3)

    left.+:(0)   //List(0,1,2,3)

    //以下操作等价

    left :+ 4    //List(1,2,3,4)

    left.:+(4)   //List(1,2,3,4)

    //以下操作等价

    0 :: left      //List(0,1,2,3)

    left.::(0)     //List(0,1,2,3)

    例子:

    [AppleScript] 纯文本查看 复制代码

    ?

    01

    02

    03

    04

    05

    06

    07

    08

    09

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    package cn.itcast.collect

    /**

     

     * 不可变List集合操作

     */

    object ImmutListDemo {

      def main(args: Array[String]) {

        //创建一个不可变的集合

        val lst1 = List(1,2,3)

        //补充:另一种定义list方法

        val other_lst=2::Nil

        //获取集合的第一个元素

        val first=lst1.head

        //获取集合中除第一个元素外的其他元素集合,

        val tail=lst1.tail

        //补充:其中如果 List 中只有一个元素,那么它的 head 就是这个元素,它的 tail 就是 Nil;

        println(other_lst.head+"----"+other_lst.tail)

        //0插入到lst1的前面生成一个新的List

        val lst2 = 0 :: lst1

        val lst3 = lst1.::(0)

        val lst4 = 0 +: lst1

        val lst5 = lst1.+:(0)

         

     

    //将一个元素添加到lst1的后面产生一个新的集合

        val lst6 = lst1 :+ 3

        val lst0 = List(4,5,6)       

        //2list合并成一个新的List

        val lst7 = lst1 ++ lst0

        //将lst0插入到lst1前面生成一个新的集合

        val lst8 = lst1 ++: lst0

        //将lst0插入到lst1前面生成一个新的集合

        val lst9 = lst1.:::(lst0)

     

        println(other_lst)

        println(lst1)

        println(first)

        println(tail)

        println(lst2)

        println(lst3)

        println(lst4)

        println(lst5)

        println(lst6)

        println(lst7)

        println(lst8)

        println(lst9)

      }

    }

    (2)可变的序列 import scala.collection.mutable._

    [AppleScript] 纯文本查看 复制代码

    ?

    01

    02

    03

    04

    05

    06

    07

    08

    09

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    ackage cn.itcast.collect

    import scala.collection.mutable.ListBuffer

     

    object MutListDemo extends App{

      //构建一个可变列表,初始有3个元素1,2,3

      val lst0 = ListBuffer[Int](1,2,3)

      //创建一个空的可变列表

      val lst1 = new ListBuffer[Int]

      //向lst1中追加元素,注意:没有生成新的集合

      lst1 += 4

      lst1.append(5)

     

     

      //将lst1中的元素最近到lst0中, 注意:没有生成新的集合

      lst0 ++= lst1

     

     

      //将lst0和lst1合并成一个新的ListBuffer 注意:生成了一个集合

      val lst2= lst0 ++ lst1

     

     

      //将元素追加到lst0的后面生成一个新的集合

      val lst3 = lst0 :+ 5

     

     

      //删除元素,注意:没有生成新的集合

      val lst4 = ListBuffer[Int](1,2,3,4,5)

      lst4 -= 5

     

     

      //删除一个集合列表,生成了一个新的集合

      val lst5=lst4--List(1,2)

     

     

      //把可变list 转换成不可变的list 直接加上toList

      val lst6=lst5.toList

     

     

      //把可变list 转变数组用toArray

      val lst7=lst5.toArray

     

     

      println(lst0)

      println(lst1)

      println(lst2)

      println(lst3)

      println(lst4)

      println(lst5)

      println(lst6)

      println(lst7)

     

    }

    1.4.2. Set

    (1)不可变的Set    import scala.collection.immutable._

    Set代表一个没有重复元素的集合;将重复元素加入Set是没有用的,而且 Set 是不保证插入顺序的,即 Set 中的元素是乱序的。

    定义:val set=Set(元素,元素,.....)

    [AppleScript] 纯文本查看 复制代码

    ?

    001

    002

    003

    004

    005

    006

    007

    008

    009

    010

    011

    012

    013

    014

    015

    016

    017

    018

    019

    020

    021

    022

    023

    024

    025

    026

    027

    028

    029

    030

    031

    032

    033

    034

    035

    036

    037

    038

    039

    040

    041

    042

    043

    044

    045

    046

    047

    048

    049

    050

    051

    052

    053

    054

    055

    056

    057

    058

    059

    060

    061

    062

    063

    064

    065

    066

    067

    068

    069

    070

    071

    072

    073

    074

    075

    076

    077

    078

    079

    080

    081

    082

    083

    084

    085

    086

    087

    088

    089

    090

    091

    092

    093

    094

    095

    096

    097

    098

    099

    100

    101

    102

    103

    104

    105

    106

    107

    108

    109

    110

    111

    112

    113

    114

    115

    116

    117

    118

    119

    120

    121

    //定义一个不可变的Set集合

     

    scala> val set =Set(1,2,3,4,5,6,7)

     

    set: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)

     

      

     

    //元素个数

     

    scala> set.size

     

    res0: Int = 7

     

      

     

    //取集合最小值

     

    scala> set.min

     

    res1: Int = 1

     

      

     

    //取集合最大值

     

    scala> set.max

     

    res2: Int = 7

     

      

     

    //将元素和set1合并生成一个新的set,原有set不变

     

    scala> set + 8

     

    res3: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)

     

      

     

    scala> val set1=Set(7,8,9)

     

    set1: scala.collection.immutable.Set[Int] = Set(7, 8, 9)

     

      

     

    //两个集合的交集

     

    scala> set & set1

     

    res4: scala.collection.immutable.Set[Int] = Set(7)

     

      

     

    //两个集合的并集

     

    scala> set ++ set1

     

    res5: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

     

      

     

    //在第一个set基础上去掉第二个set中存在的元素

     

    scala> set -- set1

     

    res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

     

      

     

    //返回第一个不同于第二个set的元素集合

     

    scala> set &~ set1

     

    res7: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

     

      

     

      

     

    //计算符合条件的元素个数

     

    scala> set.count(_ >5)

     

    res8: Int = 2

     

      

     

    /返回第一个不同于第二个的元素集合

     

    scala> set.diff(set1)

     

    res9: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

     

      

     

    /返回第一个不同于第二个的元素集合

     

    scala> set1.diff(set)

     

    res10: scala.collection.immutable.Set[Int] = Set(8, 9)

     

      

     

    //取子set(2,5为元素位置, 0开始,包含头不包含尾)

     

    scala> set.slice(2,5)

     

    res11: scala.collection.immutable.Set[Int] = Set(6, 2, 7)

     

      

     

    //迭代所有的子set,取指定的个数组合

     

    scala> set1.subsets(2).foreach(x=>println(x))

     

    Set(7, 8)

     

    Set(7, 9)

     

    Set(8, 9)

    (2)可变的Set  import scala.collection.mutable._

    [AppleScript] 纯文本查看 复制代码

    ?

    01

    02

    03

    04

    05

    06

    07

    08

    09

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    //导入包

     

    scala> import scala.collection.mutable

     

    import scala.collection.mutable

     

    //定义一个可变的Set

     

    scala> val set1=new HashSet[Int]()

     

    set1: scala.collection.mutable.HashSet[Int] = Set()

     

      

     

    //添加元素

     

    scala> set1 += 1

     

    res1: set1.type = Set(1)

     

      

     

    //添加元素  add等价于+=

     

    scala> set1.add(2)

     

    res2: Boolean = true

     

    scala> set1

     

    res3: scala.collection.mutable.HashSet[Int] = Set(1, 2)

     

      

     

    //向集合中添加元素集合

     

    scala> set1 ++=Set(1,4,5)

     

    res5: set1.type = Set(1, 5, 2, 4)

     

      

     

    //删除一个元素

     

    scala> set1 -=5

     

    res6: set1.type = Set(1, 2, 4)

     

      

     

    //删除一个元素

     

    scala> set1.remove(1)

     

    res7: Boolean = true

     

    scala> set1

     

    res8: scala.collection.mutable.HashSet[Int] = Set(2, 4)

    1.4.3. Map

    (1)不可变的Map   import scala.collection.immutable._

    [AppleScript] 纯文本查看 复制代码

    ?

    01

    02

    03

    04

    05

    06

    07

    08

    09

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    67

    定义Map集合

     

    1.val map=Map(-> , -> 值...)

     

    2.利用元组构建  val map=Map((键,值), (键,值) , (键,值)....)

     

    展现形式:

     

    val  map = Map(“zhangsan”->30,”lisi”->40)

     

    val  map = Map((“zhangsan”,30),(“lisi”,40))

     

      

     

    3.操作map集合

     

    获取值: 值=map()

     

    原则:通过先获取键,在获取键对应值。

     

      

     

    4.遍历map集合

     

    scala> val imap=Map("zhangsan" -> 20,"lisi" ->30)

     

    imap: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 20, lisi -> 30)

     

    //方法一:显示所有的key

     

    scala> imap.keys

     

    res0: Iterable[String] = Set(zhangsan, lisi)

     

      

     

    //方法二:显示所有的key

     

    scala> imap.keySet

     

    res1: scala.collection.immutable.Set[String] = Set(zhangsan, lisi)

     

      

     

    //通过key获取value

     

    scala> imap("lisi")

     

    res2: Int = 30

     

      

     

    //通过key获取value key对应的值则返回,没有就返回默认值0

     

    scala> imap.getOrElse("zhangsan",0)

     

    res4: Int = 20

     

      

     

    //没有对应的key,返回默认0

     

    scala> imap.getOrElse("zhangsan1",0)

     

    res5: Int = 0

     

    //由于是不可变map,故不能向其添加、删除、修改键值对

    (2)可变的Map  import scala.collection.mutable._

     

    001

    002

    003

    004

    005

    006

    007

    008

    009

    010

    011

    012

    013

    014

    015

    016

    017

    018

    019

    020

    021

    022

    023

    024

    025

    026

    027

    028

    029

    030

    031

    032

    033

    034

    035

    036

    037

    038

    039

    040

    041

    042

    043

    044

    045

    046

    047

    048

    049

    050

    051

    052

    053

    054

    055

    056

    057

    058

    059

    060

    061

    062

    063

    064

    065

    066

    067

    068

    069

    070

    071

    072

    073

    074

    075

    076

    077

    078

    079

    080

    081

    082

    083

    084

    085

    086

    087

    088

    089

    090

    091

    092

    093

    094

    095

    096

    097

    098

    099

    100

    101

    102

    103

    104

    105

    106

    107

    108

    109

    110

    111

    112

    113

    114

    115

    116

    117

    118

    119

    120

    121

    122

    123

    124

    125

    126

    127

    128

    129

    130

    131

    132

    133

    //导包

     

    import scala.collection.mutable

     

    //声明一个可变集合

     

    scala> val user =mutable.HashMap("zhangsan"->50,"lisi" -> 100)

     

    user: scala.collection.mutable.HashMap[String,Int] = Map(lisi -> 100, zhangsan -> 50)

     

      

     

    //添加键值对

     

    scala> user +=("wangwu" -> 30)

     

    res0: user.type = Map(lisi -> 100, zhangsan -> 50, wangwu -> 30)

     

      

     

    //添加多个键值对

     

    scala> user += ("zhangsan0" -> 30,"lisi0" -> 20)

     

    res1: user.type = Map(zhangsan0 -> 30, lisi -> 100, zhangsan -> 50, lisi0 -> 20,wangwu -> 30)

     

      

     

    //方法一:显示所有的key

     

    scala> user.keys

     

    res2: Iterable[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)

     

      

     

    //方法二:显示所有的key

     

    scala> user.keySet

     

    res3: scala.collection.Set[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)

     

      

     

    //通过key获取value

     

    scala> user("zhangsan")

     

    res4: Int = 50

     

      

     

    //通过key获取value key对应的值则返回,没有就返回默认值0

     

    scala> user.getOrElse("zhangsan",0)

     

    res5: Int = 50

     

      

     

    //没有对应的key,返回默认0

     

    scala> user.getOrElse("zhangsan1",0)

     

    res6: Int = 0

     

      

     

    //更新键值对

     

    scala> user("zhangsan") = 55

     

    scala> user("zhangsan")

     

    res8: Int = 55

     

      

     

    //更新多个键值对

     

    scala> user += ("zhangsan" -> 60, "lisi" -> 50)

     

    res9: user.type = Map(zhangsan0 -> 30, lisi -> 50, zhangsan -> 60, lisi0 -> 20,wangwu -> 30)

     

      

     

    //删除key

     

    scala> user -=("zhangsan")

     

    res14: user.type = Map(zhangsan0 -> 30, lisi -> 50, lisi0 -> 20, wangwu -> 30)

     

      

     

    //删除key

     

    scala>user.remove("zhangsan0")

     

      

     

    //遍历map 方法一:通过key

     

    scala> for(x<- user.keys) println(x+" -> "+user(x))

     

    lisi -> 50

     

    lisi0 -> 20

     

    wangwu -> 30

     

      

     

    //遍历map 方法二:模式匹配

     

    scala> for((x,y) <- user) println(x+" -> "+y)

     

    lisi -> 50

     

    lisi0 -> 20

     

    wangwu -> 30

     

      

     

    //遍历map 方法三:通过foreach

     

    scala>  user.foreach{case (x,y) => println(x+" -> "+y)}

     

    lisi -> 50

     

    lisi0 -> 20

     

    wangwu -> 30

    展开全文
  • 一、数组 1. 数组有 定长数组:Array  变长数组:ArrayBuffer 不可变的集合或数组一般在immutable包下面,scala默认将这个包导入进来了 ;可变的集合或数组一般在mutable包下,需要手动导入 。 Array 是一个...

    一、数组
    1. 数组有   定长数组:Array
                       变长数组:ArrayBuffer
    不可变的集合或数组一般在immutable包下面,scala默认将这个包导入进来了
    ;可变的集合或数组一般在mutable包下,需要手动导入

    Array 是一个不可变长数组,但是数组中角标对应的元素是可变的

    import scala.collection.mutable.ArrayBuffer
    object Demo1 {
      def main(args: Array[String]) {
        //初始化一个长度为8的定长数组,其所有的元素为0
        val arr1 = new Array[Int](8)
        //直接打印定长数组,内容为数组的hashcode值
        println(arr1)
        // 将数组转化为数组缓冲,就可以看到原数组中的内容
        println(arr1.toBuffer)
        println(arr1.length)
    
       val arr2 = Array("hadoop", "hive", "spark")
        // 下面的这种写法会报错,上述定义定长数组,本质上通过伴生对象的apply()实现初始化
        // val ARR3 = new Array("hadoop","hive","spark")
        println(arr2.toBuffer)
        println(arr2(0))
        //变长数组
        val ab = ArrayBuffer[Int]()
        //向数组缓冲的尾部追加一个元素
        ab += 1
        //追加多个元素
        ab +=(2, 3, 4)
        //追加一个数组 ++=
        ab ++= Array(6, 7)
        //追加一个数组缓冲
        ab ++= ArrayBuffer(8, 9)
        println(ab)
      }
    }

    2.遍历数组

    object ForArrayDemo {
      def main(args: Array[String]) {
        //使用for循环遍历
        val arr1 = Array("jack", "tom", "rose")
        for (i <- arr1) println(i)
        //使用until遍历,与java里面的for(int i; i < arr.length; i ++)类似
        val arr2 = Array("scala", "spark", "hadoop")
        for (i <- (0 until (arr2.length)))
          println(i + "---" + arr2(i))
        //反转数组
        for (i <- (0 until arr2.length).reverse)
          println(i + "---" + arr2(i))
      }
        println(arr1.max)
        println(arr1.min)
        println(arr1.sum)
        println(arr1.head)   //取第一个元素
        println(arr1.last)   //取最后一个元素
        arr1.update(0, 0)    //更新指定角标的元素的值
    
    }
    }

    3.数组转换

    object TransDemo {
      def main(args: Array[String]) {
        val arr1 = Array(1,2,3,4,5)
        //yield 把每一个元素遍历后,处理放到一个新的区间里面去
        val arr2 = for(i <-arr1 if i % 2 == 0)yield i * 10
        println(arr2.toBuffer)
        //map 是把原来数组的每一个元素拿出来(自己完成遍历操作),然后处理了得到一个新的数组
        println(arr1.map(_*100).toBuffer)
        //filter 是对元素进行筛选(自己内部加了if条件),然后放入一个新的数组中
        val arr3 =arr1.filter(_%2==0).map(_+100)
        println(arr3.toBuffer)
      }
    
    }

    二、映射
    scala中把映射
    scala中把hash表这种数据结构叫映射
    构建映射有两种方式,一种是箭头 ->,一种是元组()

    object MapDemo {
      def main(args: Array[String]) {
        /*注意:在Scala中,有两种Map,一个是immutable包下的Map,
        该Map中的内容不可变;另一个是mutable包下的Map,该Map中的内容可变*/
        //不可变
        val scor = Map(("tommy",80),("jackky",90),("rosey",100))
        //可变
        val scores = scala.collection.mutable.Map(("tom",80),("jack",90),("rose",100))
        println(scores("tom"))
        scores("tom") = 88
        println(scores("tom"))
        //可以先对key进行判断,如果存在则取出对应的value
        if(scores.contains("tom")){
          println(scores("tom"))
        }
        //get 方法返回的是一个Option对象,这个对象有两个小弟:Some和None
        //如果有值则返回的是some,否则返回的是None
        //通过Option的get方法可以取出Some里面的值
        val maybeInt: Option[Int] = scores.get("tom")
        println(maybeInt.get)
        scores += (("kobe",100),("zms" , 99),("kuli",1))
        println(scores("kobe"))
        //用getOrElse ,如果取不到,可以返回一个给定的默认值
        val star = scores.getOrElse("韦德","闪电侠")
        val star1 = scores.getOrElse("kobe",0)
        println(star)  //闪电侠
        println(star1) //100
      }
    }

    三、元组
    映射是K/V对偶的集合,对偶是元组最简单的形式,元组可以封装多个不同类型的值,注意元组的角标是从1 开始的。

    object TupleDemo {
      def main(args: Array[String]) {
        val tuple2: (Int, String) = (3, "value")
        val tuple3 = ("hi", "heiio", "baibai")
        val tuple, (key, value) = ("key", "value")
        println(tuple2._2)
        val t1 = Array(1,2)
        val t2 = Array("hah","ok")
        //拉链操作,zip命令可以将多个值绑定在一起
        val t3 : Array[(Any,Any)] = t1.zip(t2) 
        t3.foreach(x => println(x))//(1,hah) (2,ok)
    
    }
    }

    四、集合
    Scala的集合有三大类:序列Seq、集Set、映射Map,所有的集合都扩展自Iterable特质
    在Scala中集合有可变(mutable)和不可变(immutable)两种类型,immutable类型的集合初始化后)不能改变不(注意与val修饰的变量进行区别)
    1. 不可变的序列 import scala.collection.immutable._
    在Scala中列表要么为空(Nil表示空列表)要么是一个head元素加上一个tail列表。
    9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
    注意::: 操作符是右结合的,如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

    def main(args: Array[String]): Unit = {
        val list = List(1, 2, 3)
        //原来的list是不变的
        val newList = list ++ List("dfasd", true)
        //println(newList)
        /**
          * 给头部添加
          */
        val newList2 = list.::(4, 5)
        val newList3 = list.+:(4, 5)
        val newList4 = (4, 5) :: list
        val newList5 = (4, 5) +: list
        println(newList5)
        /**
          * 给尾部添加
          */
        val newList6 = list.:+(4, 5)
        val newList7 = list ++ List(4, 5)
        val newList8 = list ++: List(4, 5)
        // println(newList8)
        /**
          * list 的常规操作
          */
        println(list.sum)
        println(list.max)
        println(list.min)
        println(list.head)
        println(list.last)
        list.updated(0, 0)
        list.reverse
        list.mkString(",")
        list.mkString("[", ",", "]")
        /**
          * list 的转换操作
          */
        list.map(x=>x).reverse.sortBy(x=>x).filter(x=>true).foreach(println(_))
      }

    2.

    def main(args: Array[String]) {
        //创建了一个lst0 有初始值
        val lst0 = ListBuffer[Int](1,2,3)
    
        //创建空的lst1
        val lst1 = new ListBuffer[Int]
          println("lst1:"+ lst1)
        //改lst1 添加一个元素,从打印结果可以看出,添加元素的两种方式: append 与 +=
        lst1.append(4)
        lst1 += 5
        println("lst1:"+ lst1)
        //将lst1 里面的元素追加到lst0
        lst0 ++=lst1
        println("lst0:" + lst0)
    
        // 注意:下面的情况会产生一个新的集合
        val lst3 = lst0 ++ lst1
        val lst4 = lst1 :+ 10
        println("lst3:" + lst3)
        println("lst4:" + lst4)
      }
    }

    3.Set

    def main(args: Array[String]): Unit = {
        /**
          * 不可变的
          */
        val set0 = Set(1, 2, 3, 4)
        val set1 = set0 + 9
        val set2 = set0 ++ Set(5, 6, 7)
    
        set0.foreach(println(_))
    
        /**
          * 可变的
          */
        val set3 = collection.mutable.Set(1, 2, 3, 4, 5)
        set3 += 5
        set3 ++= Set(6, 7, 8, 9)
        println(set3)
      }
    展开全文
  • 文章目录一、数组1、定长数组和变长数组2、遍历数组3、数组转换4、常用数组的算法二、映射(Map)1、构建映射2、获取映射中的值三、元组1、创建元组2、获取元组中的值3、将对偶的元组转换成映射4、拉链操作四、集合...
  • scala的数组映射、元组和集合

    千次阅读 2017-05-24 22:32:35
    一、数组1.1定义数组scala&gt; val arr = new Array[Int](10)arr: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)scala&gt; arr(0)=1scala&gt; arr(1)=2scala&gt;val arr1 = Array(1,2,3,4)arr1...
  • 数组 定长数组:在Scala中可以用Array,初始化一个定长数组。例如: val nums = new Array[Int](10) //10个整数的数组,所有元素初始化为0 ...val s = Array("Hello", "Scala") //长度2的字符串数组 s
  • 1.数组 ①.定长数组,可以使用Array,当指定类型而没有初始化时,使用初始默认值初始化 val nums = new Array[Int](10) 当指定了初始值时,定义数组就不需要new了 val s = Array("hello","world") 访问数组...
  • 症状:postgre中采用数组类型存放数据,实体类对应属性String[] ,插入正常,查询无法查询到属性。 Postgre 中可以储存数组类型的数据,而对于数组类型的属性,MyBatis默认采用ObjectTypeHandler,其内部采用...
  • 1.数组 1.1定长数组和变长数组 object ArrayDemo { ... //初始化一个长度8的定长数组,其数组元素均0 val arr1 = new Array[Int](8) //直接打印定长数组,内容为数组的hashcode值 println(arr1) ...
  • 切片是围绕动态数组的概念构建的,可以按需自动增长和缩小。切片的动态增长是通过内置函数append来实现的。这个函数可以快速且高效地增长切片。还可以通过对切片再次切片来缩小一个切片的大小。
  • 切片是围绕动态数组的概念构建的,可以按需自动增长和缩小 切片底层内存在连续块中分配,因此能获得索引、迭代以及垃圾回收优化的好处。 切片的数据结构 指向底层数组的指针 切片长度 切片容量 ...
  • 在 Go 语言中,便于存储及管理用户数据,其数据结构设计分为数组 Array、切片 Slice、映射 Map三种结构。 近期又看了 Go 语言基础的内容,看了一下这三种结构实现的原理: 数组 Array 数组是切片和映射的基础...
  • G语言有3种数据结构可以让用户管理集合数据:数组、切片和映射。 一、数组  在Go语言里,数组是一个长度固定的数据类型,用于存储一段具有相同类型的元素的连续块。数组存储的类型可以使内置类型,如整型或者字符...
  • package mainimport "fmt"/* 数组是一个重要构建,定义数组并制定长度和数据类型 arr [10]int,数组一般存储使用数字做索引的数据 数组的固定以后不可以任意追加,数组声明的时候必须制定长度,或者 用 arr:=[]...
  • Go 语言有 3 种数据结构可以让用户 管理集合数据:数组、切片和映射。 先学习数组 数组内部实现和基础功能 内部实现 定义:数组是一个长度固定的数据类型,用于存储一段具有相同的类型的元素的连 续块。数组存储的...
  • 数组

    2019-04-02 19:58:03
    一、数组 1.概念:数组就是一个可以存储一组或一系列数值的变量。...映射: “键”和“值”之间存在一种对应关系,称之为映射 7.类型划分:根据键的数据类型,可以将数组划分索引数组和关联数组...
  • 数组、切片和映射(Go Tutorial)
  • 映射(Map) 映射(Map)是十分常见的一种数据结构,由一系列键(key)和值(value)组成的。每个key对应一个value,根据key可以获取和设定value,也可以根据key来...d3.map()能构建映射,包括以下方法: d3.map([object]...
  • 数组法:构建一个480*800的二维数组,加上数学关系暴力。(代码的函数封装0,因其不我写的代码) #include <stdio.h> #include <sys/types.h> #include <sys/stat.h>...
  • 如果目标数组构建完成,就停止读取更多元素。 题目数据保证目标数组严格递增,并且只包含 1 到 n 之间的数字。 请返回构建目标数组所用的操作序列。 题目数据保证答案是唯一的。 示例 1: 输入:tar..
  • 首先讲解一下映射数组 CREATE TABLE `admin_role_ids` ( `id` bigint(20) NOT NULL primary key AUTO_INCREMENT COMMENT 'id', `type` varchar(16) DEFAULT NULL COMMENT '分别 admin , tourist 枚举', `role_ids...
  • 一、数组 1、定长数组 声明数组的两种形式: 声明指定长度的数组 val 数组名= new Array[类型](数组长度)   提供数组初始值的数组,无需newkeyword   Scala声明数组时。须要带有Array类名,且...
  • 一、数组 1、定长数组 声明数组的两种形式: 声明指定长度的数组 val 数组名= new Array[类型](数组长度)   提供数组初始值的数组,无需new关键字   Scala声明数组时,需要带有Array类名,且使用 () 来指明...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 83,394
精华内容 33,357
关键字:

为什么不用数组构建映射