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

亦凉 2024-03-25 22:25 42阅读 0赞

**目录**

sameElements 判断两个序列是否顺序和对应位置上的元素都一样

scan 对数组进行二元运算

scanLeft 从左向右计算

scanRight 从右向左计算

segmentLength 返回满足条件索引处后面元素长度

seq 产生一个引用当前序列的 sequential 视图

size 返回元素个数

slice 取出范围内元素

sliding 新序列

sliding(size: Int): collection.Iterator\[Array\[T\]\]

sliding(size: Int, step: Int): collection.Iterator\[Array\[T\]\]

sortBy 按指定的排序规则排序

sortWith 自定义排序方法

sorted 使用默认的排序规则对序列排序（升序）

span 分割序列

splitAt 从指定位置开始，把序列拆分成两个集合

startsWith 从指定偏移处，是否以某个序列开始

stringPrefix 返回 toString 结果的前缀

subSequence 返回区间内的序列

sum 求和

tail 返回除了当前序列第一个元素的其它元素组成的序列

tails 对集合中的元素进行 tail 操作

take 返回当前序列中前 n 个元素组成的序列

takeRight 从右边开始

takeWhile 从左边开始

类型转换

toArray

toBuffer

toIndexedSeq

toIterable

toIterator

toList

toMap

toSeq

toSet

toStream

toVector

toTraversable

transform 对序列中所有元素进行替换操作

transpose 矩阵转换

union 联合两个序列

unzip 组合序列（两个元素）

unzip3 组合序列（三个元素）

update 更新索引处元素

view 返回区间内的元素

withFilter 根据条件过滤元素

zip 将两个序列对应位置上的元素组成一个pair序列

zipAll 同zip不足自动填充

zipWithIndex 序列中的每个元素和它的索引组成一个序

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

### sameElements 判断两个序列是否顺序和对应位置上的元素都一样 ###

**语法**：def sameElements(that: GenIterable\[A\]): Boolean  
**注解：**判断两个序列是否顺序和对应位置上的元素都一样

var a = Array(1, 2, 3, 4, 5)
        var b = Array(1, 2, 3, 4, 5)
        var c = Array(1, 2, 3, 4, 6)
        println(a.sameElements(b))
        print(a.sameElements(c))

![c7c10aa8284a48b19bd833ec52c46b1c.png][]

### scan 对数组进行二元运算 ###

**语法：**def scan\[B >: A, That\](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom\[Array\[T\], B, That\]): That  
**注解：**用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值

var a = Array(1, 2, 3, 4, 5)
        print(a.scan(5)(_ + _).mkString(","))
        /**
         * 5
         * 5+1=6
         * 6+2=8
         * 8+3=11
         * 11+4=15
         * 15+5=20
         * */

![7d9e55f9703a4c9498daf3b5c407ba90.png][]

### **scanLeft** 从左向右计算 ###

**语法：**def scanLeft\[B, That\](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom\[Array\[T\], B, That\]): That  
**注解：**从左向右计算

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

![8feb69ee27dc434c9e435a958613f555.png][]

### **scanRight** 从右向左计算 ###

**语法：**def scanRight\[B, That\](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom\[Array\[T\], B, That\]): That  
**注解：**从右向左计算

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

![b005276046e645c8bb1a9751cc14b19d.png][]

### segmentLength 返回满足条件索引处后面元素长度 ###

**语法**：def segmentLength(p: (T) ⇒ Boolean, from: Int): Int  
**注解**：从序列的索引 from 处开始向后查找，所有满足 p 的连续元素的长度

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

![06ef32ae6a7d469dbce412b5c4e9bd94.png][]

### seq 产生一个引用当前序列的 sequential 视图 ###

**语法**：def seq: collection.mutable.IndexedSeq\[T\]  
**注解**：产生一个引用当前序列的 sequential 视图

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

![5c1c7eab712f4de1a76b2df99dbf533f.png][]

### size 返回元素个数 ###

**语法**：def size: Int  
**注解**：序列元素个数，同 length

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

![75fe9a3ae312420ab44e95c8881c045e.png][]

### slice 取出范围内元素 ###

**语法**：def slice(fro m: Int, until: Int): Array\[T\]  
**注解**：取出当前序列中，from 到 until 之间的片段(左包右不包)

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

![c249ee08a8f1422ca83820bd89c0e00f.png][]

