List泛型自定义类型排序和大小比较C#版

最新推荐文章于 2024-06-02 22:29:24 发布
最新推荐文章于 2024-06-02 22:29:24 发布
阅读量3.2k 收藏 2
点赞数
分类专栏： .net
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/joycesunny/article/details/23343297
版权

想删除一堆大小相同的文件，于是想到用List泛型自定义类型排序和大小比较，准备先大小排序，再比较删除同大小的

1、随便来个自定义类

public class FileSort
    {
        long filesize;

        public long Filesize
        {
            get { return filesize; }
            set { filesize = value; }
        }

        string filepath;

        public string Filepath
        {
            get { return filepath; }
            set { filepath = value; }
        }
    }

2、List<FileSort> list= new List<FileSort>();

    把需要处理的文件信息填进list  //此处代码略

 

3、自定义排序

 private int CompareByFileSize(FileSort x, FileSort y)
        {
            int returnVal = y.Filesize.CompareTo(x.Filesize);
            return returnVal;
        }

        list.Sort(CompareByFileSize);


4、比较大小，删除相同大小的

                int m = 0;
                while (m < list.Count - 1)
                {
                    if (list[m].Filesize == list[m + 1].Filesize)
                    {
                        new FileInfo(list[m + 1].Filepath).Delete();
                        list.RemoveAt(m + 1);
                    }
                    else
                    {
                        m++;
                    }
                }


 5、要是觉得大小相同还不放心的话那就再加个hash吧

我设定一个文件大于16K的话用FileStream读文件开头的16K，小于则全部读进byte[] readBytes

int hash = Encoding.ASCII.GetString(readBytes).GetHashCode(); 比较的话先比大小，大小一样加比hash

                int m = 0;
                while (m < list.Count - 1)
                {
                    if (list[m].Filesize == list[m + 1].Filesize)
                    {
                        if (list[m].Hash == list[m + 1].Hash)
                        {
                             new FileInfo(list[m + 1].Filepath).Delete();
                            list.RemoveAt(m + 1);
                        }
                        else
                        {
                            m++;
                        }
                    }
                    else
                    {
                        m++;
                    }
                }


完整代码

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.IO;
using System.Threading;
using System.Text;
using System.ComponentModel;

namespace TEST
{
    public partial class Form1 : Form
    {
        StringBuilder sb = new StringBuilder();

        public Form1()
        {
            InitializeComponent();
            textBox1.Text = "不显示查找速度更快适合大数据量文件操作";
        }

        public void FindFileShow(object o)
        {
            FindParameter fp = (FindParameter)o;
            DirectoryInfo di = new DirectoryInfo(fp.Path);
            FileInfo[] fis = di.GetFiles(fp.Filename);
            DirectoryInfo[] dis = di.GetDirectories();

            foreach (FileInfo i in fis)
            {
                this.Invoke(new MethodInvoker(() => { sb.Append(i.FullName + "\r\n"); textBox1.Text = sb.ToString(); label3.Text = (int.Parse(label3.Text) + 1).ToString(); }));
            }

            foreach (DirectoryInfo i in dis)
            {
                try
                {
                    fp.Path = i.FullName;
                    FindFileShow(fp);
                }
                catch (Exception)
                {
                    //Undo
                }
            }
        }

        public void FindFileHide(object o)
        {
            FindParameter fp = (FindParameter)o;
            DirectoryInfo di = new DirectoryInfo(fp.Path);
            FileInfo[] fis = di.GetFiles(fp.Filename);
            DirectoryInfo[] dis = di.GetDirectories();

            foreach (FileInfo i in fis)
            {
                this.Invoke(new MethodInvoker(() => { sb.Append(i.FullName + "\r\n"); label3.Text = (int.Parse(label3.Text) + 1).ToString(); }));
            }

            foreach (DirectoryInfo i in dis)
            {
                try
                {
                    fp.Path = i.FullName;
                    FindFileHide(fp);
                }
                catch (Exception)
                {
                    //Undo
                }
            }
        }

