Scala --- Array方法大全（二）

客官°小女子只卖身不卖艺 2024-03-25 21:45 35阅读 0赞

**目录**

init 返回当前序列中不包含最后一个元素的序列

inits 对集合中的元素进行 init 操作

intersect 取两个集合的交集

isDefinedAt 判断序列中是否存在指定索引

isEmpty 判断当前序列是否为空

isTraversableAgain 判断序列是否可以反复遍历

iterator 对序列中的每个元素产生一个 iterator

last 取得数组中最后一个元素

lastIndexOf 取得序列中最后一个等于 elem 的元素的位置，索引值

lastIndexOfSlice 获取某值最后一次出现索引

lastIndexWhere 返回当前序列中最后一个满足条件的元素的索引

lastOption 返回当前数组中最后一个对象，

length 返回当前序列中元素个数

lengthCompare 参数和数组长度作比较

lift 按给定索引取值

map 对序列中的元素进行操作

max 返回序列中最大的元素

maxBy 返回序列中第一个符合条件的元素

min 返回序列中最小的元素

minBy 返回序列中第一个不符合条件的元素

mkString 将所有元素组合成一个字符串

mkString

mkString(sep: String) 分隔符

mkString(start: String, sep: String, end: String) 分隔符和开头结尾

nonEmpty 判断序列不是空

orElse 返回参数

padTo 扩充数列

par 将集合转换为并行集合

partition 拆分序列

patch 批量替换

permutations 排列组合

prefixLength 返回给定长度的序列长度

product 返回所有元素乘积的值

reduce 二元运算

reduceLeft 从左向右计算

reduceRight 从右向左计算

reduceLeftOption

reduceRightOption

repr 将序列对象转化为供解释器读取的形式

reverse 反转序列

reverseIterator 反向生成迭代

reverseMap 同 map 方向相反

runWith 判断参数是否在序列中

--------------------

### init 返回当前序列中不包含最后一个元素的序列 ###

**语法**：def init: Array\[T\]  
**注解**：返回当前序列中不包含最后一个元素的序列

var a = Array(1, 2, 3, 4, 5)
        var b = a.init
        print(b.mkString(","))

![f8e6658a52284473ade751ecf7c7357f.png][]

### inits 对集合中的元素进行 init 操作 ###

**语法：**def inits: collection.Iterator\[Array\[T\]\]  
**注解：**对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象

var e = Array(1, 2, 3)
    e.inits.foreach(x => println(x.mkString(",")))

![2f7bc35064704dddbc12e20cd5bc0725.png][]

### intersect 取两个集合的交集 ###

**语法**：def intersect(that: collection.Seq\[T\]): Array\[T\]  
**注解**：取两个集合的交集

var a = Array(1, 2, 3, 4, 5)
        var b = Array(3, 4, 5, 6, 7)
        print(a.intersect(b).mkString(","))

![287040d5455447dc8c2e48af76763998.png][]

### isDefinedAt 判断序列中是否存在指定索引 ###

**语法**：def isDefinedAt(idx: Int): Boolean  
**注解**: 判断序列中是否存在指定索引

var a = Array(1, 2, 3, 4, 5, 6, 7)
        println(a.isDefinedAt(1))
        print(a.isDefinedAt(10))

![f3562ed522654b268d6598eb5fb5b9f7.png][]

### isEmpty 判断当前序列是否为空 ###

**语法**：def isEmpty: Boolean  
**注解**：判断当前序列是否为空

var a = Array(1, 2, 3, 4, 5, 6, 7)
        var b: Array[Int] = Array()
        println(a.isEmpty)
        print(b.isEmpty)

![23eb028ee2a3430cb8cb1c48ec89b141.png][]

### isTraversableAgain 判断序列是否可以反复遍历 ###

**语法：**def isTraversableAgain: Boolean  
**注解：**判断序列是否可以反复遍历(迭代器不能反复遍历，即判断是否是迭代器)  
（该方法是GenTraversableOnce中的方法，对于 Traversables 一般返回true，对于 Iterators 返回 false，除非被复写）

var a = Array(1, 2, 3, 4, 5, 6, 7)
        print(a.isTraversableAgain)

