大数据技术之_16_Scala学习_07_数据结构(上)-集合

第十章 数据结构(上)-集合

10.1 数据结构特点

10.1.1 Scala 集合基本介绍

10.1.2 可变集合和不可变集合举例

示例代码如下：

package com.atguigu.chapter10.test;

import java.util.ArrayList;

public class JavaCollectionDemo {
   
    public static void main(String[] args) {
   
        // 不可变集合类似 java 的数组
        int[] nums = new int[3];
        nums[2] = 11;
        // nums[3] = 90; // 数组越界

        String[] names = {
   "bj", "sh"};
        System.out.println(nums + " " + names); // [I@12a3a380 [Ljava.lang.String;@29453f44

        // 可变集合举例
        ArrayList al = new ArrayList<String>();
        al.add("zs");
        al.add("zs2");
        System.out.println(al + " " + al.hashCode()); // [zs, zs2] 242625
        al.add("zs3");
        System.out.println(al + " " + al.hashCode()); // [zs, zs2, zs3] 7642233

    }
}

输出结果如下：

[I@12a3a380 [Ljava.lang.String;@29453f44
[zs, zs2] 242625
[zs, zs2, zs3] 7642233

10.2 Scala 不可变集合继承层次一览图

10.2.1 图

10.2.2 小结

  1、Set、Map 是 Java 中也有的集合。
  2、Seq 是 Java 中没有的，我们发现 List 归属到 Seq 了，因此这里的 List 就和 java 不是同一个概念了。
  3、我们前面的 for 循环有一个 1 to 3，就是 IndexedSeq 下的 Vector。
  4、String 也是属于 IndexeSeq。
  5、我们发现经典的数据结构，比如Queue 和 Stack 被归属到 LinearSeq。
  6、大家注意 Scala 中的 Map 体系有一个SortedMap，说明 Scala 的 Map 可以支持排序。
  7、IndexSeq 和 LinearSeq 的区别
    IndexSeq 是通过索引来查找和定位，因此速度快，比如 String 就是一个索引集合，通过索引即可定位。
    LineaSeq 是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找，它的价值在于应用到一些具体的应用场景(比如：电商网站，大数据推荐系统：最近浏览的10个商品)。

10.3 Scala 可变集合继承层次一览图

10.3.1 图

10.3.2 小结

  1、Scala 可变集合中比不可变集合丰富。
  2、在 Seq 集合中，增加了 Buffer 集合，将来开发中，我们常用的有 ArrayBuffer 和 ListBuffer。
  3、如果涉及到线程安全可以选择 Syn… 开头的集合。
  4、其他的小结参考不可变集合。

10.4 数组-定长数组(声明泛型)

10.4.1 第一种方式定义数组

说明：这里的数组等同于 Java 中的数组，中括号的类型就是数组的类型。

val arr1 = new Array[Int](10)
// 赋值，集合元素采用小括号访问
arr1(1) = 7

示例代码如下：

package com.atguigu.chapter10.array

/**
  * 第一种方式定义数组
  * 说明：这里的数组等同于 Java 中的数组，中括号的类型就是数组的类型。
  */
object ArrayDemo01 {
   
  def main(args: Array[String]): Unit = {
   
    // 明
    // 1. 创建了一个 Array 对象
    // 2. [Int] 表示泛型，即该数组中，只能存放 Int
    // 3. [Any] 表示该数组可以存放任意类型
    // 4. 在没有赋值情况下，各个元素的值玩为0
    // 5. arr01(3) = 10 表示修改第4个元素的值
    val arr01 = new Array[Int](4) // 底层 int[] arr01 = new int[4]
    println(arr01.length) // 4
    println("arr01(0)=" + arr01(0)) // 0

    //数据的遍历
    for (i <- arr01) {
   
      println(i)
    }
    println("----------")

    arr01(3) = 10
    for (i <- arr01) {
   
      println(i)
    }
    
  }
}

输出结果如下：

4
arr01(0)=0
0
0
0
0
----------
0
0
0
10

10.4.2 第二种方式定义数组

说明：在定义数组时，直接赋值。

// 使用 apply 方法创建数组对象
val arr1 = Array(1, 2)

示例代码如下：

package com.atguigu.chapter10.array

/**
  * 第二种方式定义数组
  * 说明：在定义数组时，直接赋值。
  */
object ArrayDemo02 {
   
  def main(args: Array[String]): Unit = {
   
    // 说明
    // 1. 使用的是 object Array 的 apply 方法
    // 2. 直接初始化数组，因为你给了整数和字符串, 这个数组的泛型就是 Any 了
    // 3. 遍历方式一样
    var arr02 = Array(1, 3, "xxx")
    arr02(1) = "xx"
    for (i <- arr02) {
   
      println(i)
    }

    // 可以使用我们传统的方式遍历，使用下标的方式遍历
    for (index <- 0 until arr02.length) {
   
      printf("arr02[%d]=%s", index, arr02(index) + "\t")
    }
    
  }
}

输出结果如下：

1
xx
xxx
arr02[0]=1	arr02[1]=xx	arr02[2]=xxx

10.5 数组-变长数组(声明泛型)

说明：

// 定义/声明
val arr2 = ArrayBuffer[Int]()
// 追加值/元素
arr2.append(7)
// 重新赋值
arr2(0) = 7

示例代码如下：

package com.atguigu.chapter10.array

import scala.collection.mutable.ArrayBuffer

object ArrayBufferDemo01 {
   
  def main(args: Array[String]): Unit = {
   
    // 创建 ArrayBuffer
    val arr01 = ArrayBuffer[Any](3, 2, 5)

    // 访问，查询
    // 通过下标访问元素
    println("arr01(1)=" + arr01(1)) // arr01(1) = 2
    // 遍历
    for (i <- arr01) {
   
      println(i)
    }
    println(arr01.length) // 3
    println("arr01.hash=" + arr01.hashCode()) // arr01.hash=110266112


    // 修改 [修改值，动态增加]
    // 使用 append 追加数据，append 支持可变参数
    // 可以理解成 java 的数组的扩容
    arr01.append(90.0, 13) // (3, 2, 5, 90.0, 13)  append 底层重新 new 出一个数组，然后底层把新的地址值重新赋给 arr01
    println("arr01.hash=" + arr01.hashCode()) // arr01.hash=-70025354

    println("====================")

    arr01(1) = 89 // 修改 (3, 89, 5, 90.0, 13)
    println("----------")
    for (i <- arr01) {
   
      println(i)
    }

    // 删除
    // 删除，是根据下标来说
    arr01.remove(0) // (89, 5, 90.0, 13) // arr01.hash=-1775231646
    println("arr01.hash=" + arr01.hashCode())
    println("----------删除后的元素遍历----------")
    for (i <- arr01) {
   
      println(i)
    }
    println("最新的长度=" + arr01.length) // 4

  }
}

输出结果如下：

arr01(1)=2
3
2
5
3
arr01.hash=110266112
arr01.hash=-70025354
====================
----------
3
89
5
90.0
13
arr01.hash=-1775231646
----------删除后的元素遍历----------
89
5
90.0
13
最新的长度=4

10.5.1 变长数组分析小结

10.5.2 定长数组与变长数组的转换

示例代码如下：

package com.atguigu.chapter10.array

import scala.collection.mutable.ArrayBuffer

object Array22ArrayBuffer {
   
  def main(args: Array[String]): Unit = {
   

    val arr2 = ArrayBuffer[Int](