        private void Form1_Resize(object sender, EventArgs e)
        {
            this.Width = 1024;
            this.Height = 768;
        }

        private void textBox2_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("需要手动输入查找路径吗(文件量太大时手动输入可减少不必要的打开时间)？", "手动确认", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
            {
                //Undo
            }
            else
            {
                FolderBrowserDialog fbd = new FolderBrowserDialog();
                if (fbd.ShowDialog() == DialogResult.OK)
                    textBox2.Text = fbd.SelectedPath;
            }
        }

        private int CompareByFileSize(FileSort x, FileSort y)
        {
            int returnVal = y.Filesize.CompareTo(x.Filesize);
            return returnVal;
        }

        private int CompareByHash(FileSort x, FileSort y)
        {
            int returnVal = y.Hash.CompareTo(x.Hash);
            return returnVal;
        }

        private int CompareByFileName(FileSort x, FileSort y)
        {
            int returnVal = y.Filename.CompareTo(x.Filename);
            return returnVal;
        }

        private void 显示目录查找ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            sb = new StringBuilder();
            textBox1.Text = "";
            label3.Text = "0";
            FindParameter fp = new FindParameter();
            fp.Path = textBox2.Text;
            fp.Filename = textBox3.Text;
            BackgroundWorker worker = new BackgroundWorker();
            worker.WorkerReportsProgress = false;
            worker.DoWork += (s, o) =>
            {
                FindFileShow(fp);
            };
            worker.RunWorkerCompleted += (s, o) =>
            {
                MessageBox.Show("查找成功！");
            };
            worker.RunWorkerAsync();
        }

