c#学习笔记004days

最新推荐文章于 2024-08-08 23:29:04 发布
最新推荐文章于 2024-08-08 23:29:04 发布
阅读量105 收藏
点赞数
分类专栏： c#学习笔记 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asdjsakl123/article/details/107133533
版权

004days

  1. Statck__Queue(栈和队列）
  2. ArrayList
  3. Dictionary
  4. List
  5. Hashtable

Statck__Queue(栈和队列）

using System;
using System.Collections;

namespace Statck__Queue
{//Statck Queue
 //栈，   队列
 //区别
 //栈:先进先出
 //队列：先进后出
 // using System.Collections
    class Program
    {
        static void Main(string[] args)
        {
            STATCK();
            QUEUE();
        }
        public static void STATCK()
        {
            //实例化一个栈
            Stack s = new Stack();
            //将一个元素压栈
            s.Push("hello");
            s.Push("h");
            s.Push("e");
            s.Push("l");
            s.Push("o");
            //获取栈顶的元素
            object ele = s.Peek();
            Console.WriteLine(ele);
            //将栈顶元素出栈,返回刚刚出栈的元素
            object e = s.Pop();

            //遍历集合
            foreach (object obj in s)
            {
                Console.WriteLine(obj);
            }
        }
        public static void QUEUE()
        {//实例化一个Queue
            Queue q = new Queue();
            //将一个元素放到队列中
           q.Enqueue("hello");
            q.Enqueue("h");
            q.Enqueue("e");
            q.Enqueue("l");
            q.Enqueue("o");
            //获取排在队列首位的元素
            object ele = q.Peek();
            Console.WriteLine(ele);
            //将队首元素移出队列，放回值为刚刚移出的元素
            object e = q.Dequeue();
        }
    }
}

ArrayList

using System;
using System.Collections;
namespace housebook5
{
    //集合：是一个容器，是用来存储兼容的数据类型的容器
    #region
    /*
    //数组和集合的不同点
    //1.数组是定长的容器，而集合是变长的容器
    //2.集合提供了很多的快捷的方法来操作元素

    //1.ArrayList：一个类似于数组的容器
    //using System.Collectioms
    {
        class Program
        {
            static void Main(string[] args)
            {//实例化一个ArrayList对象
                //增、删、改、查
                //ArrayList中可以添加的元素类型为object
                ArrayList list = new ArrayList();
                //增
                AddOperation(list);
                //删
                RemoveOperation(list);
                //改
                UpdateOperation(list);
                //查
                SearchOperation(list);
                //其他方法


            }
            public static void AddOperation(ArrayList list)
            {//增，可以添加任意类型的元素
                list.Add(1);
                list.Add("hello world");
                list.Add(3.14);
                list.Add(true);
                //批量添加:将一个集合中的元素添加到另外一个集合中
                list.AddRange(new int[] { 1, 2, 3 });
                list.Add(new int[] { 1, 2, 3 });
                Console.WriteLine(list.Count);
                //插入
                list.Insert(0, "hello world");
                //批量插入元素
                list.InsertRange(0,new bool[] {true,false,true })
            }
            public static void RemoveOperation(ArrayList list)
            {//移除指定的第一个元素
                list.Remove(1);
                //移除指定下标的元素
                //注意不要越界
                list.RemoveAt(4);
                //给定一个下标和长度，确定一个范围，移除这个范围内的元素
                //注意：不要越界，长度不要超出
                list.RemoveRange(3, 2);

            }
            public static void UpdateOperation(ArrayList list)
            {//1.通过下标来修改一个元素
                list[1] = 1;
                //2.批量修改元素
                list.SetRange(0, new string[] { "a", "b", "c"});
           }
            public static void SearchOperation(ArrayList list)
            {//通过便利下标
             //   for(int i = 0; i < list.Count; i++)
             // {
             //   Console.WriteLine(list[i]);
             //}
             //2.通过foreach遍历
             //注意：在foreach中，遍历的元素类型一定要和集合中存储的元素类型保持一致
             //如果遍历的类型和集合中类型中不一样，会将集合中的的元素进行强制类型转换
             // foreach(object obj in list)
             //  {//在foreach中不可以修改集合
             //     Console.WriteLine(obj)}
             //3.通过枚举器/迭代器来遍历，也不能修改集合
                IEnumerator em = list.GetEnumerator();
                while (em.MoveNext())
                {
                    object obj = em.Current;
                    Console.WriteLine(obj);
                }
                //查找某个元素对应的下标
                int index = list.IndexOf(3);  //查询某个元素第一次出现的下标
                int index2 = list.LastIndexOf(3); //查询某个元素最后一次出现的下标
                int index3 = list.BinarySearch(3); //使用二分查找查询某个元素

            }
            public static void OtherOperation(ArrayList list)
            {//1.集合排序，默认是降序
                list.Sort();
                //集合倒序
                list.Reverse();
                //3.判断集合中是否包含某个元素
                bool contains = list.Contains(1);
                //4、将一个集合中的元素拷贝到另外一个集合中
                object[] newList = new object[10];
                list.CopyTo(newList);

            }
        } 

    */
    #endregion
    //设计一个person类
    //字段：int age;
    //设计一个Arraylist的集合,在这个集合中添加10个person对象
    //将这个集合中的元素按照年龄进行升序排序
    //试一下:sort（）方法能不能实现？
    #region
    /*


    //Q:集合中可以存储任何类型的数据,如果集合中存储的是自定义的类型,如何使用sort
    //A:
    //1.sort()：会将集合中的元素按照一定的规则进行排序
    //1.通过Icomparable接口实现
    //让集合中需要排序的元素对应的类去实现这个接口

    class Peolpe:IComparable, IComparable<Peolpe>
    {
        public int age;
       public Peolpe(int age)
        {
            this.age = age;
        }
        public override string ToString()
        {
            return age+"";
        }
        //1.这个方法就是Icomparable接口中自定义比较规则的方法
        //前提:要比较的两个对象是谁?this和obj
        //==0:this==obj
        //>0 this>obj
        //<0 this<obj
         public int CompareTo(object obj)
        {

            //先判断obj是不是person类型的
            if (obj is Peolpe)
            {
                Peolpe anotherpeople = obj as Peolpe;

                //将比较结果返回
                return age - anotherpeople.age;
            }
            else
                return 0;
        }

        //2.使用 IComparable<Peolpe>来定义规则
        public int CompareTo(Peolpe obj)
        {
            return age - obj.age;
        }
    }
    class Program
    {
        public static void Main(string[] args)
        {
            ArrayList list = new ArrayList();
            ADD(list);
            list.Sort();
            foreach (object obj in list)
            {
                Console.WriteLine(obj);
            }

        }
        public static void ADD(ArrayList list)
        {
            list.Add(new Peolpe(3));
            list.Add(new Peolpe(4));
            list.Add(new Peolpe(5));
            list.Add(new Peolpe(6));
            list.Add(new Peolpe(1));
            list.Add(new Peolpe(2));
            list.Add(new Peolpe(7));
            list.Add(new Peolpe(10));
            list.Add(new Peolpe(9));
            list.Add(new Peolpe(8));

        }
    }
    */
    #endregion
}```

## Dictionary

```csharp
using System;
using System.Collections.Generic;
//Dictionary<>:类似于Hashtable,存储的元素也是键值对
//using System.Collections.Generic;
namespace Dictionary
{
    class Program
    {
        static void Main(string[] args)
        {//实例化一个Dictionary对象
            Dictionary<string, string> dic = new Dictionary<string, string>();
          //增
        AddOperation(dic);
         //删
        RemoveOperation(dic);
         // 改
        UpdateOperation(dic);
           //查
        SearchOperation(dic);
       }
        //增
        static void AddOperation(Dictionary<string, string> dic)
        {//添加

            dic.Add("name", "xiaohong");
            dic.Add("age", "10");
            dic.Add("gender", "male");
            dic.Add("score", "59.9");
        }
        //删
        static void RemoveOperation(Dictionary<string, string> dic)
        {
            dic.Remove("age");
        }
        //改
        static void UpdateOperation(Dictionary<string, string> dic)
        {
            dic["name"] = "laowang";
        }
        //查
        static void SearchOperation(Dictionary<string, string> dic)
        {//直接遍历Dictionary
         //Dictionary<>中的元素类型是keyvaluepair<>
         foreach(KeyValuePair<string,string> obj in dic)
            {
                Console.WriteLine(obj);
            }
            foreach (KeyValuePair<string, string> obj in dic)
            {
                string key = obj.Key;
                string value = obj.Value;
                Console.WriteLine($"{key}={value}");
            }
            //获取dictionary中所有的key
            ICollection<string> keys = dic.Keys;
            foreach(string key in keys)
            {
                string value = dic[key];
                Console.WriteLine($"{key}={value}");
            }
        }
    }
}

List

using System;
using System.Collections.Generic;
/*
namespace List
{//list<>
 //也是一个集合,和ArrayList的区别"
 //list<>集合是只能存储指定类型的集合
// using System.Collections.Generic;
    class Program
    {
        static void Main(string[] args)
        {//实例化一个list对象
            List<string> list = new List<string>();        
           //实例化一个ArrayList对象
                //增、删、改、查
                //增
                AddOperation(list);
                //删
                RemoveOperation(list);
                //改
                UpdateOperation(list);
                //查
                SearchOperation(list);
                //其他方法


            }
            public static void AddOperation(List<string> list)
            {//增，可以添加任意类型的元素
                list.Add("阿童木");
                list.Add("hello world");
                list.Add("一休");
             list.Add("大力水手");
            list.Add("大力水手");
            list.Add("大力水手");
            list.Add("大力水手");
            list.Add("大力水手");
            list.Add("大力水手");

            //批量添加:将一个集合中的元素添加到另外一个集合中
            list.AddRange(new string[] { "1", "2", "3" });
                Console.WriteLine(list.Count);
                //插入
                list.Insert(0, "hello world");
            //批量插入元素
            list.InsertRange(0, new string[] { "true", " false, true" });
            }
            public static void RemoveOperation(List<string> list)
            {//移除指定的第一个元素
                list.Remove("一休");
                //移除指定下标的元素
                //注意不要越界
                list.RemoveAt(4);
                //给定一个下标和长度，确定一个范围，移除这个范围内的元素
                //注意：不要越界，长度不要超出
                list.RemoveRange(3, 2);
            //4\删除所有满足条件的匹配项
            // 1. list.RemoveAll(Method);
            //2.
            list.RemoveAll(name => name == "大力水手");
            }
        public static bool Method(string obj)
        {
            return obj == "大力水手";
        }
            public static void UpdateOperation(List<string> list)
            {//1.通过下标来修改一个元素
                list[0] = "机械暴龙兽";
            }
            public static void SearchOperation(List<string> list)
            {//通过便利下标
             //   for(int i = 0; i < list.Count; i++)
             // {
             //   Console.WriteLine(list[i]);
             //}
             //2.通过foreach遍历
             //注意：在foreach中，遍历的元素类型一定要和集合中存储的元素类型保持一致
             //如果遍历的类型和集合中类型中不一样，会将集合中的的元素进行强制类型转换
             // foreach(object obj in list)
             //  {//在foreach中不可以修改集合
             //     Console.WriteLine(obj)}
             //3.通过枚举器/迭代器来遍历，也不能修改集合
                IEnumerator<string> em = list.GetEnumerator();
                while (em.MoveNext())
                {
                    object obj = em.Current;
                    Console.WriteLine(obj);
                }
                //查找某个元素对应的下标
                int index = list.IndexOf("机械暴龙兽");  //查询某个元素第一次出现的下标
                int index2 = list.LastIndexOf("机械暴龙兽"); //查询某个元素最后一次出现的下标
                int index3 = list.BinarySearch("机械暴龙兽"); //使用二分查找查询某个元素

            }
            public static void OtherOperation(List<string> list)
            {//获取一个集合中的子集
            List<string> sub = list.GetRange(1, 2);
            //Exists:判断集合中受否存在指定条件的元素
            bool result = list.Exists(name=>name=="阿童木");
            //Contains：判断集合中是否包含指定的元素
            }
        }

    }

    */
namespace Other
{
    class Program
    {public static void Main(string[] args)
        {
            //实例化一个集合
            List<int> list = new List<int>();
            //添加元素
            list.AddRange(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
            //判断集合中是否包含指定条件的元素
            bool result = list.Exists(number => number % 2 != 0);
            Console.WriteLine(result);
            //查找集合中的第一个奇数
            int n = list.Find(number => number % 2 != 0);
            Console.WriteLine(n);
            //查找集合中所有的奇数
           List<int> results= list.FindAll(number => number % 2 != 0);
            //第一个奇数的下标
            list.FindIndex(number => number % 2 != 0);
            //查找集合中最后一个奇数
            list.FindLast(number => number % 2 != 0);
            //移除所有的奇数
            list.RemoveAll(number => number % 2 != 0);
        }

    }
}

Hashtable

using System;
using System.Collections;
//Hashtable:是一个集合，存储的元素是一个  键值对（key-value-pair）
//键值对：是有两个值来组成，一个是键（key），一个是值（value）
//using System.Collections;
namespace xiaoming
{
    class Program
    {
        static void Main(string[] args)
        {//实例化一个Hashtable
            Hashtable table = new Hashtable();
            //增
            AddaOperation(table);
            //删除
            RemoveOperation(table);
            //改
            UpdateOperation(table);
            //查询操作
            searchOperation(table);
            //其他操作
            OtherOperation(table);


        }
        //增
        public static void AddaOperation(Hashtable table)
        {//hashtable中键值对的特点
         //1.键和值需要同时出现
         //2.键和值一一对应,一个键对应一个值
         //3.不允许出现相同的键（key）；，但可以出现相同的值（value）
         //4.Hashtable中的元素是按照key的hash编码来进行排序的，所以，hashtable中元素的顺序可能和添加的顺序是不一样的

            //添加的是键值对
            table.Add("name", "xiaoming");
            table.Add(1, "xiaoming");
            table.Add("xiaomingd", 10);
            table.Add(false, true);
            // table.Add(false, 13);会出现异常
        }
        //删
        public static void RemoveOperation(Hashtable table)
        {//通过key来删除一个键值对
            table.Remove("name");

        }
        //改
        public static void UpdateOperation(Hashtable table)
        {//通过键来修改值，
            table["name"] = "laowang";
            //还可以通过这种方式添加
            table["height"] = 173;

        }
        //查询操作
        public static void searchOperation(Hashtable table)
        {//1.
            /*
            //Hashtable中存储的元素类型是DictionaryEntry
            foreach(DictionaryEntry entry in table)
            {//获取一个键值对中的键
                object key = entry.Key;
                //获取一个键值对中的值
                object value = entry.Value;
                Console.WriteLine($"{key}={value}");*/
            //2
            //获取Hashtable中所有的Key
            ICollection keys = table.Keys;
            //遍历刚刚获取到的所有的key
            foreach(object key in keys)
            {//通过key来获取value
                object value = table[key];
                Console.WriteLine($"{ key}={value}");

            }


            }
        //其他操作
        public static void OtherOperation(Hashtable table) {
            //判断Hashtable中是否包含特定的键
            bool result = table.Contains("age");

        }

        }
    }
哈哈之哈死了123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Learning hard C# 学习笔记
04-01
《Learning Hard C# 学习笔记》是一份深入浅出的C#编程教程，旨在帮助初学者快速掌握C#这门强大的编程语言。C#是由微软公司开发的一种面向对象的编程语言，广泛应用于Windows平台、游戏开发（尤其是Unity引擎）、...
C#学习笔记
05-04
以下是对C#学习笔记的详细解读： 1. **基础语法**：C#的基础包括变量、数据类型（如整型、浮点型、布尔型、字符串等）、运算符（算术、比较、逻辑、赋值等）和控制结构（如条件语句、循环语句、switch语句）。初学...
C#学习笔记——基本语法
12-31
C#，又名Csharp，天朝喜欢叫C井。 C#是一种面向对象的编程语言。在面向对象的程序设计方法中，程序有各种相互交互的对象组成。相同种类的对象通常具有相同的类型，或者说，是在先沟通那个的class中。 例如,以...
C#学习笔记9月份-10月份
10-09
C#学习笔记9月份-10月份 本笔记涵盖了C#的多个方面，包括 LINQ 的强类型和即时执行、对象的生命周期、.NET 程序集、类型反射、元数据的必要性、迭代器、foreach 执行过程、索引器、枚举器、.NET Framework 类库、源...
C#学习总结
weixin_43284350的博客
08-08 639
用追马的时间种草吧
【滴水三期】32/64位——PE文件节表打印与解析
sunqingyu888的博客
08-03 461
【滴水三期】32/64位——PE文件节表打印与解析
[Kimi笔记]C# 项目涉及到几个关键概念：解决方案（Solution）、项目（Project）、代码、依赖和库。
m0_74331272的博客
08-04 314
在 Visual Studio 中创建 C# 项目时，涉及到几个关键概念：解决方案（Solution）、项目（Project）、代码、依赖和库。每个项目都有自己的项目文件（ .csproj ），其中定义了项目的配置、编译选项、依赖关系和其他元数据。当一个项目需要使用另一个项目的输出时，可以在项目中添加对另一个项目的引用。通过 NuGet，开发者可以搜索、安装和管理第三方库，这些库可以是开源的，也可以是商业的。项目是解决方案中的一个单独的组件，通常是编译成单个可执行文件或库文件的代码集合。
C#如何解决引用类型的“深度”克隆问题
qq_34059233的博客
08-08 197
在C#中我们new一个引用类型的对象称为对象1，如果我们再次new一个引用类型的对象称为对象2，如果直接将第一个对象直接赋值给第二个对象，然后如果我们这时候改变对象2的值，你会发现对象1的值也会被更改，这就是引用类型的浅克隆，因为引用类型的复制本质上并没有开辟新的内存，两个对象都是指向同一个内存，所以改变其中一个对象，另一个对象的值也会被改变。
C#：基本语法
wy2458984254的博客
08-06 1027
本人在实习过程需要用C#进行开发，但本人之前的技术栈是C++方向，所以在菜鸟教程上速通了一下C#的基本语法，总的来说和C++还是非常相似的。
c#12 实验特性Interceptor如何使用的一个简单但完整的示例
sdgfafg_25的博客
08-07 611
如果我们编译程序，就会看见生成了这样的文件代码return c.A;_ = path;如果运行ut ，结果也正确， debug 逐行调试也可看到断点能进入我们 生成的代码文件中引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构。
C# 使用 NLog 输出日志到文件夹
build2024
08-04 340
通过设置 ·maxArchiveDays·，可以实现自动管理日志文件的归档和清理，避免日志文件过多导致存储空间的浪费。=“5242880”: 文件归档大小尺寸，如果单文凭超过 5242880，则重新创建一个新的文件。或者创建一个共用的写日志静态类,需要输出日志的代码逻辑处，通过调用当前静态类即可。: 这些设置确保文件可以在多个进程中安全写入，同时不保持文件句柄打开。: 日志文件归档使用滚动编号，避免创建大量的备份文件。: 这表示每天生成一个新的日志文件。的文件夹，并在其中创建。属性：日志内容输出的模板。
[Kimi笔记]C# 中，public、private 和 internal 访问修饰符
m0_74331272的博客
08-04 340
在 C# 中，publicprivate和internal。
C# & Unity 面向对象补全计划 七大原则 之 接口隔离原则 (ISP) 难度：☆ 总结：大接口分成小的，然后该干啥干啥
2301_77947509的博客
08-05 311
该干啥干啥原则
在C#中配置ini文件以及封装ini类
weixin_64532720的博客
08-07 1051
在C#中使用DllImport属性从导入函数来写入和读取Windows的INI文件，你可以使用来写入数据，使用来读取数据。
C#:通用方法总结—第15集
m0_53104033的博客
08-04 459
大家好，今天继续分享我们的通用方法系列。 下面是今天的通用方法： （1）这个通用方法为用文件流写数据 /// /// 用文件流写数据 /// /// /// ///
C#:通用方法总结—第14集
m0_53104033的博客
08-04 495
大家好，今天继续介绍我们的通用方法系列。 下面是今天的通用方法： （1）这个通用方法为获取平面矢量 /// /// 获取平面矢量 /// /// /// public static double[] GetVector(Tag c)//获取平面矢量 { double[] point = new
005集——运算符——C#学习笔记
最新发布
yongshiqq的博客
08-08 767
C# 提供了许多运算符。其中许多都受到的支持，可用于对这些类型的值执行基本操作。通常可以这些运算符，也就是说，可以为用户定义类型的操作数指定运算符行为。最简单的 C# 表达式是文本（例如和）和变量名称。可以使用运算符将它们组合成复杂的表达式。运算符和决定了表达式中操作的执行顺序。可以使用括号更改由运算符优先级和结合性决定的计算顺序。
C# 自定义控件无法加载
小天花藏
08-04 183
Visual Studio 是 x86 的程序，要针对当前平台（x86）生成，才可以正常使用窗体设计器。在做winform开发时自己定义了一个控件，控件在工具箱中显示了，但是拖动到窗体设计器时会提示。点击确定后，控件会从工具箱中移除。,再重启项目，即可解决。
图书阅读推广平台
m0_73706453的博客
08-03 967
本次设计任务是要设计一个图书阅读推广平台，通过这个系统能够为用户提供更好的平台。系统的主要功能包括：用户、书籍信息等功能。 管理员可以根据系统给定的账号进行登录，登录后可以进入图书阅读推广平台，对图书阅读推广平台所有模块进行管理。包括查看和修改自己的个人信息以及登录密码。 该系统为每一个用户都分配了一个用户账号，用户通过账号的登录可以在系统中查看书籍信息及对个人信息进行修改等功能。
Python基本语法
xiyun_king的博客
08-07 793
除法运算/总是返回浮点数，如果要得到一个整数结果可以使用 // 运算符，要计算余数可以使用%，而且python全面支持浮点数，混合类型运算数的运算会把整数转化为浮点数python使用**运算符计算乘方交互模式下，上一次输出的表达式会赋值给变量_。把python当作计算器使用时，用该变量实现下一步计算更为简单。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值