### sliding 新序列 ###

#### sliding(size: Int): collection.Iterator\[Array\[T\]\] ####

**语法:** def sliding(size: Int): collection.Iterator\[Array\[T\]\]  
**注解:**从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止

var a = Array(1, 2, 3, 4, 5)
        var b = a.sliding(3).toList
        for (i <- 0 to b.length - 1) {
          var s = "第%d个：%s"
          println(s.format(i, b(i).mkString(",")))
        }

![c3da4777ed0e461eb883663c78d68cdc.png][]

#### sliding(size: Int, step: Int): collection.Iterator\[Array\[T\]\] ####

**语法：**def sliding(size: Int, step: Int): collection.Iterator\[Array\[T\]\]  
**注解：**从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止该方法，可以设置步进 step，第一个元素组合完后，下一个从 上一个元素位置+step后的位置处的元素开始

var a = Array(1, 2, 3, 4, 5)
        var b = a.sliding(3, 2).toList //第一个从1开始， 第二个从3开始，因为步进是 2
        for (i <- 0 to b.length - 1) {
          var s = "第%d个：%s"
          println(s.format(i, b(i).mkString(",")))
        }

![633c8d1730a1476daf615b05180dfec8.png][]

### sortBy 按指定的排序规则排序 ###

**语法**：def sortBy\[B\](f: (T) ⇒ B)(implicit ord: math.Ordering\[B\]): Array\[T\]  
**注解**：按指定的排序规则排序

var a = Array(3, 2, 1, 4, 5)
        var b = a.sortBy(x => x)
        println(b.mkString(","))
        //倒序
        var c = a.sortBy(x => -x)
        println(c.mkString(","))

![77d40def44c6421e80c9c319b0db4c91.png][]

### sortWith 自定义排序方法 ###

**语法**：def sortWith(lt: (T, T) ⇒ Boolean): Array\[T\]  
**注解**：自定义排序方法

var a = Array(3, 2, 1, 4, 5)
        var b = a.sortWith(_.compareTo(_) > 0) 
        println(b.mkString(","))
        var c = a.sortWith(_.compareTo(_) < 0)  
        println(c.mkString(","))

![44c648e573654b209779ae68f9d75222.png][]

### sorted 使用默认的排序规则对序列排序（升序） ###

**语法**：def sorted\[B >: A\](implicit ord: math.Ordering\[B\]): Array\[T\]  
**注解**：使用默认的排序规则对序列排序（升序）

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

![f02322d44c334221b3836d773a4086d3.png][]

### span 分割序列 ###

**语法**：def span(p: (T) ⇒ Boolean): (Array\[T\], Array\[T\])  
**注解**：分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合

var a = Array(3, 2, 1, 4, 5)
        var b = a.span(x => x > 2)
        println(b._1.mkString(","))
        println(b._2.mkString(","))

![6b4e1f6d698944759de89e92ec939b51.png][]

### splitAt 从指定**位置**开始，把序列拆分成**两个集合** ###

**语法**：def splitAt(n: Int): (Array\[T\], Array\[T\])  
**注解**：从指定**位置**开始，把序列拆分成**两个集合**

var a = List(3, 2, 1, 4, 5)
        println(a.splitAt(2))

![23c31012e8a741728a2124848147c3cc.png][]

### startsWith 从指定偏移处，是否以某个序列开始 ###

**语法**1：def startsWith\[B\](that: GenSeq\[B\], offset: Int): Boolean  
**注解**1：从指定偏移处，是否以某个序列开始

var a = Array(0, 1, 2, 3, 4, 5)
        var b = Array(1, 2)
        println(a.startsWith(b, 1))

![32defc798f254eaa8b76962e6d2ef222.png][]

**语法**2：def startsWith\[B\](that: GenSeq\[B\]): Boolean  
**注解**2：是否以某个序列开始

var a = Array(0, 1, 2, 3, 4, 5)
        var b = Array(0, 1)
        var c = Array(1, 2)
        println(a.startsWith(b))
        println(a.startsWith(c))

![8780bf3cc65b4eaf869876de2e0c0929.png][]

### stringPrefix 返回 toString 结果的前缀 ###

**语法**：def stringPrefix: String  
**注解**：返回 toString 结果的前缀

var a = Array(0, 1, 2, 3, 4, 5)
        println(a.toString())
        var b = a.stringPrefix
        println(b)