        private void 不显示目录查找ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            sb = new StringBuilder();
            textBox1.Text = "不显示查找速度更快适合大数据量文件操作";
            label3.Text = "0";
            FindParameter fp = new FindParameter();
            fp.Path = textBox2.Text;
            fp.Filename = textBox3.Text;
            BackgroundWorker worker = new BackgroundWorker();
            worker.WorkerReportsProgress = false;
            worker.DoWork += (s, o) =>
            {
                FindFileHide(fp);
            };
            worker.RunWorkerCompleted += (s, o) =>
            {
                MessageBox.Show("查找成功！");
            };
            worker.RunWorkerAsync();
        }

        private void 删除所有找到ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("确定要删除所有找到文件吗？", "删除确认", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
            {
                BackgroundWorker worker = new BackgroundWorker();
                worker.WorkerReportsProgress = true;
                progressBar1.Visible = true;
                progressBar1.Value = 0;
                worker.DoWork += (s, o) =>
                {
                    string[] filepath = sb.ToString().Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                    int k = 1;
                    foreach (string i in filepath)
                    {
                        try
                        {
                            FileInfo fi = new FileInfo(i);
                            fi.Delete();
                        }
                        catch (Exception)
                        {
                            //Undo
                        }
                        worker.ReportProgress((int)((float)k / (float)filepath.Length * 100), null);
                        k++;
                    }
                };
                worker.ProgressChanged += (s, o) =>
                {
                    progressBar1.Style = ProgressBarStyle.Continuous;
                    progressBar1.Value = o.ProgressPercentage;
                };
                worker.RunWorkerCompleted += (s, o) =>
                {
                    progressBar1.Visible = false;
                    MessageBox.Show("删除成功！");
                };
                worker.RunWorkerAsync();
            }
        }

        private void 删除大小重复ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("确定要删除大小重复文件吗？", "删除确认", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
            {
                BackgroundWorker worker = new BackgroundWorker();
                worker.WorkerReportsProgress = true;
                progressBar1.Visible = true;
                progressBar1.Value = 0;
                worker.DoWork += (s, o) =>
                {
                    string[] filepath = sb.ToString().Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                    List<FileSort> list = new List<FileSort>();
                    int k = 1;
                    foreach (string i in filepath)
                    {
                        try
                        {
                            FileInfo fi = new FileInfo(i);
                            FileSort fs = new FileSort();
                            fs.Filesize = fi.Length;
                            fs.Filepath = i;
                            list.Add(fs);
                        }
                        catch (Exception)
                        {
                            //Undo
                        }
                        worker.ReportProgress((int)((float)k / (float)filepath.Length * 50), null);
                        k++;
                    }

                    list.Sort(CompareByFileSize);
                    int m = 0;
                    while (m < list.Count - 1)
                    {
                        if (list[m].Filesize == list[m + 1].Filesize)
                        {
                            new FileInfo(list[m + 1].Filepath).Delete();
                            list.RemoveAt(m + 1);
                        }
                        else
                        {
                            m++;
                            worker.ReportProgress((int)((float)m / (float)(list.Count - 1) * 50) + 50, null);
                        }
                    }
                };
                worker.ProgressChanged += (s, o) =>
                {
                    progressBar1.Style = ProgressBarStyle.Continuous;
                    progressBar1.Value = o.ProgressPercentage;
                };
                worker.RunWorkerCompleted += (s, o) =>
                {
                    progressBar1.Visible = false;
                    MessageBox.Show("删除成功！");
                };
                worker.RunWorkerAsync();
            }
        }

        private void 一般精确删除重复ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("确定要一般精确删除重复文件吗？", "删除确认", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
            {
                BackgroundWorker worker = new BackgroundWorker();
                worker.WorkerReportsProgress = true;
                progressBar1.Visible = true;
                progressBar1.Value = 0;
                worker.DoWork += (s, o) =>
                {
                    string[] filepath = sb.ToString().Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                    int k = 1;
                    List<FileSort> list = new List<FileSort>();
                    foreach (string i in filepath)
                    {
                        try
                        {
                            FileInfo fi = new FileInfo(i);
                            FileSort fs = new FileSort();
                            fs.Filesize = fi.Length;
                            fs.Filepath = i;
                            FileStream file = fi.OpenRead();
                            byte[] read;
                            if (fi.Length >= 1024 * 16)
                            {
                                read = new byte[1024 * 16];
                                file.Seek(0, SeekOrigin.Begin);
                                file.Read(read, 0, 1024 * 16);
                                file.Close();
                            }
                            else
                            {
                                read = new byte[fi.Length];
                                file.Seek(0, SeekOrigin.Begin);
                                file.Read(read, 0, (int)fi.Length);
                                file.Close();
                            }
                            fs.Hash = Encoding.ASCII.GetString(read).GetHashCode();
                            list.Add(fs);
                        }
                        catch (Exception)
                        {
                            //Undo
                        }
                        worker.ReportProgress((int)((float)k / (float)filepath.Length * 50), null);
                        k++;
                    }
                    list.Sort(CompareByFileSize);
                    int m = 0;
                    while (m < list.Count - 1)
                    {
                        if (list[m].Filesize == list[m + 1].Filesize)
                        {
                            if (list[m].Hash == list[m + 1].Hash)
                            {
                                new FileInfo(list[m + 1].Filepath).Delete();
                                list.RemoveAt(m + 1);
                            }
                            else
                            {
                                m++;
                                worker.ReportProgress((int)((float)m / (float)(list.Count - 1) * 50) + 50, null);
                            }
                        }
                        else
                        {
                            m++;
                            worker.ReportProgress((int)((float)m / (float)(list.Count - 1) * 50) + 50, null);
                        }
                    }
                };
                worker.ProgressChanged += (s, o) =>
                {
                    progressBar1.Style = ProgressBarStyle.Continuous;
                    progressBar1.Value = o.ProgressPercentage;
                };
                worker.RunWorkerCompleted += (s, o) =>
                {
                    progressBar1.Visible = false;
                    MessageBox.Show("删除成功！");
                };
                worker.RunWorkerAsync();
            }
        }

        private void 完全精确删除重复ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("确定要完全精确删除重复文件吗？", "删除确认", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
            {
                BackgroundWorker worker = new BackgroundWorker();
                worker.WorkerReportsProgress = true;
                progressBar1.Visible = true;
                progressBar1.Value = 0;
                worker.DoWork += (s, o) =>
                {
                    string[] filepath = sb.ToString().Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                    int k = 1;
                    List<FileSort> list = new List<FileSort>();
                    foreach (string i in filepath)
                    {
                        try
                        {
                            FileInfo fi = new FileInfo(i);
                            FileSort fs = new FileSort();
                            fs.Filesize = fi.Length;
                            fs.Filepath = i;
                            FileStream file = fi.OpenRead();
                            byte[] read = new byte[(int)fi.Length];
                            file.Seek(0, SeekOrigin.Begin);
                            file.Read(read, 0, (int)fi.Length);
                            file.Close();
                            fs.Hash = Encoding.ASCII.GetString(read).GetHashCode();
                            list.Add(fs);
                        }
                        catch (Exception)
                        {
                            //Undo
                        }
                        worker.ReportProgress((int)((float)k / (float)filepath.Length * 50), null);
                        k++;
                    }
                    list.Sort(CompareByFileSize);
                    int m = 0;
                    while (m < list.Count - 1)
                    {
                        if (list[m].Filesize == list[m + 1].Filesize)
                        {
                            if (list[m].Hash == list[m + 1].Hash)
                            {
                                new FileInfo(list[m + 1].Filepath).Delete();
                                list.RemoveAt(m + 1);
                            }
                            else
                            {
                                m++;
                                worker.ReportProgress((int)((float)m / (float)(list.Count - 1) * 50) + 50, null);
                            }
                        }
                        else
                        {
                            m++;
                            worker.ReportProgress((int)((float)m / (float)(list.Count - 1) * 50) + 50, null);
                        }
                    }
                };
                worker.ProgressChanged += (s, o) =>
                {
                    progressBar1.Style = ProgressBarStyle.Continuous;
                    progressBar1.Value = o.ProgressPercentage;
                };
                worker.RunWorkerCompleted += (s, o) =>
                {
                    progressBar1.Visible = false;
                    MessageBox.Show("删除成功！");
                };
                worker.RunWorkerAsync();
            }
        }

        private void 删除旧时间重复文件ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("确定要删除重复名称旧时间文件吗？", "删除确认", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
            {
                BackgroundWorker worker = new BackgroundWorker();
                worker.WorkerReportsProgress = true;
                progressBar1.Visible = true;
                progressBar1.Value = 0;
                worker.DoWork += (s, o) =>
                {
                    string[] filepath = sb.ToString().Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                    int k = 1;
                    List<FileSort> list = new List<FileSort>();
                    foreach (string i in filepath)
                    {
                        try
                        {
                            FileInfo fi = new FileInfo(i);
                            FileSort fs = new FileSort();
                            fs.Filename = fi.Name;
                            fs.Filepath = i;
                            fs.Lasttime = fi.LastWriteTimeUtc;
                            list.Add(fs);
                        }
                        catch (Exception)
                        {
                            //Undo
                        }
                        worker.ReportProgress((int)((float)k / (float)filepath.Length * 50), null);
                        k++;
                    }
                    list.Sort(CompareByFileName);
                    int m = 0;
                    while (m < list.Count - 1)
                    {
                        if (list[m].Filename == list[m + 1].Filename)
                        {
                            if (list[m].Lasttime >= list[m + 1].Lasttime)
                            {
                                new FileInfo(list[m + 1].Filepath).Delete();
                                list.RemoveAt(m + 1);
                            }
                            else
                            {
                                new FileInfo(list[m].Filepath).Delete();
                                list.RemoveAt(m);
                            }
                        }
                        else
                        {
                            m++;
                            worker.ReportProgress((int)((float)m / (float)(list.Count - 1) * 50) + 50, null);
                        }
                    }
                };
                worker.ProgressChanged += (s, o) =>
                {
                    progressBar1.Style = ProgressBarStyle.Continuous;
                    progressBar1.Value = o.ProgressPercentage;
                };
                worker.RunWorkerCompleted += (s, o) =>
                {
                    progressBar1.Visible = false;
                    MessageBox.Show("删除成功！");
                };
                worker.RunWorkerAsync();
            }
        }
    }

    public class FindParameter
    {
        string path;

        public string Path
        {
            get { return path; }
            set { path = value; }
        }
        string filename;

        public string Filename
        {
            get { return filename; }
            set { filename = value; }
        }
    }

    public class FileSort
    {
        long filesize;

        public long Filesize
        {
            get { return filesize; }
            set { filesize = value; }
        }

        string filepath;

        public string Filepath
        {
            get { return filepath; }
            set { filepath = value; }
        }

        int hash;

        public int Hash
        {
            get { return hash; }
            set { hash = value; }
        }

        string filename;

        public string Filename
        {
            get { return filename; }
            set { filename = value; }
        }

        DateTime lasttime;

        public DateTime Lasttime
        {
            get { return lasttime; }
            set { lasttime = value; }
        }
    }
}


