39、常用类之Math类、Arrays类、System类、BigInteger和BigDecimal类、日期类

野性酷女 2024-03-31 09:22 88阅读 0赞

一、Math类

1、Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数

![af4a9461be6744188e28b789aee90323.png][]

补：random返回的是0 <= x <1 之间的一个随机小数

//请写出获取a-b之间的一个随机整数，a，b均为整数，比如a=2,b=7
            //返回一个数x，范围在[2，7]
            //1、0 <= x < 1
            //2、0*(b-a) <= x*(b-a) < 1*(b-a)
            //3、x*(b-a) = Math.random()*(b-a),
            4、核心公式:(int)(a+Math.random()*(b-a+1)); 返回的是[a,b]之间的一个数
            //5、+1是因为要取[2，7]之间的整数，(int)转换后会丢失小数部分，不加1就只能取到[2，6]
            //6、答案：(int)(2+Math.random()*6)
            //答案解析：
            //Math.random()*6返回的是[0，6)
            //2+Math.random()*6返回的是[2，8)
            //(int)转换后，会丢失精度，变成[2，7]
    
    package Math_;
    public class Math_ {
        public static void main(String[] args) {
            for(int i=0;i<3;i++){
                System.out.println((int)(2+Math.random()*(7-2+1)));
                //输出：
                //3
                //2
                //5
            }
        }
    }

package Math_;
    public class Math_ {
        public static void main(String[] args) {
            int abs=Math.abs(-9);
            System.out.println(abs);//9
    
            double pow=Math.pow(2,4);
            System.out.println(pow);//16
    
            double ceil=Math.ceil(-3.001);
            System.out.println(ceil);//-3
    
            double floor=Math.floor(-4.999);
            System.out.println(floor);//-5
    
            long round=Math.round(-5.001);
            System.out.println(round);//-5 四舍五入，该参数+0.5
    
            double sqrt=Math.sqrt(9.0);
            System.out.println(sqrt);//3.0
    
            int min=Math.min(1,9);
            System.out.println(min);//1
    
            int max=Math.max(1,9);
            System.out.println(max);//9
        }
    }

二、Arrays类

1、Arrays里面包含了一系列静态方法，用于管理或操作数组（比如排序和搜索）

![e83b536102624899a641a9e2d6745895.png][]

package Math_;
    import java.util.Arrays;
    import java.util.Comparator;
    public class Math_ {
        public static void main(String[] args) {
            Integer arr[]={1,-1,7,0,89};
            Arrays.sort(arr, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    Integer i1=(Integer) o1;
                    Integer i2=(Integer) o2;
                    return i2-i1;//[89, 7, 1, 0, -1]
                }
            });
            System.out.println("=======排序后=======");
            System.out.println(Arrays.toString(arr));
            //1、因为数组是引用类型，所以通过sort排序后，会直接影响到实参arr
            //2、sort重载的，也可以通过传入一个接口Comparator实现定制排序
            //3、调用定制排序时，传入两个参数：
            //（1）排序的数组arr（2）实现了Comparator接口的匿名内部类，要求实现compare方法
    
            //追源码：
    //        while(left<right){
    //            int mid=(left-right)>>>1;
    //            if(c.compare(pivot,a[mid])<0)
    //                right=mid;
    //            else
    //                left=mid+1;
    //        }
            //public int compare(Integer o1, Integer o2) 返回的值>0还是<0
            //会影响整个排序结果
            //充分体现了 接口编程+动态绑定+匿名内部类 的综合使用
        }
    }