![7554f9711d084816bc3d29c0c0bd5184.png][]

### subSequence 返回区间内的序列 ###

**语法**：def subSequence(start: Int, end: Int): CharSequence  
**注解**：返回 start 和 end 间的字符序列(数组类型必须是Array\[Char\])(左包右不包)

var chars = Array('a', 'b', 'c', 'd')
        var b = chars.subSequence(0, 3)
        println(b.toString)

![99a2666ed5a4446787d85a2357d31666.png][]

### sum 求和 ###

**语法**：def sum: A  
**注解**：序列求和，元素需为Numeric\[T\]类型

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

![f7e1d00894b642c0a54ebd15aa3b528e.png][]

### tail 返回除了当前序列第一个元素的其它元素组成的序列 ###

**语法**：def tail: Array\[T\]  
**注解**：返回除了当前序列第一个元素的其它元素组成的序列（与init相反）

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

![a86300a74a264179b99e8b8208eb048d.png][]

### tails 对集合中的元素进行 tail 操作 ###

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

var a = Array(1, 2, 3, 4, 5)
        var b = a.tails.toList
        for (i <- 1 to b.length) {
          var s = "第%d个值：%s"
          println(s.format(i, b(i - 1).mkString(",")))
        }

![453df2614d104f0eb4f93489a169539c.png][]

### take 返回当前序列中前 n 个元素组成的序列 ###

**语法**：def take(n: Int): Array\[T\]  
**注解**：返回当前序列中前 n 个元素组成的序列

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

![774ca688e720446f822e29649221f8fa.png][]

### takeRight 从右边开始 ###

**语法**：def takeRight(n: Int): Array\[T\]  
**注解**：返回当前序列中，从右边开始，选择 n 个元素组成的序列

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

![7bd4f2b62a1146a0a2db172f26f8c56a.png][]

### takeWhile 从左边开始 ###

**语法**：def takeWhile(p: (T) ⇒ Boolean): Array\[T\]  
**注解**：返回当前序列中，从第一个元素开始，到第一不满足条件的元素为止，满足条件的连续元素组成的序列。

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

![2f44d81d25cb4198a441ba29ce2f1aec.png][]

### 类型转换 ###

#### toArray ####

**语法**：def toArray: Array\[A\]  
**注解**：转换成 Array 类型

scala> var a = List(1,2,3,4)
    a: List[Int] = List(1, 2, 3, 4)
    
    scala> a.toArray
    res0: Array[Int] = Array(1, 2, 3, 4)

![b3ad5a44b0c140fa9468d1bfe0150fd8.png][]

#### toBuffer ####

**语法**：def toBuffer\[A1 >: A\]: Buffer\[A1\]  
**注解**：转换成 Buffer 类型

scala> a.toBuffer
    res1: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4)

![201331c0e4be4ba4800c7ba5105145d8.png][]

#### toIndexedSeq ####

**语法：**def toIndexedSeq: collection.immutable.IndexedSeq\[T\]  
**注解：**转换成 IndexedSeq 类型

scala> a.toIndexedSeq
    res2: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4)

![448564857e9d486ebe920d9e3499cef4.png][]

#### toIterable ####

**语法：**def toIterable: collection.Iterable\[T\]  
**注解**: 转换成可迭代的类型

scala> a.toIterable
    res0: Iterable[Int] = List(1, 2, 3, 4)

![75e1dcfc05b543fe86a056ed591d4be8.png][]

#### toIterator ####

**语法**：def toIterator: collection.Iterator\[T\]  
**注解**：同 iterator 方法

scala> a.toIterator
    res1: Iterator[Int] = <iterator>

![8d9f39dc65c349b797ce47e2434a08ea.png][]

#### toList ####

**语法**：def toList: List\[T\]  
**注解**：同 List 类型

scala> var b = Array(1,2,3,4,5)
    b: Array[Int] = Array(1, 2, 3, 4, 5)
    
    scala> b.toList
    res3: List[Int] = List(1, 2, 3, 4, 5)

![4e5d1b40292d41b0b2e77300292c4208.png][]

#### toMap ####

**语法**：def toMap\[T, U\]: Map\[T, U\]  
**注解**：同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据