@CAPRICA@
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
list泛型自定义排序示例
10-26
在.NET编程环境中，List泛型类是常用的集合类型，它提供了丰富的操作方法，包括排序功能。本示例主要探讨如何自定义排序逻辑，使特定元素优先出现在列表前面。这个过程通常涉及委托和比较器，通过定义自定义的比较...
『Java』集合--Collection概念+List派系
Jack的博客----我要实现梦想,我要为之奋斗
02-08 1301
集合类 为什么出现集合类： 面向对象语言对事物的体现是以对象的形式，所以为了方便对多个对象的操作， 就对对象进行存储，集合就是存储对象最常用的一种方式 数组和集合类同是容器，区别： 数组虽然也可以存储对象，但长度是固定的：集合长度是可变的 数组中可以
C#中大List的内存分配
weixin_34360651的博客
03-28 349
之前在开发中只用到List的时候几乎就是拿过来就用，从来没有考虑过List的内存分配问题，试想一个有10万元素的List的在构造和添加元素时内存是如何变化的呢？在MSDN上关于List的Capacity属性是这么解释的，也就是说，当我们添加的元素数量小于等于Capacity的值时，List是不会重新调整内部数据结构，也就是不会重新申请或者分配内存，而当我们添加的元素数量大于Capacity 的值时...
【C#】自定义List排序规则的两种方式
最新发布
qq_63231615的博客
06-02 765
1.系统排序原理 2.方式一：调用接口并重写 3.方式二：传排序规则函数做参数
【 Daily 】比较大小（C#实现）
qq_46354133的博客
04-09 1508
/* 程序问题注释开始 程序的版权和版本声明部分 Copyright © 2020,湖南工程职业技术学院信息工程学院学生 All rights reserved. 文件名称： 取数值 作 者： 李 斌 完成日期： 2020 年 04 月 09日 对任务及求解方法的描述部分 问题描述 　　三个数从小到大输出 输入格式 　　输入三个整数 x ...
C# 泛型集合的自定义类型排序的实现
12-16
一、泛型集合List排序 经sort方法之后，采用了升序的方式进行排列的。 List<int> list = new List() { 2, 4, 1, 3, 5, -2, 0, 10 }; Console.Write("排序前..."); foreach (var item in list) { Console.Write...
c#实现对泛型数组排序
12-26
本文将深入探讨如何在C#中使用泛型和数组排序，并结合面向对象原则，尤其是ASP.NET和.NET框架中的相关概念。 首先，我们需要理解什么是泛型。在C#中，泛型允许我们定义类型参数化的类、接口和方法。这意味着在编写...
LIST泛型排序
01-07
这就是“LIST泛型排序”所涉及的主题。在本篇文章中，我们将深入探讨如何实现这个功能，并通过一个具体的示例来阐述。 首先，泛型是Java中的一种机制，允许我们在定义类、接口和方法时引入类型参数，从而提高代码的...
C#源代码-List泛型集合.zip
06-04
在本压缩包"C#源代码-List泛型集合.zip"中，重点聚焦于C#中的`List<T>`类，这是一个非常常用的泛型集合，用于存储同类型的元素序列。`List<T>`是`System.Collections.Generic`命名空间下的一个类，它实现了`IList<T>...
自定义的Troop<T>泛型类（ c++, java和c#）的实现代码
08-30
自定义的`Troop<T>`泛型类是一个通用的数据结构，它在C++、Java和C#中都有相应的实现。这个泛型类的设计目的是提供一个轻量级的列表操作类，适用于那些对性能要求不高或者数据量不大的场景。`Troop<T>`包含了多种...
用泛型比较各种数据类型
11-04
泛型不仅限于比较和排序，还可以用于容器类（如Dictionary, TValue>）、集合（如List）以及其他各种数据结构，确保在存储和操作数据时保持类型安全。此外，泛型委托（比如Func, TResult>和Action）允许我们在不指定...
C# List介绍及具体用法
12-23
一、# List泛型集合 集合是OOP中的一个重要概念，C#中对集合的全面支持更是该语言的精华之一。 为什么要用泛型集合？ 在C# 2.0之前，主要可以通过两种方式实现集合： a.使用ArrayList 直接将对象放入ArrayList，操作...
C#源代码-List泛型集合的三个练习.zip
06-04
本压缩包文件“C#源代码-List泛型集合的三个练习”包含了三个练习，旨在帮助学习者深入理解和应用List类。以下是对这些练习知识点的详细说明： 1. **泛型基础** 泛型是C#中的一种强大的特性，它允许创建可重用的...
C# System.Collections 非泛型接口方法解析.pdf
12-27
在C#编程中，System.Collections命名空间包含了许多非泛型集合接口，这些接口是.NET框架早期版本的基础，尽管现在泛型集合接口（如`IEnumerable<T>`）更为常用，但理解非泛型接口对于维护旧代码或处理特定场景仍然很...
c#输入三个数选出最大的_C#比较三个数的大小
weixin_42636454的博客
12-28 3389
usingSystem;usingSystem.Collections.Generic;usingSystem.Text;namespacewuxiaoguang{classProgram{staticvoidMain(string[]args){doublea=0,b=0,c=0,d=0;//中间变量。try{Console.WriteLine("比较三个数...
C# 比较多个数组（lambda,匿名比较器）
weixin_30562507的博客
03-20 370
//逐个比较，找出最大的那个数组 static void Main(string[] args) { //测试数据 int[] num0 = { 5, 8, 6 }; int[] num1 = { 12, 9, 1 }; int[] num2 = { 3, 7, 2 };...
c# list 容量_C# ArrayList的用法总结
weixin_39988331的博客
01-26 740
C# ArrayList的用法总结System.Collections.ArrayList类是一个特殊的数组。通过添加和删除元素，就可以动态改变数组的长度。一、优点1. 支持自动改变大小的功能2. 可以灵活的插入元素3. 可以灵活的删除元素4. 可以灵活访问元素二、局限性跟一般的数组比起来，速度上差些三、添加元素1．public virtual int Add(object value);将对象添...
C#基础之数组排序，对象大小比较
weixin_34198583的博客
08-19 219
 C#基础之数组排序，对象大小比较转：http://www.cnblogs.com/yukaizhao/archive/2011/08/19/csharp-compare.html从个小例子开始：view sourceprint?1int[] intArray = new int[]{2,3,6,1,4,5};2Array.Sort(intArray);3Array.ForEach&lt;int&...
"使用泛型集合List<T>-C: 实现类型安全和灵活度
在C#编程语言中，使用泛型集合List是一种非常常见和有用的方式。泛型集合允许我们在编译时指定集合中存储的数据类型，并且提供了许多强大的操作和功能。在本篇文章中，我们将深入探讨使用泛型集合List的各个方面。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值