![b963114847e14d14b14907874930d40a.png][]

### iterator 对序列中的每个元素产生一个 iterator ###

**语法**：def iterator: collection.Iterator\[T\]  
**注解**：对序列中的每个元素产生一个 iterator（任何集合都有iterator方法）

var a = Array(1, 2, 3, 4, 5, 6, 7)
        print(a.iterator)

![332262300a90419eb8e59d74697a0ece.png][]

### last 取得数组中最后一个元素 ###

**语法**：def last: T  
**注解**：取得序列中最后一个元素

var a = Array(1, 2, 3, 4, 5, 6, 7)
        print(a.last)

![3c0b4cce04ff40588384933feecb5fb7.png][]

### lastIndexOf 取得序列中最后一个等于 elem 的元素的位置，索引值 ###

**语法**1：def lastIndexOf(elem: T): Int  
**注解**1：取得序列中最后一个等于 elem 的元素的位置，索引值

var a = Array(1, 2, 3, 4, 5, 6, 7)
        print(a.lastIndexOf(3))

![831cd58672a34e17ae8f1115531e6aae.png][]

**语法**2：def lastIndexOf(elem: T, end: Int): Int  
**注解**2:取得序列中最后一个等于 elem 的元素的位置，可以指定在 end 之前的元素（包括end）中查找

var a = Array(1, 2, 3, 4, 5, 6, 7)
        println(a.lastIndexOf(3, 5))
        print(a.lastIndexOf(3, 1))

![b68c3de7016e49a7996f4906c22c0fbd.png][]

### lastIndexOfSlice 获取某值最后一次出现索引 ###

**语法**1：def lastIndexOfSlice\[B >: A\](that: GenSeq\[B\]): Int  
**注解**1：判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引

var a = Array(1, 2, 3, 4, 5, 6, 7, 1, 2)
        var b = Array(1, 2)
        print(a.lastIndexOfSlice(b))

![8b2796d1b0614ac0aeb4adf66b2ca3d0.png][]

**语法**2：def lastIndexOfSlice\[B >: A\](that: GenSeq\[B\], end: Int): Int  
**注解**2：:判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引，可以指定在 end 之前的元素（包括end）中查找

var a = Array(1, 2, 3, 4, 5, 6, 7, 1, 2)
        var b = Array(1, 2)
        print(a.lastIndexOfSlice(b, 5))

![7107f41c1d3949a484bbc998b881ec19.png][]

### lastIndexWhere 返回当前序列中最后一个满足条件的元素的索引 ###

**语法**1：def lastIndexWhere(p: (T) ⇒ Boolean): Int  
**注解**1：返回当前序列中最后一个满足条件 p 的元素的索引

var a = Array(1, 2, 3, 4, 5, 6, 7, 1, 2)
        print(a.lastIndexWhere(x => x < 8))

![4451063eaadc4f80b5b5ee1130926eca.png][]

**语法**2：def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int  
**注解**2：返回当前序列中最后一个满足条件 p 的元素的索引，可以指定在 end 之前（包括）的元素中查找

var a = Array(1, 2, 3, 4, 5, 6, 7, 1, 2)
        print(a.lastIndexWhere(x => x < 5, 5))

![8227118ac34542a38eda6f4912573edf.png][]

### lastOption 返回当前数组中最后一个对象， ###

**语法**：def lastOption: Option\[T\]  
**注解**：返回当前序列中最后一个对象，若序列为空，返回None

var a = Array(1, 2, 3, 4, 5, 6, 7)
        print(a.lastOption)

![114130ae369245358a33b8dcc2a5c891.png][]

### length 返回当前序列中元素个数 ###

**语法**：def length: Int  
**注解**：返回当前序列中元素个数

var a = Array(1, 2, 3, 4, 5, 6, 7)
        print(a.length)

![0b695ebb8e1d4f6882f670568be3d898.png][]

### lengthCompare 参数和数组长度作比较 ###

**语法**：def lengthCompare(len: Int): Int  
**注解**：比较序列的长度和参数 len，根据二者的关系返回不同的值，比较规则是