var chars = Array(("a", "b"), ("c", "d"), ("e", "f"))
        var b = chars.toMap
        println(b)
        var a = Array(1, 3, 4, 5, 2, 5)
        var c = a.map((_, 1))
        var d = c.toMap
        println(d)

![4a0bfff750344db9b2649fd8ad4b3fab.png][]

#### toSeq ####

**语法**：def toSeq: collection.Seq\[T\]  
**注解**：同 Seq 类型

scala> b.toSeq
    res5: Seq[Int] = WrappedArray(1, 2, 3, 4, 5)

![6568f32d84fe429bac18bc42d017afb4.png][]

#### toSet ####

**语法**：def toSet\[B >: A\]: Set\[B\]  
**注解**：同 Set 型

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

![97e7a72577244897a465710f8835f346.png][]

#### toStream ####

**语法**：def toStream: collection.immutable.Stream\[T\]  
**注解**：同 Stream 类型(流)

scala> b.toStream
    res7: scala.collection.immutable.Stream[Int] = Stream(1, ?)

![025c551282f04cde946a69736cd581b7.png][]

#### toVector ####

**语法**：def toVector: Vector\[T\]  
**注解**：同 Vector 类型

scala> b.toVector
    res8: Vector[Int] = Vector(1, 2, 3, 4, 5)

![7601b7cdfa92432da1a85ad21f0ac45f.png][]

#### toTraversable ####

**语法**：def toTraversable: Traversable\[T\]  
**注解**：同 Traversable类型

scala> b.toTraversable
    res9: Traversable[Int] = WrappedArray(1, 2, 3, 4, 5)

![c760f9e8ae20471e947ce8377a4c3606.png][]

### transform 对序列中所有元素进行替换操作 ###

**语法**： def transform(f: T => T): scala.collection.mutable.WrappedArray\[T\]  
**注解**：提供一个lambda表达式，对序列中所有元素进行替换操作

val a = Array(1, 2, 3, 4, 5)
        println(a.transform(x => 6))
        val c = Array(1, 3, "a", Array(1, 2))
        print(a.transform(x => 8))

![e089673741fb480b9c509cc5b9e13ce9.png][]

### transpose 矩阵转换 ###

**语法**：def transpose\[U\](implicit asArray: (T) ⇒ Array\[U\]): Array\[Array\[U\]\]  
**注解**：矩阵转换，二维数组行列转换(转置)

scala> var k = Array(Array(1, 3, 2), Array(5, 8, 2), Array(7, 9, 8), Array(2, 7, 5))
    k: Array[Array[Int]] = Array(Array(1, 3, 2), Array(5, 8, 2), Array(7, 9, 8), Array(2, 7, 5))
    
    scala> k.transpose
    res0: Array[Array[Int]] = Array(Array(1, 5, 7, 2), Array(3, 8, 9, 7), Array(2, 2, 8, 5))

![fe951f682f7241b2886e718d0e20c1ff.png][]

### union 联合两个序列 ###

**语法**：def union(that: collection.Seq\[T\]): Array\[T\]  
**注解**：联合两个序列，同操作符 ++(不去重)

var a = Array(1, 2, 3, 4, 5)
        var b = Array(6, 7)
        var c = a.union(b)
        println(c.mkString(","))

![c7a7aa91a08b4223876d5a71d538ff41.png][]

### unzip 组合序列（两个元素） ###

**语法：**def unzip\[T1, T2\](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag\[T1\], ct2: ClassTag\[T2\]): (Array\[T1\], Array\[T2\])  
**注解：**将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列

var chars = Array(("a", "b"), ("c", "d"))
        var b = chars.unzip
        println(b._1.mkString(","))
        println(b._2.mkString(","))

![0a595f46e6fa44f094f13fbb29666321.png][]

### unzip3 组合序列（三个元素） ###

**语法：**def unzip3\[T1, T2, T3\](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag\[T1\], ct2: ClassTag\[T2\], ct3: ClassTag\[T3\]): (Array\[T1\], Array\[T2\], Array\[T3\])  
**注解：**将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列

var chars = Array(("a", "b", "x"), ("c", "d", "y"), ("e", "f", "z"))
        var b = chars.unzip3
        println(b._1.mkString(","))
        println(b._2.mkString(","))
        println(b._3.mkString(","))

![289fd65802f8409c8efc1fbc1aa4dce3.png][]

### update 更新索引处元素 ###

