Scala集合操作

最新推荐文章于 2022-04-20 14:55:05 发布

卡卡卡丶西都

最新推荐文章于 2022-04-20 14:55:05 发布

阅读量500

点赞数

分类专栏：笔记文章标签： scala

本文链接：https://blog.csdn.net/weixin_45470171/article/details/110007990

版权

笔记专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Scala集合

Scala同时支持可变集合和不可变集合,因为不可变集合可以安全的并发访问，所有它也是默认使用的集合类

不可变集合，指的是集合内的元素一但初始化就无法进行改变，任何对集合的改变都要生成一个新的集合

scala.collection.immutable 在这个包下，无须手动导包

可变集合，指的是集合本身可以动态变化，且集合提供了改变集合内元素的方法

scala.collection.mutable ，在这个包下，需要手动导包

在这里插入图片描述

学知识：学顶层知识，用底层方法

Traversable

创建Traversable对象

// 创建空的Traversable 对象
val t1 = Traversable.empty[Int]
// 通过小括号方式实现
val t2 = Traversable[Int]()
//通过nil
val t3 = Nil

//传参
val t4 = (1 to 10).toTraversable //底层是Vector
val t5 = Traversable(1,2,3,4) //底层是List

1.创建Traversable对象

object TraversableDemo {
  def main(args: Array[String]): Unit = {
    //创建集合对象
    val t1: Traversable[Int] = Traversable.empty[Int]
    val t2: Traversable[Int] = Traversable[Int]()
    val t3: Traversable[Int] = Nil
    //比较是否相同   == 比较的是集合中的数据  eq 比较的是集合的地址值
    println(t1.equals(t2)) //true
    println(t2.equals(t3)) //true
    println(t1.equals(t3)) //true
    println("-" * 15)
    //创建 Traversable 集合对象 ， 存储数据
    // 1 通过 toTraversable()方法来实现
    val t4: Traversable[Int] = List(1, 2, 3).toTraversable
    //val t5: Traversable[Int] = Set(1, 2, 3).toTraversable
    //2 通过 Traverable 伴生对象的apply()方法来实现
    val t6: Traversable[Int] = Traversable(11, 22, 33, 44, 55)

    println(s"t4 = ${t4}") //Lsit(1,2,3)
    //println(s"t5 = ${t5}")
    println(s"t6 = ${t6}") //(11,22,33,44,55)
  }
}

转置Traversable结合

1 4 7 	   1 2 3
2 5 8   => 4 5 6
3 6 9 	   7 8 9
java 中的转置 
int data [][] = {{1,4,7},{2,5,8},{3,6,9}}

for(int i = 0;i<data.length;i++){
    for(int j =i; j<data[i].length;j++){
        int k = data[i][j];
        data[i][j]= data[j][i];
        data[j][i]= k;
    }
}
for(int i =0 ; i<data.length;i++){
    for(int j =0;j<data[i].length;j++){
        System.out.println(data[i][j]+"\t")
    }
    System.out.print()
}
Scala中的转置
    //定义一个集合 ，元素为Traversable集合
    val t1: Traversable[Traversable[Int]] = Traversable(Traversable(1, 4, 7), Traversable(2, 5, 8), Traversable(3, 6, 9))
    //通过transpose方法，对集合t1进行转置，用t2接收
    val t2: Traversable[Traversable[Int]] = t1.transpose
    println(s"t1 = ${t1}")
    //t1 = List(List(1, 4, 7), List(2, 5, 8), List(3, 6, 9))
    println(s"t2 = ${t2}")
    //t2 = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))

拼接集合

 java中的拼接
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);
        ArrayList list2 = new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);
        System.out.println(list2);
        list.addAll(list2);
        System.out.println(list);
 scala中的拼接
 val t1 = Traversable(11,22,33)
    val t2 = Traversable(44,55)
    val t3 = Traversable(77,88,99)
// 通过concat()方法拼接上述的三个集合.
    val t4 =Traversable.concat(t1,t2,t3)
// 打印
    println(s"t4 = ${t4}")

使用偏函数筛选元素

    //创建一个Traversble集合 ，存储元素1, to 10
    val t1 = (1 to 10).toTraversable//底层是Vector
    val t2 = Traversable(1,2,3,4,5,6,7,8,9,10) //底层是List

    //2.通过collect 方法筛选出集合中的所有函数
    //方式一
    //定义偏函数  过滤函数
    val pf:PartialFunction[Int,Int] = {
      case x if x % 2 == 0 =>x

    }
    //调用collect方法，获取t1集合中所有的偶数
    val t3 = t1.collect(pf)

    val t4 = t2.collect({
      case x if x % 2 == 0 => x
    })
    println(s"t3 = ${t3}") // t3 = Vector(2, 4, 6, 8, 10)
    println(s"t4 = ${t4}")//t4 = List(2, 4, 6, 8, 10)
  }

计算集合元素的阶乘

def scan[B](z: B)(op: (B, B) => B)

[B]表示返回值的数据类型.
(z: B)表示初始化值.
(op: (B, B) => B)表示一个具体的运算函数.
scan()方法等价于scanLeft()方法, 还有一个跟它相反的方法scanRight().

  //定义集合
    val t1 =  Traversable(1,2,3,4,5)
    // 假设初始化值
    //t1.scan(初始化值)(函数对象)

    /**
     *表示前一个值的阶乘值    x  1  1  2  6  24  120
     *表示要计算的下一个数据   y    1  2  3  4    5
     */
    val t2 = t1.scan(1)((x: Int, y: Int) => x * y)

    /**
     *表示前一个值的阶乘值    x  120  120  60   20   5    1
     *表示要计算的下一个数据   y       1    2    3   4    5
     */
    val t3 = t1.scanRight(1)(_*_)

    println(t2)
    println(t3)