var a = Array(1, 2, 3)
        println(a.lengthCompare(2))
        println(a.lengthCompare(3))
        print(a.lengthCompare(5))

![f717da65f3944592ae4f0b6b486b15f6.png][]

> 比较规则：
> 
> x < 0 if this.length < len  
> x == 0 if this.length == len  
> x > 0 if this.length > len  
> 结果：this.length - len

### lift 按给定索引取值 ###

语法：def lift: A1 => Option\[B1\]  
注解：按给定索引取值，返回Optition类型的值。

val a = Array(1, 2, 3, "a")
        println(a.lift(1))
        println(a.lift(3))
        println(a.lift(5))

![09dd26b907944276b81f33459451b344.png][]

### map 对序列中的元素进行操作 ###

**语法**：def map\[B\](f: (A) ⇒ B): Array\[B\]  
**注解**：对序列中的元素进行 f 操作

var a = Array(1, 2, 3, 4, 5)
        var b = a.map(x => x * 10)
        print(b.mkString(","))

![693ca57b25e140308bcb930ad92e18cb.png][]

### max 返回序列中最大的元素 ###

**语法**：def max: A  
**注解**：返回序列中最大的元素

var a = Array(1, 2, 3, 4, 5)
        print(a.max)

![3cde2b7728944524b09633ba40dad1b6.png][]

### maxBy 返回序列中第一个符合条件的元素 ###

**语法**：def maxBy\[B\](f: (A) ⇒ B): A  
**注解**：返回序列中第一个符合条件的元素

var a = Array(1, 2, 3, 4, 5)
        print(a.maxBy(x => x > 3))

![13f1431d0d324bca94ed3be7fb90de84.png][]

### min 返回序列中最小的元素 ###

**语法**：def min: A  
**注解**：返回序列中最小的元素

var a = Array(1, 2, 3, 4, 5)
        print(a.mkString)

### minBy 返回序列中第一个不符合条件的元素 ###

**语法**：def minBy\[B\](f: (A) ⇒ B): A  
**注解**：返回序列中第一个不符合条件的元素

var a = Array(1, 2, 3, 4, 5)
        print(a.maxBy(x => x > 3))

![f64cfd60bd944d64932169c033cd382d.png][]

### mkString 将所有元素组合成一个字符串 ###

#### mkString ####

**语法**：def mkString: String  
**注解**：将所有元素组合成一个字符串

var a = Array(1, 2, 3, 4, 5)
        print(a.mkString)

![a862d7a0c56e4aa4a30cf9d330f67858.png][]

#### mkString(sep: String) 分隔符 ####

**语法**：def mkString(sep: String): String  
**注解**：将所有元素组合成一个字符串，以 sep 作为元素间的分隔符

var a = Array(1, 2, 3, 4, 5)
        print(a.mkString(","))

![c94e494a136f4ccbafe18d074d9d4b38.png][]

#### mkString(start: String, sep: String, end: String) 分隔符和开头结尾 ####

**语法：**def mkString(start: String, sep: String, end: String): String  
**注解：**将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

var a = Array(1, 2, 3, 4, 5)
        print(a.mkString("{", ",", "}"))

![2a821d71321a465a94b4d5c1192e4e90.png][]

### nonEmpty 判断序列不是空 ###

**语法**：def nonEmpty: Boolean  
**注解**：判断序列不是空

var a = Array(1, 2, 3, 4, 5, 6, 7)
        var b: Array[Int] = Array()
        println(a.nonEmpty)
        print(b.nonEmpty)

![66a42c15f7fd43fea8280549904274e1.png][]

### orElse 返回参数 ###

**语法**：def orElse\[A1 <: Int, B1 >: Any\](that: PartialFunction\[A1,B1\]): PartialFunction\[A1,B1\]  
**注解：**参数：Some；返回：如果Option不为None返回Some否则返回参数的Some

val a = Some("Hello Option")
        println(a.orElse(null))
        val c = None
        println(c.orElse(Some("New Value")))

![50045f570b534e718e1e74b20f80bf65.png][]

### padTo 扩充数列 ###

**语法**：def padTo(len: Int, elem: A): Array\[A\]  
**注解**：后补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