//对上面的定制排序方法加以解释说明：
    package Math_;
    
    import java.util.Arrays;
    import java.util.Comparator;
    
    public class Math_ {
        public static void main(String[] args) {
            int[] arr={1,-1,8,0,20};
            bubble01(arr);
            System.out.println("====排序后====");
            System.out.println(Arrays.toString(arr));
            //====排序后====
            //[-1, 0, 1, 8, 20]
    
            bubble02(arr, new Comparator() {
                @Override
                public int compare(Object o1, Object o2) {
                    Integer i1=(Integer) o1;
                    Integer i2=(Integer) o2;
                    return i2-i1;
                    //如果是return i1-i2;则输出：
                    //====定制排序后====
                    //[-1, 0, 1, 8, 20]
                }
            });
            System.out.println("====定制排序后====");
            System.out.println(Arrays.toString(arr));
            //====定制排序后====
            //[20, 8, 1, 0, -1]
        }
    
        //冒泡排序
        public static void bubble01(int[] arr){
            int temp=0;
            for(int i=0;i<arr.length-1;i++){
                for(int j=0;j<arr.length-1-i;j++){
                    if(arr[j]>arr[j+1]){
                        temp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                    }
                }
            }
        }
    
        //结合冒泡+定制
        public static void bubble02(int[] arr,Comparator c){
            int temp=0;
            for(int i=0;i<arr.length-1;i++){
                for(int j=0;j<arr.length-1-i;j++){
                    //数组排序由c.compare(arr[j],arr[j+1])返回的值决定
                    //>0 表示前面的数大，要交换
                    if(c.compare(arr[j],arr[j+1])>0){
                        temp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                    }
                }
            }
        }
    }

package Math_;
    
    import java.util.Arrays;
    
    public class Math_ {
        public static void main(String[] args) {
            Integer[] arr={1,2,90,123,567};
            //1、使用binarySearch二叉查找
            //2、要求该数组必须是有序，才可使用binarySearch
            //3、如果数组中不存在该元素，就返回return -(low+1);low是它本该在位置
            int index= Arrays.binarySearch(arr,92);
            System.out.println("index="+index);//index=-4 //-(3+1)
        }
    }

![3c2771aba2e44403812ca0b96d2c86e9.png][]

package Math_;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Math_ {
        public static void main(String[] args) {
            Integer[] arr={1,2,90,123,567};
            Integer[] arr2={1,2,90,123,567};
            //1、从arr数组中，拷贝arr.length个元素到newArr数组中
            //2、如果拷贝的长度 > arr.length就在新数组后面增加null
            //3、如果拷贝的长度 < 0就抛出异常NegativeArraySizeException
            System.out.println("====拷贝执行完毕后====");
            Integer[] newArr=Arrays.copyOf(arr,arr.length);
            System.out.println(Arrays.toString(newArr));
            //====拷贝执行完毕后====
            //[1, 2, 90, 123, 567]
    
            Integer[] num=new Integer[]{9,3,2};
            //使用99去填充num数组，可以理解成是替换原来的元素
            System.out.println("====数组填充后====");
            Arrays.fill(num,99);
            System.out.println(Arrays.toString(num));
            //====数组填充后====
            //[99, 99, 99]
    
            boolean equals=Arrays.equals(arr,arr2);
            System.out.println(equals);//true
            //如果两个数组元素完全一样，则返回true，否则返回false
    
            List asList=Arrays.asList(2,3,4,5,6);
            System.out.println(asList);
            System.out.println("asList的运行类型："+asList.getClass());
            //[2, 3, 4, 5, 6]
            //asList的运行类型：class java.util.Arrays$ArrayList
            
            //ArrayList是Arrays的一个静态内部类
        }
    }

2、练习题

![8081100873404d78b643c8fa512f9bac.png][]

//我的代码