**语法**1：def update(i: Int, x: T): Unit  
**注解**：将序列中 i 索引处的元素更新为 x

var a = Array(1, 2, 3, 4, 5)
        a.update(1, 9)
        println(a.mkString(","))

![e543181f21774f9c8f0a2759b89338a8.png][]

**语法**2：def updated(index: Int, elem: A): Array\[A\]  
**注解**：将序列中 i 索引处的元素更新为 x ,并返回替换后的数组

var a = Array(1, 2, 3, 4, 5)
        var b = a.view(1, 3).toArray
        println(b.mkString(","))

![6657592bff444ce5abc9d34c1b68d493.png][]

### view 返回区间内的元素 ###

**语法**：def view(from: Int, until: Int): IndexedSeqView\[T, Array\[T\]\]  
**注解**：返回 from 到 until 间的序列，不包括 until 处的元素

var a = Array(1, 2, 3, 4, 5)
        var b = a.view(1, 3).toArray
        println(b.mkString(","))

![cf9e467fed7848efbad75a66c3cd22e7.png][]

### withFilter 根据条件过滤元素 ###

**语法**：def withFilter(p: (T) ⇒ Boolean): FilterMonadic\[T, Array\[T\]\]  
**注解**：根据条件 p 过滤元素(返回特殊类型FilterMonadic\[T, Array\[T\]\])

var a = Array(1, 2, 3, 4, 5)
        var b = a.withFilter(x => x > 3)
        var c = b.map(x => x)
        println(c.mkString(","))

![58bc411cd6d3401d9588639a07896dc8.png][]

### zip 将两个序列对应位置上的元素组成一个pair序列 ###

**语法**：def zip\[B\](that: GenIterable\[B\]): Array\[(A, B)\]  
**注解**：将两个序列对应位置上的元素组成一个pair序列

var a = Array(1, 2, 3, 4, 5)
            var b = Array(5, 4, 3, 2, 1)
            var c = a.zip(b)
            println(c.mkString(","))

![6694880470ca47759d35f3fb027746e3.png][]

### zipAll 同zip不足自动填充 ###

**语法：**def zipAll\[B\](that: collection.Iterable\[B\], thisElem: A, thatElem: B): Array\[(A, B)\]  
**注解：**同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem

var a = Array(1, 2, 3, 4, 5, 6, 7)
        var b = Array(5, 4, 3, 2, 1)
        var c = a.zipAll(b, 9, 8)
        println(c.mkString(","))

![22d88e23abf94316aa06fb879c9811c5.png][]

### zipWithIndex 序列中的每个元素和它的索引组成一个序列 ###

**语法**：def zipWithIndex: Array\[(A, Int)\]  
**注解**：序列中的每个元素和它的索引组成一个序列

var a = Array(10, 20, 30, 40)
        var b = a.zipWithIndex
        println(b.mkString(","))

![e7d1ce70393c440ea0a887ff4c65a0dc.png][]