var a = Array(1, 2, 3, 4, 5)
        println(a.padTo(7, 0).mkString(",")) 
    //需要一个长度为 7  的新序列，空出的填充 0

![b22c8bb0aa8345cea27bb107ccac2b6a.png][]

### par 将集合转换为并行集合 ###

**语法**：def par: ParArray\[T\]  
**注解**：将集合转换为并行集合；返回一个并行实现，产生的并行序列，不能被修改。

var a = Array(1, 2, 3, 4, 5)
        print(a.par)

![5b77cf7e2faf4543bb0dccab673266bd.png][]

### partition 拆分序列 ###

**语法**：def partition(p: (T) ⇒ Boolean): (Array\[T\], Array\[T\])  
**注解**：偏函数；按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列。

var a = Array(1, 2, 3, 4, 5)
        var b: (Array[Int], Array[Int]) = a.partition(x => x > 2)
        println(b._1.mkString(","))
        print(b._2.mkString(","))

![9e0723b14f444e91bf013c55c0092b7f.png][]

>     var varue = (1, 2)
>     print(varue._1)
> 
> ![5421a53b67f148b8947459117fcc5532.png][]

### patch 批量替换 ###

**语法**：def patch(from: Int, that: GenSeq\[A\], replaced: Int): Array\[A\]  
**注解**： 批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that

var a = Array(1, 2, 3, 4, 5)
        var b = Array(3, 4, 6)
        var c = a.patch(1, b, 2)
        print(c.mkString(","))

![b0c3f80a2077472d9fa15b34b273b1a1.png][]

### permutations 排列组合 ###

语法：def permutations: collection.Iterator\[Array\[T\]\]  
注解：排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样

var a = Array(1, 2, 3, 4, 5)
        var b = a.permutations.toList 
        b.foreach(x => println(x.mkString(",")))

![c6f432105e44490aa12940302e04bc00.png][]

> **combinations**
> 
> var a = Array(1, 2, 3, 4, 5)
> 
> var c = a.combinations(5).toList
> 
> c.foreach(x => print(x.mkString(",")))
> 
> ![4034abdaa68b45d2a50bd461c8793a47.png][]

### prefixLength 返回给定长度的序列长度 ###

**语法**：def prefixLength(p: (T) ⇒ Boolean): Int  
**注解**：给定一个条件 p，截止到第一个不满足条件的元素，返回一个前置数列的长度，这个数列中的元素都满足 p

var a = Array(1, 2, 3, 4, 5)
        print(a.prefixLength(x => x < 4))

![6b90292e244049e29b24584588de9f68.png][]

### product 返回所有元素乘积的值 ###

**语法**：def product: A  
**注解**：返回所有元素乘积的值(只能是数值型)

var a = Array(1, 2, 3, 4, 5)
        println(a.product)

![ebe249e2ccf541759c09c88658130977.png][]

### reduce 二元运算 ###

**语法**：def reduce\[A1 >: A\](op: (A1, A1) ⇒ A1): A1  
**注解**：对序列中的每个元素进行二元运算(一次取2个值)，不需要初始值

var a = Array(1, 2, 3, 4, 5)
        print(a.reduce(_ + _))

![e4c46a464d4a4af48e776db0a94dfa5b.png][]

>     def seq(m: Int, n: Int): Int = {
>           var s = "seq_exp=%d+%d"
>           println(s.format(m, n))
>           return m + n
>         }
>     
>         var a = Array(1, 2, 3, 4, 5)
>         var b = a.reduce(seq)
>         println(b)
>     
>         /**
>          * seq_exp=1+2
>          * seq_exp=3+3
>          * seq_exp=6+4
>          * seq_exp=10+5
>          */

### reduceLeft 从左向右计算 ###

**语法：**def reduceLeft\[B >: A\](op: (B, T) ⇒ B): B  
**注解：**从左向右计算

var a = Array(1, 2, 3, 4)
        println(a.reduceLeft(_ + _))
        print(a.reduceLeft(_ - _))

![f8f86737bcda48978ac16aaa6ae58d2b.png][]

### reduceRight 从右向左计算 ###

