有关ArrayList 和 List 文章

已于 2022-06-11 22:03:19 修改
阅读量428 收藏
点赞数 8
文章标签： java 数据结构
于 2022-06-11 21:46:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mu_tong_/article/details/125239220
版权

文章目录

😀1.基本数据类型和包装类直接的对应关系

在这里插入图片描述

基本就是类型的首字母大写，除了 Integer 和 Character。

注意这里 String 不是 包装类，是引用类型。（包装类针对基本数据类型）

包装类的装箱拆箱

在这里插入图片描述

ArrayList

在这里插入图片描述

注意这里埋了坑哦

😉ArrayList 的 几种打印方式

在这里插入图片描述

List 迭代器打印，外加 Listlterator的 add方法与remove方法注意事项

在这里插入图片描述

🤩ArrayList的常见方法

1.add方法

在这里插入图片描述

2.remove

在这里插入图片描述

3.get方法

在这里插入图片描述

4.set方法

在这里插入图片描述

5.clear 清空顺序表

在这里插入图片描述

6.contains 查找顺序表中的元素

public class Test {
    public static void main(String[] args) {
        ArrayList<String>list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println(list);
        System.out.println(list.contains("a"));
        System.out.println(list.contains("f"));
    }
}

在这里插入图片描述

7.indexOf 查找顺序表元素并返回下标

public class Test {
    public static void main(String[] args) {
        ArrayList<String>list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println(list);
        System.out.println(list.indexOf("a"));
        System.out.println(list.indexOf("f"));
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6TJLpoXY-1654954789532)(C:\Users\A\AppData\Roaming\Typora\typora-user-images\image-20220608221123195.png)]

8.lastIndexOf 从后往前找 元素并返回下标

public class Test {
    public static void main(String[] args) {
        ArrayList<String>list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("c");

        System.out.println(list);
        System.out.println(list.lastIndexOf("c"));
        System.out.println(list.indexOf("f"));
    }
}

在这里插入图片描述

9.subList 截取字符串

在这里插入图片描述

😏填坑

在这里插入图片描述

🥰模拟实现ArrayList

1、add方法 添加元素

// 这里 实现 我们自己 的 ArrayList 可以参考 源码实现
    class  nameError extends RuntimeException {
        public nameError(String message) {
            super(message);
        }
}
class ArrayErrow extends RuntimeException {
        public ArrayErrow(String message) {
            super(message);
        }
}

class doesnotexistError extends RuntimeException {
    public doesnotexistError(String message) {
        super(message);
    }
}
class MyArrayList<E> {
    private Object[] elementData; // 数组，
    private  int usedSize;// 有效元素的数据个数
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    public MyArrayList() {
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    public MyArrayList(int capacity) throws nameError {
        if(capacity > 0) {
            // 对参数进行判断
            this.elementData = new Object[capacity];
        }else if(capacity == 0) {
            this.elementData = new Object[0];
        }else {
            throw new nameError("初始化的容量不能为负数");
        }
    }

    /**
     * 添加元素
     * @param e
     * @return
     */
    public boolean add(E e) {
        // 确定一个真正的容量，预测 --》扩容[将检查顺序表空和满和扩容放到了一起]
        ensureCapacityInternal(usedSize+1);
        elementData[usedSize] = e;
        usedSize++;
        return true;
    }
    private  void ensureCapacityInternal(int minCapacity) {
        //1.计算出需要的容量
        int capacity = calculateCapacity(elementData,minCapacity);
        //2.拿出计算出的容量 去看 满了扩容，空的 扩容
        ensureExplicitCapacity(capacity);
    }
    // 判断是否满了
    private  void  ensureExplicitCapacity(int minCapacity) {

        // 进不去 if 语句 说明还没有放满
        if(minCapacity - elementData.length > 0 ) {
            // 现在 minCapacity 实际元素 如果大于 数组长度（容量） 就需要扩容
            grow(minCapacity);
        }

    }
    //private static final int DEFAULT_CAPACITY = 10;
    private int calculateCapacity(Object[] elementData,int minCapacity) {
        // 判断 是否 有分配 过 容量大小
        if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(10,minCapacity);
        }
        return minCapacity;
        // 这里返回 minCapacity 说明 分配过容量大小
        // 分配过返回+1的值

    }

    private static int hugeCapacity (int minCapacity) {
        if(minCapacity < 0) {
            throw new ArrayErrow("给定的顺序表容量太大溢出错误");
        }
        return (minCapacity > Max_Array_size) ?
                Integer.MAX_VALUE :
                Max_Array_size;
    }