[c7c10aa8284a48b19bd833ec52c46b1c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2cce29b89b564aa0af7326ca6d854a97.png
[7d9e55f9703a4c9498daf3b5c407ba90.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/599ee86e8547431d8cd0c28518c84918.png
[8feb69ee27dc434c9e435a958613f555.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a17830aaddb54617858c70f43add4e12.png
[b005276046e645c8bb1a9751cc14b19d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/35345ca363d0465a8062c104f550c5d7.png
[06ef32ae6a7d469dbce412b5c4e9bd94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a59c6cad61194a969518b62247c994fe.png
[5c1c7eab712f4de1a76b2df99dbf533f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b8bc97b311ff417aa9935e167e34f480.png
[75fe9a3ae312420ab44e95c8881c045e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a35090b90ee947f68de1f69cb80040ce.png
[c249ee08a8f1422ca83820bd89c0e00f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3b19db45c0454f208029ec1e6e7a6f51.png
[c3da4777ed0e461eb883663c78d68cdc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0bedc8789aab47d18ea9ac4d5698c09d.png
[633c8d1730a1476daf615b05180dfec8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/86c0bd30e4214722a391149efbb7c340.png
[77d40def44c6421e80c9c319b0db4c91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a6eef56d60b44b3da356f52bf8051047.png
[44c648e573654b209779ae68f9d75222.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bd45ded3cc104ed48b74df2c8186ab85.png
[f02322d44c334221b3836d773a4086d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/984bd8fb06b14efcb5e37b4a2fa43fba.png
[6b4e1f6d698944759de89e92ec939b51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d8a34e0f094e4916bb8320aee87eaa4b.png
[23c31012e8a741728a2124848147c3cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/587c67efd34549d1a15a122e78fee897.png
[32defc798f254eaa8b76962e6d2ef222.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1e38015da9cc4bfe8c92f2b54a87fa8e.png
[8780bf3cc65b4eaf869876de2e0c0929.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4156f163dd8b42509c039fff9c06e908.png
[7554f9711d084816bc3d29c0c0bd5184.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/998cb4cf515444aa8bfeb116f6bcbd5b.png
[99a2666ed5a4446787d85a2357d31666.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e3fc373ef8f34c87b5c46037600178dc.png
[f7e1d00894b642c0a54ebd15aa3b528e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3079cb6ac5624875aed70f8dff44db63.png
[a86300a74a264179b99e8b8208eb048d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d1f3df8df4c14f79b840b6330a07df4d.png
[453df2614d104f0eb4f93489a169539c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3234d4c879ea4f2a8569dd6dc57b9c7c.png
[774ca688e720446f822e29649221f8fa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/926f1b6ae36c4ea097f347ebeade88c2.png
[7bd4f2b62a1146a0a2db172f26f8c56a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/23448915b5734717aeb80bb52bb4dea0.png
[2f44d81d25cb4198a441ba29ce2f1aec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2d4b0b148fcc4548bbb1587f54f6d213.png
[b3ad5a44b0c140fa9468d1bfe0150fd8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3ea63ebaceee48e5b411d8176721afc9.png
[201331c0e4be4ba4800c7ba5105145d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/23a9d7abfed74c80a8c821436d6e93bb.png
[448564857e9d486ebe920d9e3499cef4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fd7aac48ef7e4df5b0d0dcf6df3d12f2.png
[75e1dcfc05b543fe86a056ed591d4be8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/20fd1d4c44574b118bbaffc4fc696029.png
[8d9f39dc65c349b797ce47e2434a08ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/406bb47f61784da79d5f7bf14968bc68.png
[4e5d1b40292d41b0b2e77300292c4208.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7978338ec3f14ff484652900826c508b.png
[4a0bfff750344db9b2649fd8ad4b3fab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3cc55d44ffc1479e8d31656c0b456167.png
[6568f32d84fe429bac18bc42d017afb4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/90cb613318d744df8bff505402f572fb.png
[97e7a72577244897a465710f8835f346.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a6036441158543fd89e67ec311538f27.png
[025c551282f04cde946a69736cd581b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f97dfc44c79d42ac98bc1c0168c7c13e.png
[7601b7cdfa92432da1a85ad21f0ac45f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b2f1e63dabf341dd82f4835601295bed.png
[c760f9e8ae20471e947ce8377a4c3606.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/37ccae73bf59454da5d92465da832c9b.png
[e089673741fb480b9c509cc5b9e13ce9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c9f75bd8076b4838acd8bd8bf0e993c9.png
[fe951f682f7241b2886e718d0e20c1ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4dabd005477b478aa61bda8c89b7e627.png
[c7a7aa91a08b4223876d5a71d538ff41.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0c0e3fb71f5042dfa1ca6c878bb7eef3.png
[0a595f46e6fa44f094f13fbb29666321.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/9530e3c0076f461eaf281ac3de9f362f.png
[289fd65802f8409c8efc1fbc1aa4dce3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f736079a0528495e835f725bdfeebcbf.png
[e543181f21774f9c8f0a2759b89338a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4823014be4a24d6aa9b02303fdeac64b.png
[6657592bff444ce5abc9d34c1b68d493.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2403c6d7452b47f78502a5ce503a0361.png
[cf9e467fed7848efbad75a66c3cd22e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f035c68f35e24046970ab8293a610e82.png
[58bc411cd6d3401d9588639a07896dc8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8c750b77c0fb4da183d405dd5925411f.png
[6694880470ca47759d35f3fb027746e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/091ee1d931cc4c42acb6acc96f3cc196.png
[22d88e23abf94316aa06fb879c9811c5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/90f9ea029694441f94bcec7b4d9ad67c.png
[e7d1ce70393c440ea0a887ff4c65a0dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4ebca076b4dd42beaa9184760bb30240.png