**语法：**def reduceRight\[B >: A\](op: (T, B) ⇒ B): B  
**注解：**从右向左计算

var a = Array(1, 2, 3, 4, 5)
        println(a.reduceRight(_ + _))
        print(a.reduceRight(_ - _))

![73e62dc22294463fa7cc9beeecf6f348.png][]

### reduceLeftOption ###

**语法**：def reduceLeftOption\[B >: A\](op: (B, T) ⇒ B): Option\[B\]  
**注解**：计算Option，参考reduceLeft，防止空数组报错，若空，返回None

var a = Array(1, 2, 3, 4, 5)
        println(a.reduceLeftOption(_ + _))
        print(a.reduceLeftOption(_ - _))

![5b9afd35d6a64b329f3bfe8554ff08e5.png][]

### reduceRightOption ###

**语法**：def reduceRightOption\[B >: A\](op: (T, B) ⇒ B): Option\[B\]  
**注解：**计算Option，参考reduceRight，防止空数组报错，若空，返回None

var a = Array(1, 2, 3, 4, 5)
        println(a.reduceRightOption(_ + _))
        print(a.reduceRightOption(_ - _))

![fba80339d4334bed832b018d306b2d19.png][]

### repr 将序列对象转化为供解释器读取的形式 ###

**语法：**def repr: Array\[A1\]  
**注解：**将序列对象转化为供解释器读取的形式

var a = Array(1, 2, 3, 4, 5)
        print(a.repr.mkString(","))

![297f0bae0eb4499998a196ae0df2b479.png][]

### reverse 反转序列 ###

**语法**：def reverse: Array\[T\]  
**注解**：反转序列

var a = Array(1, 2, 3, 4, 5)
        print(a.reverse.mkString(","))

![ade16ca707d8405ca2cf66e3339e1efe.png][]

### reverseIterator 反向生成迭代 ###

**语法：**def reverseIterator: collection.Iterator\[T\]  
**注解：**反向生成迭代

var a = Array(1, 2, 3, 4, 5)
        print(a.reverseIterator.mkString(","))

![0891f6855a2941fe9e6d952a9f14b607.png][]

### reverseMap 同 map 方向相反 ###

**语法**：def reverseMap\[B\](f: (A) ⇒ B): Array\[B\]  
**注解**：同 map 方向相反

var a = Array(1, 2, 3, 4, 5)
        var b = a.reverseMap(x => x + 1)
        println(b.mkString(","))

![ee2e38a4f322451594a371dd26eae80c.png][]

### **runWith** 判断参数是否在序列中 ###

**语法：**def runWith\[U\](action: A1 => U): Int => Boolean  
**注解：**执行偏函数，当参数不在定义域内时，返回false，否则返回true，并执行action

var b = Array.range(1, 20)
        print(b.runWith(x => x match {
          case x if x % 2 == 0 => x
        })(17))

![ed38c2c8ce83402bae1139ae28af17a7.png][]