获取集合的指定元素

集合是用来存储数据的, 既然能存储, 那肯定也可以从集合中获取到我们想要的数据如下的方法实现:

head: 获取集合的第一个元素, 如果元素不存在, 则抛出NoSuchElementException异常.
last: 获取集合的最后一个元素, 如果元素不存在, 则抛出NoSuchElementException异常.
headOption: 获取集合的第一个元素, 返回值类型是Option.
lastOption: 获取集合的最后一个元素, 返回值类型是Option.
find: 查找集合中第一个满足指定条件的元素.
slice: 截取集合中的一部分元素.

def slice(from:Int, until: Int): Traversable[A]

截取从from(起始索引)开始, 至until索引(结束索引)结束的元素, 包含from索引, 但是不包含until索引.

包左不包右

    //定义一个集合
    val t1 = Traversable(1,2,3,4,5,6)
//    //获取第一个元素
//    println(t1.head)
    println(t1.headOption)

//    //获取最后一个
//    println(t1.last)
    println(t1.lastOption)
    println("-"*17)
      //find方法 获取集合中的第一个数，打印
    println(t1.find(_ % 2 == 0))
    println("-"*17)
    //slice 截取
    println(t1.slice(2,4))//包左不包右

Some(1)
Some(6)
-----------------
Some(2)
-----------------
List(3, 4)

聚合函数

如果我们想统计集合中满足条件的元素个数, 或者计算集合元素和, 乘积, 求最大值, 最小值等操作 ,

count: 统计集合中满足条件的元素个数.
```
def count(p: (A) => Boolean): Int
```
sum: 获取集合中所有的元素和.
product: 获取集合中所有的元素乘积.
max: 获取集合中所有元素的最大值.
min: 获取集合中所有元素的最小值.

//聚合函数
//定义一个集合
val t1 = (1 to 10).toTraversable

// 通过count()方法来统计所有奇数的个数，并打印结果
println(t1.count(_%2 !=0))
5
//通过sum() 方法 统计所有元素的和
println(t1.sum)
55
//通过product 获取所有集合中元素的乘积
println(t1.product)
3628800
//通过max()获取集合中元素的最大值
println(t1.max)
10
//通过min()获取集合中元素的最小值
println(t1.min)
1

集合类型转换

有时候, 我们需要将Traversable集合转换成其他的集合来进行操作, 这时候就要用toXxx()方法了.

//定义集合
val t1 = (1 to 5).toTraversable
//将集合转换为 数组  列表  集
val arr = t1.toArray
val list = t1.toList
val set = t1.toSet

println(arr)
println(list)
println(set)

填充元素

如果我们需要往集合中快速添加相同元素, 例如: 生成5个都是"abc"的Traversable对象,

就需要用到fill()和iterate()方法了,

那如果是想生成指定间隔的队列元素, 就可以通过range()方法来实现

fill()方法: 快速生成指定数量的元素.
iterate()方法: 根据指定的条件, 生成指定个数的元素.
range()方法: 生成某个区间内的指定间隔的所有数据.

//生成元素为5个，元素内容为强哥牛逼的Traversable集合
val t1 = Traversable.fill(5)("强哥牛逼")
println(t1)

//生成三个随机数
println(Traversable.fill(3)(Random nextInt (100)))
//生成元素为5个对象（每个元素对象都是一个集合对象 2 集合的长度为2），元素内容为强哥牛逼的Traversable集合
println(Traversable.fill(5, 2)("强哥牛逼"))

//1表示初始化值，5表示最终获取的元素的个数， _ * 10 表示具体的规则
println(Traversable.iterate(1, 5)(_ * 10))

//通过range() 方法 获取从1开始，截止数组21之间，间隔为5的所有数据（包左不包右）
println(Traversable.range(1,21,5))
//没有传入间隔，默认的间隔为1
println(Traversable.range(1,21))

List(强哥牛逼, 强哥牛逼, 强哥牛逼, 强哥牛逼, 强哥牛逼)
List(26, 26, 67)
List(List(强哥牛逼, 强哥牛逼), List(强哥牛逼, 强哥牛逼), List(强哥牛逼, 强哥牛逼), List(强哥牛逼, 强哥牛逼), List(强哥牛逼, 强哥牛逼))
List(1, 10, 100, 1000, 10000)
List(1, 6, 11, 16)
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

案例

定义一个Traversable集合, 包含5个学生(属性为: 姓名, 年龄)的信息, 且学生的姓名和年龄信息是随机生成的.
- 假设姓名信息为(“张三”, “李四”, “王五”, “赵六”, “田七”), 年龄的取值范围是: [20, 30), 前闭后开写法.
按照学生的年龄信息降序排列后, 将结果打印到控制台上.

//创建Student的样例类，
case class Student(name:String,age:Int)

def main(args: Array[String]): Unit = {
  //定义列表来记录学生信息
  val names = List("张三", "李四", "王五", "赵六", "田七")
  //创建随机数R
  val R = new Random()
  //创建Traversable 集合 包含学生信息
  val t1 = Traversable.fill(5)(Student(names(R.nextInt(names.size)), R.nextInt(10) + 20))
    //将t1转换为List列表
    val list = t1.toList
  //排序 降序排列
  //val list1 = list.sortBy(_.age).reverse // sortBy默认的升序排列 ，反转就成降序排列了

  val list1 = list.sortWith(_.age > _.age) // > 降序排列
  println(list1)
}