    private  static final  int Max_Array_size  = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity+(oldCapacity>>1);
        if(newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        if(newCapacity - Max_Array_size >0) {
            newCapacity = hugeCapacity(minCapacity);
        }
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    private void copy(int index ,E e) {
        for(int i = usedSize-1;i>=index;i--) {
            elementData[i + 1] = elementData[i];
        }
        elementData[index] = e;
    }
    // 给 index 位置添加元素
    public void add(int index,E e) {
        rangeCheckForAdd(index);
        // 判断是否 需要扩容
        ensureCapacityInternal(usedSize+1);
        copy(index,e);
        usedSize++;
    }
    private  void  rangeCheckForAdd(int index){
        if(index < 0 || index > size()) {
           throw  new IndexOutOfBoundsException("index位置不合法，无法插入");
        }
    }
    public int size() {
        return this.usedSize;
    }
}

2.remove方法 删除 元素

// 删除 index 位置的 元素
    public E remove(int index) {
        rangeCheck(index);
        E oldvalue = (E) elementData[index];
        // 这里elementData为 Object类型要强转才能赋值
        sub(index);
        return oldvalue;
    }
    // 遍历寻找 数组中e 的元素是否存在
    private int a(E e) {
        for(int i = 0;i<usedSize;i++) {
            if(elementData[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }
    public void remove(E e) throws doesnotexistError {
       int ret = a(e);
        if(ret == -1) {
            throw new doesnotexistError("要删除的元素不存在");
        }else {
            sub(ret);
        }
    }

3.get方法 查找 index 位置的信息

public void rangeCheck2(int index) throws  nameError {
        if(index < 0 || index > size()) {
            throw new nameError("要获取信息的位置不合法");
        }
    }
    public E get(int index) {
        rangeCheck2(index);
        return (E)this.elementData[index];
    }

4.set方法 替换 index 位置的元素

   public E set(int index , E e) {
        rangeCheck2(index);
       // 判断 index 位置的合法性
        E oldvalue = (E) elementData[index];
        elementData[index] = e;
        return oldvalue;
    }

5.clear方法清空 顺序表

一个一个置空 ，最后数组元素赋值为 0 就行 
public void clear() {
        for(int i = 0;i<usedSize;i++) {
            elementData[i] = null;
        }
        usedSize = 0;
    }

🤗完整

class nameError extends RuntimeException {
    public nameError(String message) {
        super(message);
    }
}
class AarrayError extends RuntimeException {
    public AarrayError(String message) {
        super(message);
    }
}
class doesnotexistError extends RuntimeException {
    public doesnotexistError(String message) {
        super(message);
    }
}
public class MyArrayList<E>{
    private Object[] elementData;
    private int usedSize;
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    public MyArrayList() {
    this.elementData =   DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    // 用来记录 elementData 是否 分配了空间
    }
    public MyArrayList(int capacity) throws nameError{
        if(capacity > 0) {
            this.elementData = new Object[capacity];
        }else if(capacity == 0) {
            this.elementData = new Object[0];
        }else {
            throw new nameError("初始化的容量不能为负数");
        }
    }
    public boolean add(E e) {
        ensureCapacityInternal(usedSize + 1);  // Increments modCount!!
        elementData[usedSize++] = e;
        return true;
    }
    private void  ensureCapacityInternal(int minCapacity ) {
        // 判断是否分配了空间，真实的所需的空间
        int capacity = calculateCapacity(elementData,minCapacity);
        ensureExplicitCapacity(capacity);// 判断是否 需要扩容
    }
    private void ensureExplicitCapacity(int minCapacity) {
            if(minCapacity - elementData.length >0) {
                grow(minCapacity);
                // 扩容
            }
    }
    private int calculateCapacity(Object[] elementData,int minCapacity) {
        // 先判断 是否分配了空间
        if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(10,minCapacity);
        }
        // 如果分配了空间，就直接返回分配的空间
        return minCapacity;
    }
    // 创建一个 第一边界
    private  static final  int Max_Array_size  = Integer.MAX_VALUE - 8;
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity+(oldCapacity>>1);
        if(newCapacity - minCapacity <0) {
            newCapacity = minCapacity;
        }
        if(minCapacity - Max_Array_size > 0) {
            newCapacity = hugeCapacity(minCapacity);
        }

       this.elementData = Arrays.copyOf(elementData,newCapacity);
    }
    private int hugeCapacity(int mindCapacity) {
        if(mindCapacity < 0 ) {
            throw new AarrayError("开创的容量位置太大超出int 的最大容量");
        }
        return (mindCapacity > Max_Array_size) ? Integer.MAX_VALUE : Max_Array_size;
    }
    private void copy(int index,E e) {
        for(int i = usedSize-1;i >=index;i--) {
            elementData[i+1] = elementData[i];
        }
        elementData[index] = e;
        usedSize++;
    }
    public  void add(int index,E e) {
        // 判断位置 是否合法
        rangeCheckForAdd(index);
        // 判断是否需要扩容
        ensureCapacityInternal(usedSize+1);
        copy(index,e);
    }
    private void  rangeCheckForAdd(int index) throws nameError{
        if(index<0 || index >size()) {
        throw new nameError("插入index位置异常");
        }
    }
    private void rangeCheck(int index) throws nameError {
        if(index<0 || index >size()) {
            throw new nameError("删除index位置异常");
        }
    }
    public int  size() {
        return this.usedSize;
    }
    private void sub(int index) {
        for(int i = index;i<usedSize;i++) {
            elementData[i] = elementData[i+1];
        }
        elementData[usedSize-1] = null;
        usedSize--;

    }
    // 删除 index 位置的 元素
    public E remove(int index) {
        rangeCheck(index);
        E oldvalue = (E) elementData[index];
        // 这里elementData为 Object类型要强转才能赋值
        sub(index);
        return oldvalue;
    }
    // 遍历寻找 数组中e 的元素是否存在
    private int a(E e) {
        for(int i = 0;i<usedSize;i++) {
            if(elementData[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }
    public void remove(E e) throws doesnotexistError {
       int ret = a(e);
        if(ret == -1) {
            throw new doesnotexistError("要删除的元素不存在");
        }else {
            sub(ret);
        }
    }
    public void rangeCheck2(int index) throws  nameError {
        if(index < 0 || index > size()) {
            throw new nameError("要获取信息的位置不合法");
        }
    }
    public E get(int index) {
        rangeCheck2(index);
        return (E)this.elementData[index];
    }

    public E set(int index , E e) {
        rangeCheck2(index);
        E oldvalue = (E) elementData[index];
        elementData[index] = e;
        return oldvalue;
    }
    public void clear() {
        for(int i = 0;i<usedSize;i++) {
            elementData[i] = null;
        }
        usedSize = 0;
    }
    @Override
    public String toString() {
        return "MyArrayList{" +
                "elementData=" + Arrays.toString(elementData) +
                ", usedSize=" + usedSize +
                '}';
    }

}

剩下的方法 可以自行看 源码实现，这里 只完成常用的 几种方法。

最后我们来用ArrayList 实现一副扑克牌

//扑克牌
class Card{
    // 数字
    private int point;
    // 花色
    private String flowerColor;
    public Card(int point,String flowerColor) {
        this.point = point;
        this.flowerColor = flowerColor;
    }

    @Override
    public String toString() {
        return "["+this.flowerColor+" : " +this.point+" ]";
    }
}
public class Test2 {
    public static final String[] suits = {"♥","♣","♦","♠"};

    // 创建一副牌
    public static ArrayList<Card> byCard() {
        ArrayList<Card> list = new ArrayList<>();
        for(int i = 0;i<4;i++) {
            // 4 中 花色 13 中 数字 1 - 13 除去大小王
            for (int j = 1; j <=13 ; j++) {
                String suit = suits[i];
                Card card = new Card(j,suit);
                list.add(card);
                //这里也可 这样些，
               // list.add(new Card(j,suits[i]));
            }  
        }
        return list;
    }
   // 换牌
    private static void swap(List<Card>list,int i,int ret) {
        //其实 这里就是我们常用的交换元素
        // 只是 我们 要在 list 中 来获取 i 和 ret 的 信息，
        // 在通过 set 来交换
        // 原型 Card tmp = list[i]
        Card tmp = list.get(i);
        // linst[i] = list[ret]
        list.set(i,list.get(ret));
        //list[ret] = tmp;
        list.set(ret,tmp);
    }
    // 洗牌
    public static void shuffle(List<Card> list) {
        System.out.println("开始洗牌");
        System.out.println(list);
        int size = list.size() - 1;
        // 这里 我们可以先拿到最后一个元素的下标，
       for(int i = size;i>0;i--) {
           Random random = new Random();
           int ret =random.nextInt(i);
           swap(list,i,ret);
       }
        System.out.println("洗牌完成");
        System.out.println(list);
    }
    public static void main(String[] args) {
        ArrayList<Card> list = new ArrayList();
        list = byCard();
        System.out.println(list);
        shuffle(list);
//        System.out.println(list);
        ArrayList<ArrayList<Card>> hand = new ArrayList<>();
        ArrayList<Card> hand1 = new ArrayList<>();
        ArrayList<Card> hand2 = new ArrayList<>();
        ArrayList<Card> hand3 = new ArrayList<>();
            hand.add(hand1);
            hand.add(hand2);
            hand.add(hand3);

        for(int i = 0;i<5;i++) {
            for (int j = 0; j < 3; j++) {
                Card card = list.remove(0);
                hand.get(j).add(card);
            }
        }
        System.out.println("第一个人的牌："+hand1);
        System.out.println("第二个人的牌："+hand2);
        System.out.println("第三个人的牌："+hand3);


    }
}

在这里插入图片描述

在这里插入图片描述

最后我们 在来 巩固一下学到ArrayList<Arraylist<>> list = new Array<>();

杨辉三角形

相比大家都和熟悉 杨辉三角形吧 ，不就是一个直角三角形，j == 0 和 i== j 的位置赋值为 1，其他位置 arr[i][j] == arr[i-1][j]+arr[i-1][j-1] 这样的思路
然后这里我们来实践一下

class Solution {
    public List<List<Integer>> generate(int numRows) {
        // 这里 就 创建了一个ret 变量 相当于 一个二维数组 arr[i][j]
            List<List<Integer>> ret = new ArrayList<>();
        // 将第一行 的 为一个 元素 j == 0 的 地方放入 1
            List<Integer> list = new ArrayList<>();
            list.add(1);
        // 这一行 放完 就放入我们的二维数组中，
            ret.add(list);
            for(int i = 1;i<numRows;i++) {
                // 没一行的 第一列 就是 j = 0 的 地方放入 1
                List<Integer> list2 = new ArrayList<>();
                list2.add(1);
                //这一步就先当与 得到 i - 1 行 的 信息
                List<Integer> preRow = ret.get(i-1);
                for(int j = 1;j<i;j++) {
                    // 这里 不就是 arr[i][j] = arr[i-1][j]+arr[i-1][j-1]
                    int nums = preRow.get(j)+preRow.get(j-1);
                    将他放入顺序表中
                    list2.add(nums);
                }
                最后将 最后一个 1 假如 ，就是 i == j 的 地方
                list2.add(1);
                别忘记 要放进我们的二维数组中，
                ret.add(list2);
            }
            return ret;
    }
}
牧..
关注
  • 8
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
集合|容器——存储多个数据
WRLKYLJ的博客
11-19 961
一. 变量: 存储单个数据 数组: 存储多个数据 引用数据类型 定长,长度一旦确定不可改变 有序,有索引 存储相同数据类型的数据 容量可以多少进行动态的变动 储存任意引用数据类型数据 collection{接口}集合层次结构中的根接口。集合表示一组对象，成为其元素 遍历：增强for循环 iterator迭代器 Iterator<E> iterator()返回此集合中元素的迭代器 1.获取...
十二、集合-List、Set与Map
Yeung_ZY的博客
11-23 887
目录 1.集合的概念 1.1概述 1.2Collection接口 2.List接口 2.1List 2.2Vector实现类 2.3ArrayList实现类 2.3.1ArrayList存储原理分析 2.3.2LinkedList存储原理分析 2.3.3ArrayList与LinkedList性能PK 3.泛型 3.1泛型应用 3.2泛型定义 3.3自定义泛型集合 4.Collections工具类 5.Set 5.1Set实现类HashSet 5.1.1HashSet存储
将两列list拼接为一列list
qq_44193969的博客
04-23 489
将两列list拼接为一列list
关于java List 添加数据的方法的使用
热门推荐
ido1ok的博客
06-05 1万+
List 添加元素的方法通常有① boolean add(E e);② void add(int index, E element); ① boolean add(E e);每次添加的元素被放置在list的尾部； ② void add(int index, E element);在插入操作过程中指定插入的位置，此时，会自动将当前位置及只有的元素后移进行插入. 需要注意的是，参数index的值不可大于当前list的容量，即不可以随便新建一个list，向其任意的位置插入元素。即便使用new Array..
List与ArrayList
caomaoadai的博客
08-18 820
List和ArrayList的区别在于： 1、在编程语言中ArrayList类是.Net Framework提供的用于数据存储和检索的专用类。List 类可以简单视之为双向连结串行，以线性列的方式管理物件集合。List类是ArrayList类的泛型等效类。 2、ArrayList继承了IList接口，所以它可以很方便的进行数据的添加，插入和移除。List的大部分用法都与ArrayList相似，List类也继承了IList接口。 3、在ArrayList中可以插入不同类型的数据。ArrayList会把所
C#中数组、ArrayList、List、Dictionary的用法与区别浅析(存取数据)
08-31
在C#编程中，我们经常会遇到四种数据结构用于存储和管理数据：数组（Array）、ArrayList、List和Dictionary, TValue>。这些数据结构各有特点，选择合适的类型取决于具体需求。下面将对它们的用法和差异进行详细阐述...
C# 没有动态的数组，可以用arraylist或list取代
01-21
代码如下:using System.Collections; ArrayList a = new ArrayList(); a.Add(“a”);//这里”a”可以改成你要取出的字符串 a.Add(“b”); 运行后a就相当于一个... 您可能感兴趣的文章:C#中数组Array，ArrayList，泛型
Array，ArrayList与List的区别
weixin_57752568的博客
06-20 1014
Array，ArrayList与List的区别 1.Array和ArrayList的区别。 不同点：（1）Array类型的变量在声明的同时必须进行实例化(至少得初始化数组的大小)，而ArrayList可以只是先声明。如：int[] array = new array[5];或 int[] array = {1,2,3,4,5};或 ArrayList myList = new ArrayList();这些都是合法的，而直接使用 int[] array;是不行的。（2） Array只能存储同构的对象，而A
java LIst 和ArrayList区别和联系详解
y152543654的博客
11-16 850
文章目录定义使用方法使用区别延伸List的接口及其实现类的主要方法 定义 List是一个接口，Arraylist是List的实现类。因此list不能自己定义一个对象，只能进行引用。 List list1 = new List();//这种定义语句就是错误的 List list2 = new ArrayList();//正确 ArrayList list3 = new ArrayList();//正确 使用方法 以下两种定义都正确，区别在于前者只能使用List和Arraylist的公共方法，后者可以使
ArrayList和LinkedList区别
weixin_38289612的博客
08-11 1567
文章目录前言一、ArrayList和LinkedList是什么？二、从源码分析ArrayList、LinkedList1.ArrayList的继承（extends）和实现（implement）2.ArrayList和LinkedList的基本属性和方法（get、add、remove）分析2.1 ArrayList 和 LinkedList 的 add 方法2.2 ArrayList 和 LinkedList 的 get 方法2.3ArrayList 和 LinkedList 的 remove 方法总结 ..
JAVA 使一个list分为两列的或三列的，多余的行“-“代替
qq_44257753的博客
09-10 573
直接上代码了， public static List<Map<String,Object>> devideTwoList(List<Map<String,Object>> datas){ List<String> mapList = new ArrayList<>(); List<Map<String,Object>> xixi = new ArrayList<>();
【python基础】List列表中插入多个元素的几种实现方式
Everyday try to become better -Kobe Bryant
07-28 8579
【python基础】列表中插入多个元素的几种实现方式。
ArrayList(数组列表)与ArrayList之间数据的添加与删除操作
颂一家之言
11-03 7017
ListmAddFilesInfoList=new ArrayList(); ListmRemoveFileInfoList=new ArrayList(); ListmPasteFileInfoList=new ArrayList(); ListmShowFileInfoList=new ArrayList(); FileInfo[] addFileInfos=new FileInfo[mAd
【Java】Arraylist概述，Arraylist常用操作方法，遍历Arraylist，基本数据类型使用Arraylist，Arraylist练习
欢迎关注【微信公众号】测试开发Guide，从功能测试进阶测试开发
03-18 548
Arraylist 数组的长度不可以发生改变。 但是ArrayList集合的长度是可以随意变化的。 对于ArrayList来说，有一个尖括号代表泛型。 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。 注意：泛型只能是引用类型，不能是基本类型。 注意事项： 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。 如果内容是空，得到的是空的中括号：[] // 创建了一个Ar...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 554
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 792
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1074
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值