[f8e6658a52284473ade751ecf7c7357f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c53cfa77eab34c499ec9a51c06e58de5.png
[2f7bc35064704dddbc12e20cd5bc0725.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/80c1e498af774a2c9e57b5ae22ad6e1a.png
[287040d5455447dc8c2e48af76763998.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e758f63fc3194730bb7c88b4ad0cc63d.png
[f3562ed522654b268d6598eb5fb5b9f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b36f2c7185684be4b6a8222d995fb78d.png
[23eb028ee2a3430cb8cb1c48ec89b141.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/cb8d3e3f0fae4c9fbc68e5403065c232.png
[b963114847e14d14b14907874930d40a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e56193c62e7a4cd8bff4ad5506877eac.png
[332262300a90419eb8e59d74697a0ece.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/6166a2102af94d45810bf16f2dddde4b.png
[3c0b4cce04ff40588384933feecb5fb7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5e1b13a9721544ae8f8d42759b4931be.png
[831cd58672a34e17ae8f1115531e6aae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/db65e72234814313a3de703ed274c12e.png
[b68c3de7016e49a7996f4906c22c0fbd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/41cf9cbfa7754abd8384bad220487a9c.png
[8b2796d1b0614ac0aeb4adf66b2ca3d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fa091093ef9f4c438723daeeb2e898eb.png
[7107f41c1d3949a484bbc998b881ec19.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/55518ada9dd545f6be25cacc07b5748a.png
[4451063eaadc4f80b5b5ee1130926eca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/795f43a506d4445b8a80637faaf204cd.png
[8227118ac34542a38eda6f4912573edf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fccb08a99887485384d1c4028190c6fc.png
[114130ae369245358a33b8dcc2a5c891.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ab0550366ed64a108d0ffc7614a4b908.png
[0b695ebb8e1d4f6882f670568be3d898.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5d7e383abf9a43459d830f3ca5ebc59c.png
[f717da65f3944592ae4f0b6b486b15f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fa48c8f3fae54d069e615adf516e85c3.png
[09dd26b907944276b81f33459451b344.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2641f8f7e613442c8627024cdc5f2d46.png
[693ca57b25e140308bcb930ad92e18cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8d6cbc293dfc4cf58d23d664140aa769.png
[3cde2b7728944524b09633ba40dad1b6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/9c88afa45cfe47d1acc2d6692469593b.png
[13f1431d0d324bca94ed3be7fb90de84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/69391221189649a58e9a386131855472.png
[f64cfd60bd944d64932169c033cd382d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/548f9c6141a84299be1accf5e4cb4cbd.png
[a862d7a0c56e4aa4a30cf9d330f67858.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/81ea9f90987d490cab9293c7ed601984.png
[c94e494a136f4ccbafe18d074d9d4b38.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bf2bea2eee2a48a8910cee9b3e2e4573.png
[2a821d71321a465a94b4d5c1192e4e90.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/27082325163142cc9927d0719009ce3b.png
[66a42c15f7fd43fea8280549904274e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0960153867a54dec8bb98f335ee91b3d.png
[50045f570b534e718e1e74b20f80bf65.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0c94e4de410143ec910b4e42e0e7f85f.png
[b22c8bb0aa8345cea27bb107ccac2b6a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1ab7d743c1d640229df92fe6c023d4d9.png
[5b77cf7e2faf4543bb0dccab673266bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/844150ff697543adbe0b333213e75484.png
[9e0723b14f444e91bf013c55c0092b7f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d456f0040d26453280f6fcd3d65e712a.png
[5421a53b67f148b8947459117fcc5532.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c25ee76daa6241e38170ca3585ee3ac8.png
[b0c3f80a2077472d9fa15b34b273b1a1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8558362b31ea4bb6b1885156ab939520.png
[c6f432105e44490aa12940302e04bc00.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bb62c0d93eb448f29acd8f82147b8831.png
[4034abdaa68b45d2a50bd461c8793a47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/11259e4691cd4534b994f3fd09a945ed.png
[6b90292e244049e29b24584588de9f68.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f2edfb17afdf432a895e706b3ce91e88.png
[ebe249e2ccf541759c09c88658130977.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/51f34029ad414eafb20e0d7f74244783.png
[e4c46a464d4a4af48e776db0a94dfa5b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d7076527ba1a4f4692aeb02b98dc5d88.png
[f8f86737bcda48978ac16aaa6ae58d2b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3ea5a436fc0249668f391eee5e21e38b.png
[73e62dc22294463fa7cc9beeecf6f348.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ea260d53561d4ae9a56663a09e933a10.png
[5b9afd35d6a64b329f3bfe8554ff08e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e4afa0712fe144239b018b55013a628a.png
[fba80339d4334bed832b018d306b2d19.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e5ceb032839a49339fb22055bdd055eb.png
[297f0bae0eb4499998a196ae0df2b479.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/9c20d095ef4f46f885b95b6436fdc3d4.png
[ade16ca707d8405ca2cf66e3339e1efe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/807abc450a2e4d0181bc92b86cd910d9.png
[0891f6855a2941fe9e6d952a9f14b607.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4ea30ac53d7049f0a7e41133b9979931.png
[ee2e38a4f322451594a371dd26eae80c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b55dc46c91dc406eb8add22d3712e028.png
[ed38c2c8ce83402bae1139ae28af17a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0b760a11187340c998f3f55f261d4001.png