package Math_;
    
    import java.util.Comparator;
    
    public class ArraysExercise {
        public static void main(String[] args) {
            Book[] books=new Book[4];
            books[0]=new Book("红楼梦~",100);
            books[1]=new Book("金瓶梅~",90);
            books[2]=new Book("青年文摘~",5);
            books[3]=new Book("java从入门到放弃~",300);
            bubbleSort(books, new Comparator() {
                @Override
                public int compare(Object o1, Object o2) {
                    Integer i1=(Integer) o1;
                    Integer i2=(Integer) o2;
                    return i2-i1;
                }
            });
            System.out.println("====定制排序后====");
            for(int i=0;i<books.length;i++){
                System.out.println(books[i].getName()+" "+books[i].getPrice());
            }
        }
        public static void bubbleSort(Book[] books, Comparator c){
            Book temp=null;
            for(int i=0;i<books.length-1;i++){
                for(int j=0;j<books.length-1-i;j++){
                    if(c.compare(books[j].getPrice(),books[j+1].getPrice())>0){
                        temp=books[j];
                        books[j]=books[j+1];
                        books[j+1]=temp;
                    }
                }
            }
        }
    }
    class Book{
        private String name;
        private int price;
    
        public Book(String name, int price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getPrice() {
            return price;
        }
    
        public void setPrice(int price) {
            this.price = price;
        }
    }
    //输出：====定制排序后====
    //java从入门到放弃~ 300
    //红楼梦~ 100
    //金瓶梅~ 90
    //青年文摘~ 5

//老师的代码

package Math_;
    
    import java.util.Arrays;
    import java.util.Comparator;
    
    public class ArraysExercise {
        public static void main(String[] args) {
            Book[] books=new Book[4];
            books[0]=new Book("红楼梦~",100);
            books[1]=new Book("金瓶梅~",90);
            books[2]=new Book("青年文摘~",5);
            books[3]=new Book("java从入门到放弃~",300);
            Arrays.sort(books, new Comparator() {//主要是这里不一样
                @Override
                public int compare(Object o1, Object o2) {
                    Book book1=(Book) o1;
                    Book book2=(Book) o2;
                    double priceVal= book2.getPrice()- book1.getPrice();
                    //priceVal是double型的，在这个int型方法中不能直接返回（会丢失精度），所以下面提供了一个转换
                    if(priceVal>0){
                        return 1;
                    }else if(priceVal<0){
                        return -1;
                    }else{
                        return 0;
                    }
                }
            });
            System.out.println("====定制排序后====");
            System.out.println(Arrays.toString(books));
        }
        public static void bubbleSort(Book[] books, Comparator c){
            Book temp=null;
            for(int i=0;i<books.length-1;i++){
                for(int j=0;j<books.length-1-i;j++){
                    if(c.compare(books[j].getPrice(),books[j+1].getPrice())>0){
                        temp=books[j];
                        books[j]=books[j+1];
                        books[j+1]=temp;
                    }
                }
            }
        }
    }
    class Book{
        private String name;
        private double price;
    
        public Book(String name, double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Book{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    }
    //输出：====定制排序后====
    //[Book{name='java从入门到放弃~', price=300.0}, Book{name='红楼梦~', price=100.0}, Book{name='金瓶梅~', price=90.0}, Book{name='青年文摘~', price=5.0}]

三、System类

1、常用方法

![30b16b3c00014ffeba2e406562a8393e.png][]

package Math_;
    
    public class System_ {
        public static void main(String[] args) {
            System.out.println("ok1");
            System.exit(0);
            System.out.println("ok2");
            //输出：ok1
            //解读：0表示一个状态，正常的状态
        }
    }

![3d460803347449169918944f09de9e40.png][]

package Math_;
    
    import java.util.Arrays;
    
    public class System_ {
        public static void main(String[] args) {
            int[] src={1,2,3};
            int[] dest=new int[3];//dest={0.0.0}
            System.arraycopy(src,0,dest,1,2);
            //从src的第0个位置开始，拷贝3个数据到dest的第一个位置开始
            System.out.println("dest="+ Arrays.toString(dest));//dest=[0, 1, 2]
        }
    }

package Math_;
    
    import java.util.Arrays;
    
    public class System_ {
        public static void main(String[] args) {
            System.out.println(System.currentTimeMillis());
            //1668994160694
        }
    }

四、BigInteger和BigDecimal类

1、介绍：

![b3a2c5e5e9424c36ae649d3b6a4514e9.png][]

2、常用方法：

![b2e87bce827147b48e08610adf93bc62.png][]

package Math_;
    
    import java.math.BigInteger;
    
    public class BigInteger_ {
        public static void main(String[] args) {
            //long l=1111111111111111;
            //System.out.println("l="+l);
            //在编程中，需要处理很大的整数时，long不再适用
            //引出BigInteger类来处理
    
            BigInteger bigInteger=new BigInteger("11111111111111111111111111111111");
            System.out.println(bigInteger);
            //11111111111111111111111111111111
    
            //用BigInteger进行算术运算
            BigInteger bigInteger1=new BigInteger("11111111111111111111111111111111");
            BigInteger bigInteger2=new BigInteger("11111111111111111111111111111111");
            BigInteger add=bigInteger1.add(bigInteger2);
            
            System.out.println(add);//加
            //22222222222222222222222222222222
            
            BigInteger subtract=bigInteger1.subtract(bigInteger2);
            System.out.println(subtract);//减
            //0
            
            BigInteger multiply=bigInteger1.multiply(bigInteger2);
            System.out.println(multiply);//乘
            //123456790123456790123456790123454320987654320987654320987654321
            
            BigInteger divide=bigInteger1.divide(bigInteger2);
            System.out.println(divide);//除
            //1
        }
    }

package Math_;
    
    import java.math.BigDecimal;
    import java.math.BigInteger;
    
    public class BigDecimal_ {
        public static void main(String[] args) {
            //double d=11.1111111111111111111111111111111111;
            //System.out.println(d);
            //当我们需要保存一个精度很高的数时，double不够用
            //引出BigDecimal类
    
            BigDecimal bigDecimal=new BigDecimal(1.111111111111111111111);
            System.out.println(bigDecimal);
    
            //用BigDecimal进行算术运算
            BigDecimal bigDecimal1=new BigDecimal("2.2222222222222222222222");
            BigDecimal bigDecimal2=new BigDecimal("2.2222222222222222222222");
            System.out.println(bigDecimal1.add(bigDecimal2));
            System.out.println(bigDecimal1.subtract(bigDecimal2));
            System.out.println(bigDecimal1.multiply(bigDecimal2));
            //System.out.println(bigDecimal1.divide(bigDecimal2));
            //如果相除的结果是无限循环小数，则可能抛出ArithmeticException异常
            //在调用divide方法时，指定精度即可,BigDecimal.ROUND_CEILING
            //如果有无限循环小数，就会保留和分子一样的精度
            System.out.println(bigDecimal1.add(bigDecimal2,BigDecimal.ROUND_CEILING));
    
        }
    }

五、日期类（知道怎么查，怎么用即可，不用每个方法都背）

1、第一代日期类

![e3e059efc498493fbda4e207f0e60b1d.png][]

package Math_;
    
    public class Dog {
        private String name;
        private int age;
    
        public Dog(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public void cry(){}
        class Air{}
        //说明一下diagram IDEA properties的含义
        public void setAddress(String address){}
        public double getSalary(){
            return 1.1;
        }
        //set,get方法后面的部分会自动转换成属性在类图里显示出来
    }

![3c3d298872014cb18015222e04bc04c4.png][]

![71429e62a87b427cb8d3c3c2061c96d9.png][]

![fe9cc6a8c03e474cb455618e7045a603.png][]

package Math_;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class Date01 {
        public static void main(String[] args) throws ParseException {
            //解读：
            //1、获取当前系统时间
            //2、这里的Date类是在java.util包
            //3、默认输出的日期格式是国外的方式，因此通常需要对格式进行转换
            Date d1=new Date();
            System.out.println("当前日期:"+d1);
    
            //通过指定毫秒数得到时间
            Date d2=new Date(123456);
            System.out.println("指定毫秒的日期："+d2);
    
            //获取某个时间对应的毫秒数
            System.out.println("指定日期的毫秒数："+d1.getTime());
    
            //解读：
            //1、创建SimpleDateFormat对象，可以指定相应的格式
            //2、这里的格式使用的字母是规定好的，不能乱写
            SimpleDateFormat sdf=new SimpleDateFormat("yyy年MM月dd日 HH:mm:ss E");
            String format=sdf.format(d1);//format将日期转换成指定格式的字符串
            System.out.println("当前日期:"+format);
    
            //把一个格式化的String转成对应的Date
            //在此过程中，使用的sdf格式需要和我给的String的格式一样，否则会抛出转换异常
            String s="2022年11月21日 20:45:32 周一";
            Date parse=sdf.parse(s);//有异常，抛出到方法签名处，alt+enter
            System.out.println("格式字符串转成日期（外国格式）："+parse);
            System.out.println("格式字符串转成日期（国内格式）："+sdf.format(parse));
        }
    }
    //输出：
    //当前日期:Mon Nov 21 20:58:28 CST 2022
    //指定毫秒的日期：Thu Jan 01 08:02:03 CST 1970
    //指定日期的毫秒数：1669035508258
    //当前日期:2022年11月21日 20:58:28 周一
    //格式字符串转成日期（外国格式）：Mon Nov 21 20:45:32 CST 2022
    //格式字符串转成日期（国内格式）：2022年11月21日 20:45:32 周一

2、第二代日期类

![6771454bce53424fac8bcf2f005dd906.png][]

package Math_;
    
    import java.util.Calendar;
    
    public class Calendar_ {
        public static void main(String[] args) {
            //1、Calendar是一个抽象类，并且构造器是private
            //2、可以通过getInstance()来获取实例
            //3、提供了大量的方法和字段给程序员
            //4、Calendar没有提供对应的格式化的类，需要程序员自己组合来输出
            Calendar c= Calendar.getInstance();
            System.out.println("Calendar提供的字段："+c);
    
            //获取日历对象的某个日历字段
            System.out.println("年："+c.get(Calendar.YEAR));
            System.out.println("月："+c.get(Calendar.MONTH)+1);//因为月是从0开始编号的，所以要加上1
            System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));
            System.out.println("(12小时制)小时："+c.get(Calendar.HOUR));//12小时制
            System.out.println("(24小时制)小时："+c.get(Calendar.HOUR_OF_DAY));//24小时制
            System.out.println("分钟："+c.get(Calendar.MINUTE));
            System.out.println("秒："+c.get(Calendar.SECOND));
    
            //自由组合
            System.out.println(c.get(Calendar.YEAR)+"-"+(c.get(Calendar.MONTH)+1)+"-"+
                    c.get(Calendar.DAY_OF_MONTH)+" "+c.get(Calendar.HOUR)+":"+c.get(Calendar.MINUTE)
                    +":"+c.get(Calendar.SECOND));
    
        }
    }
    //输出：
    //Calendar提供的字段：java.util.GregorianCalendar[time=1669036787267,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=4,DAY_OF_MONTH=21,DAY_OF_YEAR=325,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=9,HOUR_OF_DAY=21,MINUTE=19,SECOND=47,MILLISECOND=267,ZONE_OFFSET=28800000,DST_OFFSET=0]
    //年：2022
    //月：101
    //日：21
    //(12小时制)小时：9
    //(24小时制)小时：21
    //分钟：19
    //秒：47
    //2022-11-21 9:19:47

![33126310742648ba860451f3f4a1af66.png][]

![7dd614c2ec2446f0b0212d06d1cd2ac1.png][]

package Math_;
    
    import java.time.LocalDate;
    import java.time.LocalDateTime;
    import java.time.LocalTime;
    
    public class LocalDate_ {
        public static void main(String[] args) {
            //使用now()返回表示当前日期时间的对象
            LocalDateTime ldt=LocalDateTime.now();
            System.out.println(ldt);
            System.out.println("年:"+ldt.getYear());
            System.out.println("月（英）:"+ldt.getMonth());
            System.out.println("月（中）:"+ldt.getMonthValue());
            System.out.println("日:"+ldt.getDayOfMonth());
            System.out.println("时:"+ldt.getHour());
            System.out.println("分:"+ldt.getMinute());
            System.out.println("秒:"+ldt.getSecond());
    
            LocalDate now1=LocalDate.now();//可以获取年月日，但不能获取时分秒
            LocalTime now2=LocalTime.now();//可以获取时分秒，但不能获取年月日
        }
    }
    //输出：
    //2022-11-21T21:37:16.590506200
    //年:2022
    //月（英）:NOVEMBER
    //月（中）:11
    //日:21
    //时:21
    //分:37
    //秒:16

![76a36dc11c924013ad6c44da2d1449b3.png][]

package Math_;
    
    import java.time.LocalDate;
    import java.time.LocalDateTime;
    import java.time.LocalTime;
    import java.time.format.DateTimeFormatter;
    
    public class LocalDate_ {
        public static void main(String[] args) {
            LocalDateTime ldt=LocalDateTime.now();
            DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            String format=dateTimeFormatter.format(ldt);
            System.out.println("格式化的日期："+format);
        }
    }
    //输出：格式化的日期：2022-11-21 21:49:08

![280931cebc224bda8282cd9c375b0923.png][]

package Math_;
    
    import java.time.Instant;
    import java.util.Date;
    
    public class Instant_ {
        public static void main(String[] args) {
            //通过静态方法now()获取表示当前时间戳的对象
            Instant now=Instant.now();
            System.out.println(now);
    
            //通过from把Instant转成Date
            Date date=Date.from(now);
            System.out.println(date);
    
            //通过toInstant把Date转成Instant
            Instant instant=date.toInstant();
            System.out.println(instant);
        }
    }
    //输出：
    //2022-11-21T13:55:22.780425Z
    //Mon Nov 21 21:55:22 CST 2022
    //2022-11-21T13:55:22.780Z

![8412c66314f64345b92ae2a5118c08a2.png][]

package Math_;
    
    import java.time.Instant;
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    import java.util.Date;
    
    public class Instant_ {
        public static void main(String[] args) {
            LocalDateTime ldt=LocalDateTime.now();
            DateTimeFormatter dateTimeFormatter= DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            //对当前时间进行加或减
    
            LocalDateTime localDateTime=ldt.plusDays(90);//加
            System.out.println("90天后："+dateTimeFormatter.format(localDateTime));
    
            LocalDateTime localDateTime1=ldt.minusMinutes(1234);//减
            System.out.println("1234分钟前的日期："+dateTimeFormatter.format(localDateTime1));
        }
    }
    //输出：
    //90天后：2023-02-19 22:05:30
    //1234分钟前的日期：2022-11-21 01:31:30

[af4a9461be6744188e28b789aee90323.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a54d3ab2cffc40088b8dc82e665d146a.png
[e83b536102624899a641a9e2d6745895.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c047607d395f43e0aa0b140d8ed294eb.png
[3c2771aba2e44403812ca0b96d2c86e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/24bcc645e55f4038b7ea6bcbb7f2453a.png
[8081100873404d78b643c8fa512f9bac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/cfef1809dd694b75844d78cfc34d19f9.png
[30b16b3c00014ffeba2e406562a8393e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/67af4e1f70304c1e9c88bccdf9421198.png
[3d460803347449169918944f09de9e40.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4dfda16186c6418099d89fd17a75351c.png
[b3a2c5e5e9424c36ae649d3b6a4514e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5928159634174519a16852ec42e367aa.png
[b2e87bce827147b48e08610adf93bc62.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/14938b4f8806444dae2354704abe3f07.png
[e3e059efc498493fbda4e207f0e60b1d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d75693c234604f81814783dc9b23d068.png
[3c3d298872014cb18015222e04bc04c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/06d213fdb35a48f9979fd9027e4f32bc.png
[71429e62a87b427cb8d3c3c2061c96d9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4554a680da31453ebd4267dc19022d02.png
[fe9cc6a8c03e474cb455618e7045a603.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/9d35af69d7a8425a974eacde35b5f1a0.png
[6771454bce53424fac8bcf2f005dd906.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ce9ec4509dc449c4880f3e36b68b8217.png
[33126310742648ba860451f3f4a1af66.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/401d2e6a7c354ddfab072c24b03c4afa.png
[7dd614c2ec2446f0b0212d06d1cd2ac1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/b51a4b3cb6de457e8d847a9b3cc17980.png
[76a36dc11c924013ad6c44da2d1449b3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/456e58114c354b469f6c738f9bf079bb.png
[280931cebc224bda8282cd9c375b0923.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a9ceddb8a2a845979924c351bd9c2eef.png
[8412c66314f64345b92ae2a5118c08a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/14df539cfe934955846362e9ef3dfb1f.png