C# 二维List

最新推荐文章于 2024-10-22 02:03:36 发布
最新推荐文章于 2024-10-22 02:03:36 发布
阅读量6.1k 收藏 4
点赞数 1
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013628121/article/details/84639736
版权 
    /// <summary>
    ///二维List
    /// </summary>
    public class FromCellList
    {
        public List<List<object>> list = new List<List<object>>();
        public FromCellList()
        {

        }
        public FromCellList(FromCellList fc)
        {
            list.Clear();
            for (int i = 0; i < fc.list.Count; i++)
            {
                list.Add(fc.list[i]);
            }
         }
        public FromCellList(List<List<object>> fc)
        {
            list.Clear();
            for (int i = 0; i < fc.Count; i++)
            {
                list.Add(fc[i]);
            }
        }
        public FromCellList(object[][] fc)
        {
            list.Clear();
            for (int i = 0; i < fc.Length; i++)
            {
                list.Add(fc[i].ToList());
            }
        }

        /// <summary>
        /// 在行尾添加一行
        /// </summary>
        /// <param name="line"></param>
        public void AppendRow(List<object> line)
        {
            if (RowCount == 0)
            {
                list.Add(line);
                return;
            }

            if (line.Count < 0)
            {
                throw new Exception("添加的行的数据个数不对 ColumnCount");
            }
            else
            {
                list.Add(line);
            }
        }
        /// <summary>
        /// 多少行
        /// </summary>
        public int RowCount
        {
            get
            {
                return list.Count;
            }
        }
        /// <summary>
        /// 多少列
        /// </summary>
        public int ColumnCount
        {
            get
            {
                if (list.Count == 0)
                    return 0;
                return list[0].Count;
            }
        }

        /// <summary>
        /// 检查列的下标是否越界
        /// </summary>
        /// <param name="columnIndex"></param>
        void SafeCheakColumnIndex(int columnIndex)
        {
            if (columnIndex < 0 || columnIndex >= ColumnCount)
            {
                //throw new Exception("列的下标越界");
                Console.WriteLine("行下标越界index");

            }
        }

        /// <summary>
        /// 检查行的下标是否越界
        /// </summary>
        /// <param name="columnIndex"></param>
        void SafeCheakRowIndex(int rowIndex)
        {
            if (rowIndex < 0 || rowIndex >= RowCount)
            {
                // throw new Exception("行下标越界index");
                Console.WriteLine("行下标越界index");
            }
        }

        /// <summary>
        /// 删除columnIndex列中_后重复数据所在的行,重复的只保留一份(第一次出现的)
        /// 例子:列 ={1,2,2,3,4,5,5} ,结果={1,2,3,4,5} 
        /// </summary>
        /// <param name="columnIndex"></param>
        /// <returns></returns>
        public string DelRepeatColumn(int columnIndex)
        {
            var columnList = GetColumn(columnIndex);
            var delList = GetRepeatIndex(columnList);
            var debugOutputStr = DelRowsByListIndex(delList, columnIndex);
            return debugOutputStr;
        }

        /// <summary>
        /// columnIndex列中的值在BaoList重复,则删除所在的行
        /// 例子:列={1,2,3,4,5},BaoList={1,3},结果列={2,4,5}
        /// </summary>
        /// <param name="columnIndex"></param>
        /// <param name="BaoList"></param>
        /// <returns></returns>
        public string DelRowsByListRepeat(int columnIndex,List<object> BaoList)
        {
            SafeCheakColumnIndex(columnIndex);
            var wantDelList = GetColumn(columnIndex);
            var debugOutputStr = "";
            for (int i = wantDelList.Count - 1; i > -1; i--)
            {
                for (int j = 0; j < BaoList.Count; j++)
                {
                    var a = wantDelList[i].ToString();
                    var b = BaoList[j].ToString();
                    if (a == b)
                    {
                        DeleteRow(i);
                        debugOutputStr += wantDelList[i].ToString() + "\r\n";
                    }
                }
            }
            return debugOutputStr;
        }

        /// <summary>
        /// 删除后重复的数据,重复的值只保留一份
        /// </summary>
        /// <param name="list_int"></param>
        /// <returns></returns>
        static List<int> DelRepeat(List<int> list_int)
        {
            for (int i = 0; i < list_int.Count; i++)
            {
                for (int j = list_int.Count - 1; j > i; j--) //j>i 的意思是:>i前面的已经比较过了
                {

                    var A = list_int[i];
                    var B = list_int[j];
                    if (A == B)
                    {
                        list_int.RemoveAt(j);
                    }
                }
            }
            return list_int;
        }

        /// <summary>
        /// 得到后重复的数据的下标,重复的值只保留一份,
        /// </summary>
        /// <param name="list_int"></param>
        /// <returns></returns>
        static List<int> GetRepeatIndex(List<object> list_int)
        {
            var delList = new List<int>();

            for (int i = 0; i < list_int.Count - 1; i++)
            {
                for (int j = list_int.Count - 1; j > i; j--)
                {
                    var A = list_int[i].ToString();
                    var B = list_int[j].ToString();
                    if (A == B)
                    {
                        delList.Add(j);
                    }
                }
            }
           // delList.ForEach(item => Console.WriteLine("Count=" + list.Count + ",delIndex=" + item));
            return delList;
        }

        /// <summary>
        /// 获取下标为columnIndex列的内容
        /// </summary>
        /// <param name="columnIndex">列的下标</param>
        /// <returns></returns>
        public List<object> GetColumn(int columnIndex)
        {
            SafeCheakColumnIndex(columnIndex);
            var tempList = new List<object>();
            for (int i = 0; i < list.Count; i++)
            {
                for (int j = 0; j < list[i].Count; j++)
                {
                    //有点行是空行 用一个Na代替
                    if (list[i].Count < columnIndex)
                    {
                        tempList.Add(null);
                    }

                    if (j == columnIndex)
                    {
                        tempList.Add(list[i][j]);
                    }
                }
            }
            if (list.Count != tempList.Count)
            {
               // Console.WriteLine("应该得到:" + list.Count + "行,实际得到:" + tempList.Count);
                throw new Exception("行数不对应");
            }
            return tempList;
        }

        /// <summary>
        /// 获取下标为 rowIndex 行的内容
        /// </summary>
        /// <param name="rowIndex">列的下标</param>
        /// <returns></returns>
        public List<object> GetRow(int rowIndex)
        {
            SafeCheakRowIndex(rowIndex);
            return list[rowIndex];
        }


        /// <summary>
        /// 获取最后一行的内容
        /// </summary>
        /// <param name="rowIndex">列的下标</param>
        /// <returns></returns>
        public List<object> GetEndRow()
        {
            var rowIndex = RowCount - 1;
            SafeCheakRowIndex(rowIndex);
            return list[rowIndex];
        }

        /// <summary>
        ///行排序根据columnIndex列的值 从小到大
        /// </summary>
        /// <param name="columnIndex"></param>
        public void Sort(int columnIndex)
        {
            //第一行 标题 不参与 排序
            var firstRow = list[0];
            list.RemoveAt(0);

            list.Sort((left, right) =>
            {
                var l = (List<object>)left;
                var r = (List<object>)right;

                if (l == null || r == null)
                    return -1;

                //有的行 是空行
                if (l.Count < columnIndex || r.Count < columnIndex)
                    return -1;

                //首先比较第一个字段.
                var firstL = -999;
                var firstR = -999;

                int.TryParse(l[columnIndex] as string, out firstL);
                int.TryParse(r[columnIndex] as string, out firstR);

                if (firstL > firstR)
                {
                    return 1;
                }
                else if (firstL == firstR)//相等则比较第2个字段.
                {
                    return 0;
                }
                else
                {
                    return -1;
                }

            });

            //第一行 标题 不参与 排序
            list.Insert(0, firstRow);
        }

        /// <summary>
        ///行排序根据columnIndex的列值 从大到小
        /// </summary>
        /// <param name="columnIndex"></param>
        /// <returns></returns>
        public void SortDescending(int columnIndex)
        {
            //第一行 标题 不参与 排序
            var firstRow = list[0];
            list.RemoveAt(0);

            list.Sort((left, right) =>
            {
                var l = (List<object>)left;
                var r = (List<object>)right;

                if (l == null || r == null)
                    return -1;

                //有的行 是空行
                if (l.Count < columnIndex || r.Count < columnIndex)
                    return -1;

                //首先比较第一个字段.
                var firstL = -999;
                var firstR = -999;

                int.TryParse(l[columnIndex] as string, out firstL);
                int.TryParse(r[columnIndex] as string, out firstR);

                if (firstL > firstR)
                {
                    return -1;
                }
                else if (firstL == firstR)//相等则比较第2个字段.
                {
                    return 0;
                }
                else
                {
                    return 1;
                }

            });

            //第一行 标题 不参与 排序
            list.Insert(0, firstRow);
        }

        /// <summary>
        /// 方便输出
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string result = "";
            string str = "";
            for (int i = 0; i < list.Count; i++)
            {
                var lines = list[i];
                str = "";
                str += "(" + i + "行:" + lines.Count + "列" + ")";
                for (int j = 0; j < lines.Count; j++)
                {
                    if (j > 0)
                    {
                        str += "\t";
                    }

                    str += lines[j].ToString();
                }
                result += str + "\r\n";
            }
            return result;
        }

        /// <summary>
        /// 删除下标为index的列
        /// </summary>
        /// <param name="columnIndex"></param>
        public void DeleteColumn(int columnIndex)
        {
            SafeCheakColumnIndex(columnIndex);
            for (int i = 0; i < list.Count; i++)
            {
                List<object> ziList = list[i];
                for (int j = ziList.Count - 1; j > -1; j--)
                {
                    if (j == columnIndex)
                    {
                        string item = ziList[j].ToString();
                        // Console.WriteLine("Delete:"+item+"\t"+"j="+j);
                        ziList.RemoveAt(j);
                    }
                }
            }
        }

        /// <summary>
        /// 删除下标为index的行
        /// </summary>
        public void DeleteRow(int rowIndex)
        {
            SafeCheakRowIndex(rowIndex);
            if (rowIndex == 0) return;//标题行不参与操作
            list.RemoveAt(rowIndex);
        }

        /// <summary>
        /// 修改下标为index行
        /// </summary>
        public void UpdateRow(int rowIndex, List<object> rowList)
        {
            SafeCheakRowIndex(rowIndex);
            if (rowList.Count == ColumnCount)
            {
                list[rowIndex] = rowList;
            }

        }

        /// <summary>
        /// 修改下标为index列
        /// </summary>
        /// <param name="columnIndex"></param>
        public void UpdateColumn(int columnIndex, List<object> columnList)
        {
            SafeCheakColumnIndex(columnIndex);
            if (columnList.Count != RowCount)
            {
                return;
            }
            for (int i = 0; i < list.Count; i++)
            {
                for (int j = 0; j < list[i].Count; j++)
                {
                    if (j == columnIndex)
                    {
                        list[i][j] = columnList[i];
                    }
                }
            }
        }

        /// <summary>
        /// 删除delList保存中的下标 所在行
        /// </summary>
        /// <param name="delList"></param>
        public string DelRowsByListIndex(List<int> delList,int ColumnIndex)
        {
            
            //去除重复的下标
            delList = DelRepeat(delList);

            //Console.WriteLine(delList.ToString());
            //Console.WriteLine("去重复");
            //delList.ForEach(item => Console.WriteLine("Count=" + list.Count + ",delIndex=" + item+"值:"));

            //删除前 先排序 从大到小
            delList.Sort((x, y) => -x.CompareTo(y));

           // Console.WriteLine("排序");
            //delList.ForEach(item => Console.WriteLine("Count=" + list.Count + ",delIndex=" + item));
           // Console.WriteLine("开始del");

            var outPutstr = "";
            for (int i = 0; i < delList.Count; i++)
            {
                if(delList[i]!=0) //标题行 不参与操作
                {
                    // Console.WriteLine("Count=" + list.Count + ",delIndex=" + delList[i]);
                    outPutstr += "行下标:" + delList[i] + "\t" + list[delList[i]][ColumnIndex].ToString() + "\r\n";
                    DeleteRow(delList[i]);
                }

            }
            return outPutstr += "删除数量:" + delList.Count + "个" + "\r\n";
        }

        /// <summary>
        /// columnIndex列中,单元格值的长度等于len,则删除所在的行
        /// </summary>
        /// <param name="len"></param>
        /// <param name="columnIndex"></param>
        public string DelRowEqualsLen(int len, int columnIndex)
        {
            SafeCheakColumnIndex(columnIndex);
            var outPutstr = "";
            var rowList = new List<int>();
            for (int i = 0; i < list.Count; i++)
            {
                for (int j = 0; j < list[i].Count; j++)
                {
                    if (j == columnIndex && i != 0) //i!=0 表示标题 不参与
                    {
                        string item = list[i][j].ToString();
                        if (item.Length == len)
                        {
                            //Console.WriteLine(i);
                            outPutstr += item + "\r\n";
                            rowList.Add(i);
                        }
                    }
                }
            }

            //List遍历中删除指定元素
            for (int i = rowList.Count - 1; i >= 0; i--)
            {
                DeleteRow(rowList[i]);
            }
            return outPutstr += "删除数量:" + rowList.Count + "个" + "\r\n";
        }

        /// <summary>
        ///columnIndex列中,单元格值的长度小于len,则删除所在的行
        /// </summary>
        /// <param name="len"></param>
        /// <param name="columnIndex"></param>
        public string DelRowLessLen(int len, int columnIndex)
        {
            SafeCheakColumnIndex(columnIndex);
            var outPutstr = "";
            var rowList = new List<int>();
            for (int i = 0; i < list.Count; i++)
            {
                for (int j = 0; j < list[i].Count; j++)
                {
                    if (j == columnIndex && i != 0) //i!=0 表示标题 不参与
                    {
                        string item = list[i][j].ToString();
                        if (item.Length < len)
                        {
                            outPutstr += item + "\r\n";
                            rowList.Add(i);
                        }
                    }
                }
            }
            //List遍历中删除指定元素
            for (int i = rowList.Count - 1; i >= 0; i--)
            {
                DeleteRow(rowList[i]);
            }
            return outPutstr += "删除数量:" + rowList.Count + "个" + "\r\n";
        }

        /// <summary>
        ///columnIndex列中,单元格值的长度大于len,则删除所在的行
        /// </summary>
        /// <param name="len"></param>
        /// <param name="columnIndex"></param>
        public string DelRowGreaterLen(int len, int columnIndex)
        {

            SafeCheakColumnIndex(columnIndex);
            var outPutstr = "";

            var rowList = new List<int>();
            for (int i = 0; i < list.Count; i++)
            {
                for (int j = 0; j < list[i].Count; j++)
                {
                    if (j == columnIndex && i != 0) //i!=0 表示标题 不参与
                    {
                        string item = list[i][j].ToString();
                        if (item.Length > len)
                        {
                            outPutstr += item + "\r\n";
                            rowList.Add(i);
                        }
                    }
                }
            }
            //List遍历中删除指定元素
            for (int i = rowList.Count - 1; i >= 0; i--)
            {
                DeleteRow(rowList[i]);
            }
            return outPutstr += "删除数量:" + rowList.Count + "个" + "\r\n";
        }

        /// <summary>
        /// DataTable类型转FromCellList
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static FromCellList DataTableToFromCellList(DataTable dt)
        {
            FromCellList fcl = new FromCellList();
            var objList = new List<object>();
            foreach (DataColumn dc in dt.Columns)
            {
                objList.Add(dc.ColumnName);
            }
            fcl.AppendRow(objList);

            for (int i = 0; i < dt.Rows.Count; i++)
            {
                DataRow dataRow = dt.Rows[i];
                fcl.AppendRow(dataRow.ItemArray.ToList());
                //for (int j = 0; j < dt.Columns.Count; j++)
                //{
                //    string strName = dt.Rows[i][j].ToString();
                //    Console.WriteLine(strName);
                //}
            }
            return fcl;
        }
        public  DataTable ToDataTable()
        {
            DataTable dt = new DataTable();
            for (int i = 0; i < list.Count; i++)
            {
                var lines = list[i];
                var row = new List<string>();
                for (int j = 0; j < lines.Count; j++)
                {
                    string contant = "";
                    if (lines[j].GetType() == typeof(string))
                    {
                        contant = Convert.ToString(lines[j]);
                    }
                    else if (lines[j].GetType() == typeof(int))
                    {
                        contant = lines[j].ToString();
                    }
                    else
                    {
                        contant = Convert.ToString(lines[j]);
                    }

                    //   Console.WriteLine(lines.lines[j].GetType()+"=type,vallue="+ contant);

                    //result += ("行号:" + lines.line + "neirong=" + lines.lines[j]);
                    if (i == 0)
                    {

                        dt.Columns.Add(contant + "", typeof(string));
                    }
                    if (i > 0)
                    {
                        row.Add(contant);
                    }
                }

                if (i > 0)
                {
                    dt.Rows.Add(row.ToArray());
                }

            }
            return dt;
        }

        public static FromCellList _2ArrToFromCellList()
        {
            //交错数组
            int[][] arr = new int[2][]
            {
                new int[]  { 1, 2, 3, 5, 6 },
                new int[]  { 1, 2, 3, 4, 5 },
            };
            //交错数组
            object[][] object_arr = new object[2][]
            {
                new object[]  { 1, 2, 3, 5, 6 },
                new object[]  { 1, 2, 3, 4, 5 },
            };


            int[,]  Arr = new int[2,5]  { { 1, 2, 3, 5, 6 }, { 1, 2, 3, 4, 5 } };

            object[,] objectArr = new object[2, 5] { { 1, 2, 3, 5, 6 }, { 1, 2, 3, 4, 5 } };


            int[,] a = new int[3, 4] 
            {
             {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
             {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
             {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
            };


            var t = new FromCellList(object_arr);

            return t;

        }

        public static FromCellList _2ListToFromCellList()
        {
            List<List<object>> zip2List = new List<List<object>>
            {
                new List<object>{"a","b","c","d"},
                new List<object>{"1","2","3","4"},
                new List<object>{"A","B","C","D"},
                new List<object>{"一","二","三","四"},
            };
            var t = new FromCellList(zip2List);
            return t;
        }

        public static FromCellList FromCellListToFromCellList()
        {
            List<List<object>> zip2List = new List<List<object>>
            {
                new List<object>{"a","b","c","d"},
                new List<object>{"1","2","3","4"},
                new List<object>{"A","B","C","D"},
                new List<object>{"一","二","三","四"},
            };
            var t =new FromCellList( new FromCellList(zip2List));

            return t;

        }

    }

 

绀目澄清
关注
专栏目录
c#简单实现二维数组和二维数组列表List<>的转置
weixin_33671935的博客
11-15 1127
刚看到网上一篇博文里用sql实现了行列转置。sql server 2005/2008只用一个pivot函数就可以实现sql server 2000很多行的复杂实现。提到转置，立刻想起还在求学阶段曾经做过的一个练习，用c语言实现二维数组的转置。相信大家都做过这个练习。下面利用c#利器也实现一遍，没有实际意义，练练手而已。 1、二维数组转置 Code class Program    {     ...
c# 二维list排序和计时
weixin_34220963的博客
01-14 641
1 using System; 2 using System.Collections.Generic; 3 using System.Diagnostics; 4 using System.Linq; 5 using System.Text; 6 using System.Threading; 7 8 9 namespace Console...
C# DataGridView实现二维表头
m0_67599428的博客
03-23 3400
VS2022 C# windowForm自定义控件DataGridView实现二维表头
C#基础（4）二维数组
a6s686的博客
09-04 1965
我们这节博文中，不仅学习了二维数组的使用，还借此实现了一个小地图和玩家的基本移动功能，我们初步见识到自己目前学到的东西可以做一个简单的小游戏框架了。相信你如果继续坚持，以后一定能做出更炫酷，更厉害的游戏。不过，我们的学习之路还很长，复杂的难点还等着你去攻克。还是那句话，学习要脚踏实地，一步一个脚印。共勉！请期待我的下一篇博客！
C#泛型列表List基本用法总结
北极星的专栏
01-11 2652
C#泛型列表List基本用法总结朱先忠示例代码如下：namespace SampleListT{  class Program  {      static void Main(string[] args)      {          //using System.Collections.Generic; 命名空间中的List          //using System.Colle
C# 创建二维List的简单例子
qq_42675313的博客
12-02 1万+
//二维LIST就是把2个一维LIST插入初始化好的2维LIST里即可 //初始化二维List arrayAB List<List<string>> arrayAB = new List<List<string>>(); //...
C# 二维list
weixin_30414155的博客
12-24 1523
public class ValueList : List<double> { public ValueList() { } } public ValueList[] valListArr = new ValueList[Gloabl.testPointNum]; 转载于:https://...
C#二维list怎么使用
05-24
在C#中，可以使用List<List<T>>来表示二维数组。其中T是该数组中元素的类型。 以下是如何使用二维List： 1.创建一个二维List对象： ```csharp List<List<int>> my2DList = new...以上就是使用C#二维List的基本方法。
C#中的List、二维数组和DataGridView
无涯的博客
01-19 3172
C#中的List、二维数组和DataGridView的使用方法及一些使用记录。
简述 C# 二维数据集合 List 的创建、遍历、修改、输出
最新发布
中游鱼的博客
10-22 1082
简述 C# 二维数据集合 List 的创建、遍历、修改、输出
c#画嵌套二维表
11-09
利用c# 开发的作图工具，可以画嵌套的二维表格，给初学作图者提供学习的思路。
二维排序算法 选择排序 C#二维数组实现
11-29
看了看好像没有二维的排序算法，自己感兴趣做了个。大家随便看看，提提意见~
动态二维数组 c#编程
06-27
动态二维数组 动态二维数组 动态二维数组
C#（二维数组/集合）
weixin_30686845的博客
07-30 2905
一、二维数组int [,] array = new int[5,3];//有五个一维数组，每一个一维数组有3个元素/打印出来一个“王”这个字string[,] wang = new string[,]{ {" ","■","■","■","■","■"," "},{" "," "," ","■"," "," "," "},{" "," "," ","■"," ","...
C# 用二维的list来填充datagridview详细过程
u014194297的博客
09-10 2705
花了一个早上，跨过无数坑，终于搞定了，二维的list数据填充进datagridview里，用的是datasource的绑定方式，不是一行一行填充，另外这个datagridview是空白的，未经过设计的，没有任何列，看代码！！！ 顺便提一下，手动一行一行填充datagridview的方法也说一下 private void addDgv(string p1, string p2, string ...
C#---二维数组
热门推荐
renwen1579的博客
10-19 3万+
【千锋合集】史上最全Unity3D全套教程|匠心之作_哔哩哔哩_bilibili 1.有两个下标的数组称为二维数组 2.二维数组本质上是以数组作为数组元素的数组，即数组的数组 二维数组的初始化 动态初始化 类型[，] 数组名=new 类型[常量表达式1，常量表达式2]； 例如：int[,] array=new int[2,3]{{1,2,3},{1,2,3}} int[,] map=new int[,]{{1,2,3},{4,5,6}} 注意：第二维的个数必须相同，例如上面的...
c#二维LIST赋值问题
qq_42310470的博客
10-16 1546
发现了c#二维list一个小问题和解决方法 问题描述 我定义了一个二维List： List<List> c = new List<List>(); 我想向其中添加元素，所以定义了一个：List b = new List(); 然后呢，添加c.Add(b ); 之后，我把b.Clear()了，目的是从新给b 赋值，但是c中的元素也被清空了。就很奇怪…暂时想到重新new b解决...
【C#】读取txt、csv等二维表
编程记录，亲测有效
04-28 2943
程序要读文件，在实战中主要还是以二维表为主，类似下图这种： 基本上除了掌握《【C#】txt的读写》（点击打开链接）的文件流的读写，还需要与《【C#】利用正则表达式判断输入是否为纯数字、容器类》（点击打开链接）灵活运用。本文将使用《【Java】一行代码读完记事本中的二维表》（点击打开链接）的思想，展示在C#如何读取这个的二维表，读入到Listview当中。 首先是场景布置，没什么好说的，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值