C#中的6种常见的集合

1.动态数组（ArrayList）

　　动态数组（ArrayList）代表了可被单独索引的对象的有序集合。它基本上可以替代一个数组。但是，与数组不同的是，您可以使用索引在指定的位置添加和移除项目，动态数组会自动重新调整它的大小。它也允许在列表中进行动态内存分配、增加、搜索、排序各项。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demos
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();
            list.Add(10);//单个添加
            foreach (int number in new int[5]{ 1, 2, 3, 4,5 })
            {
                list.Add(number);//循环添加一个数组
            }
            int[] number2 = new int[2]{ 11,12 };
            list.AddRange(number2);//集体添加
            list.Remove(3);//删除值为3的
            list.RemoveAt(3);//移除下标为3的
            ArrayList list2 = new ArrayList(list.GetRange(1, 3));//新ArrayList（list2）只取旧ArrayList（list）中的一部份List<T>.GetRange（Index,?Count）从下标为1的开始取三个
            Console.WriteLine("Method One:");
            foreach (int i in list)
           {
                Console.WriteLine(i);//遍历方法一
            }
            Console.WriteLine("Method Two:");
            for (int i = 0; i != list2.Count; i++)//数组是length
            {
                int number = (int)list2[i];//一定要强制转换
                Console.WriteLine(number);//遍历方法二
            }
            Console.ReadKey();
        }
    }
}

2.哈希表（Hashtable） 

　　Hashtable 类代表了一系列基于键的哈希代码组织起来的键/值对。它使用键来访问集合中的元素。当您使用键访问元素时，则使用哈希表，而且您可以识别一个有用的键值。哈希表中的每一项都有一个键/值对。键用于访问集合中的项目。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demos
{
    class Program
    {
        static void Main(string[] args)
        {
            Hashtable ht = new Hashtable();

            ht.Add("1", "hello");
            ht.Add("2", "world");
            ht.Add("3", "I");
            ht.Add("4", "Love");
            ht.Add("5", "China");

            if (ht.ContainsValue("China"))//判断 Hashtable 是否包含指定的值。
            {
                Console.WriteLine("I know you love China！But China already has a collection");
            }
            else
            {
                ht.Add("5", "China");
            }
            // 获取键的集合
            ICollection key = ht.Keys;

            foreach (string k in key)
            {
                Console.WriteLine(k + ": " + ht[k]);
            }
            Console.ReadKey();
        }
    }
}

3.排序列表（SortedList） 

　　SortedList 类代表了一系列按照键来排序的键/值对，这些键值对可以通过键和索引来访问。排序列表是数组和哈希表的组合。它包含一个可使用键或索引访问各项的列表。如果您使用索引访问各项，则它是一个动态数组（ArrayList），如果您使用键访问各项，则它是一个哈希表（Hashtable）。集合中的各项总是按键值排序

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demos
{
    class Program
    {
        static void Main(string[] args)
        {
            SortedList sl = new SortedList();

            sl.Add("1", "hello");
            sl.Add("2", "world");
            sl.Add("3", "I");
            sl.Add("4", "Love");
            sl.Add("5", "China");

            if (sl.ContainsValue("China"))
            {
                Console.WriteLine("I know you love China！But China already has a collection");
            }
            else
            {
                sl.Add("5", "China");
            }
            foreach (var item in sl.Keys)
            {
                Console.WriteLine(item + ":" + sl[item]);
            }
            int myIndex = 1;
            Console.WriteLine("The key at index {0} is {1}.", myIndex, sl.GetKey(myIndex));//获得下标为1的键的名称
            Console.WriteLine("The value at index {0} is {1}.", myIndex, sl.GetByIndex(myIndex));//获得键为1的值
            // 获取键的集合
            ICollection key = sl.Keys;
            foreach (string k in key)
            {
                Console.WriteLine(k + ": " + sl[k]);
            }

            Console.ReadKey();
        }
    }
}

4.堆栈Stack

　　堆栈（Stack）代表了一个后进先出的对象集合。当您需要对各项进行后进先出的访问时，则使用堆栈。当您在列表中添加一项，称为推入元素，当您从列表中移除一项时，称为弹出元素

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demos
{
    class Program
    {
        static void Main(string[] args)
        {
            Stack st = new Stack();

            st.Push(‘A‘);
            st.Push(‘B‘);
            st.Push(‘C‘);
            st.Push(‘D‘);

            Console.WriteLine("Current stack: ");//当前队列,先存后出
            foreach (char value in st)
            {
                Console.Write(value + " ");
            }
            Console.WriteLine();
            st.Push(‘V‘);//向 Stack 的顶部添加一个对象。
            st.Push(‘H‘);
            Console.WriteLine("The next poppable value in stack: {0}",st.Peek());//返回在 Stack 的顶部的对象，但不移除它。
            Console.WriteLine("Current stack: ");
            foreach (char value in st)
            {
                Console.Write(value + " ");
            }
            Console.WriteLine();
            Console.WriteLine("Removing values ");
            st.Pop();//移除并返回在 Stack 的顶部的对象
            st.Pop();
            st.Pop();

            Console.WriteLine("Current stack: ");
            foreach (char value in st)
            {
                Console.Write(value + " ");
            }
            Console.ReadKey();
        }
    }
}

5.队列Queue

　　队列（Queue）代表了一个先进先出的对象集合。当您需要对各项进行先进先出的访问时，则使用队列。当您在列表中添加一项，称为入队，当您从列表中移除一项时，称为出队。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demos
{
    class Program
    {
        static void Main(string[] args)
        {
            Queue q = new Queue();

            q.Enqueue(‘A‘);
            q.Enqueue(‘B‘);
            q.Enqueue(‘C‘);
            q.Enqueue(‘D‘);

            Console.WriteLine("Current queue: ");//队列先进先出
            foreach (char value in q)
                Console.Write(value + " ");
            Console.WriteLine();
            q.Enqueue(‘V‘);//向 Queue 的末尾添加一个对象。
            q.Enqueue(‘H‘);
            Console.WriteLine("Current queue: ");
            foreach (char value in q)
                Console.Write(value + " ");
            Console.WriteLine();
            Console.WriteLine("Removing some values ");
            char ch = (char)q.Dequeue();//移除并返回在 Queue 的开头的对象。
            Console.WriteLine("The removed value: {0}", ch);
            ch = (char)q.Dequeue();
            Console.WriteLine("The removed value: {0}", ch);
            Console.ReadKey();

        }
    }
}

5.点阵列（BitArray） 

　　BitArray 类管理一个紧凑型的位值数组，它使用布尔值来表示，其中 true 表示位是开启的（1），false 表示位是关闭的（0）。当您需要存储位，但是事先不知道位数时，则使用点阵列。您可以使用整型索引从点阵列集合中访问各项，索引从零开始。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Demos
{
    class Program
    {
        static void Main(string[] args)
        {
            // 创建两个大小为 8 的点阵列
            BitArray ba1 = new BitArray(8);
            BitArray ba2 = new BitArray(8);
            byte[] a = { 60 };
            byte[] b = { 13 };
            // 把值 60 和 13 存储到点阵列中
            ba1 = new BitArray(a);
            ba2 = new BitArray(b);
            // ba1 的内容
            Console.WriteLine("Bit array ba1: 60");
            for (int i = 0; i < ba1.Count; i++)
            {
                Console.Write("{0, -6} ", ba1[i]);
            }
            Console.WriteLine();

            // ba2 的内容
            Console.WriteLine("Bit array ba2: 13");
            for (int i = 0; i < ba2.Count; i++)
            {
                Console.Write("{0, -6} ", ba2[i]);
            }
            Console.WriteLine();

            BitArray ba3 = new BitArray(8);
            ba3 = ba1.And(ba2);

            // ba3 的内容
            Console.WriteLine("Bit array ba3 after AND operation: 12");
            for (int i = 0; i < ba3.Count; i++)
            {
                Console.Write("{0, -6} ", ba3[i]);
            }
            Console.WriteLine();

            ba3 = ba1.Or(ba2);
            // ba3 的内容
            Console.WriteLine("Bit array ba3 after OR operation: 61");
            for (int i = 0; i < ba3.Count; i++)
            {
                Console.Write("{0, -6} ", ba3[i]);
            }
            Console.WriteLine();

            Console.ReadKey();
        }
    }
}
时间： 2024-10-13 12:58:35

C#中的6种常见的集合的相关文章

[2]工欲善其事必先利其器-------UML中的几种常见关系(二)

目录 1.UML类图中几种常见的关系 经过(一)中介绍,我选择的是StarUML作为UML的学习工具,个人喜好,至少在功能上能够满足我现在的需求, 在介绍StarUML的使用之前首先介绍下UML中几种常见的关系: UML类图中常见的关系按照关系的强弱可分为:泛化 ,实现 ,组合, 聚合 , 依赖这几种 1.泛化关系:是一种继承关系,也就是XX is a kind of XX 描述. 2.实现关系:是一种类与接口的关系. 3. 组合关系:是一种强关联,属于一种整体与部分的关系,但是部分不能离开整体

wpf企业级开发中的几种常见业务场景

前阵子在公司弄个内部的进销存管理系统,从了解需求.系统设计到编码,大约耗费了两个月时间,后来公司有了其他的安排,这东西就算黄了.顺便吐槽一下,厂里的一些人说话真心不顾别人感受,邮件啥的没一句舒服的.不过以前在别的地方干活都是很多人弄,一直都是按领导的意思办即可,基本上不怎么跟人打交道,不能保持淡定的心态说明还是too young了点,这也算是个历练吧. 弄这个项目,好歹也辛苦了一阵子,另外细节方面感觉自己差不多做到位了,也算尽心了.这里先附几张效果图,接下来将针对几种常见的业务场景抠出一些代码,

架构设计中的6种常见安全误区

[架构源码地址] 自然世界中,先天有缺陷的生物总是容易被细菌病毒入侵,而健壮的生物更能抵抗细菌病毒的攻击,计算机系统也是一样,若有先天的架构设计安全缺陷,那么在面临网络攻击的时候,就更容易被入侵或者破坏,甚至因为设计架构的原因,有些漏洞完全没有办法修复!本文将讲述架构设计中需要避免出现的安全误区,以帮助我们研发人员设计出更安全健壮的软件架构.本文的举例既有硬件架构,也有软件架构,还有基础架构等等不同的架构,但其中原理适用于所有的架构设计.下文将从兼容性设计误区,降低成本设计误区,数据和代码不分离

XML--Java中的四种常见解析方式--dom

Java中常用的解析方式主要有四种: Java 自带:Dom.Sax. 外加包:Jdom.Dom4j. 1.Dom 主要的构建方式 DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance(); DocumentBuilder db=dbf.newDocumentBuilder(); Document dm=db.parse("rec\\books.xml"); 其中节点类为Node  节点集合类为NodeList at

JAVA中十四种常见开发工具及其特点

1.JDK (Java Development Kit)Java开发工具集 SUN的Java不仅提了一个丰富的语言和运行环境,而且还提了一个免费的Java开发工具集(JDK).开发人员和最终用户可以利用这个工具来开发java程序. JDK简单易学,可以通过任何文本编辑器(如:Windows 记事本.UltrEdit.Editplus.FrontPage以及dreamweaver等)编写Java源文件,然后在DOS状况下利通过javac命令将Java源程序编译成字节码,通过Java命令来执行编译后

Kubernetes中，两种常见类型的Volume深度实践

一.背景 存储资源在所有计算资源中扮演着十分重要的角色,大部分业务场景下都有可能使用到各类存储资源.在Kubernetes中,系统通过Volume对集群中的容器动态或静态提供存储资源.通常情况下,我们可以认为容器或者Pod的生命周期时短暂的,当容器被销毁时,容器内部的数据也同时被清除.为了持久化保存容器的数据,Kubernetes引入了Volume,类似于Docker的Volume(Docker also has a concept of volumes, though it is somewh

XML--Java中的四种常见解析方式--jdom与dom4j

jdom与dom4j作为特地为java的实现,比较灵活适合熟悉Java的人 jdom主要构建方法 SAXBuilder sax=new SAXBuilder(); 方法一:  InputStream in=new FileInputStream("rec\\books.xml");             Document document=sax.build(in);方法二:  Document document=sax.build("rec\\books.xml"

C语言中的几种常见排序算法

1.冒泡排序法:如果有N个数,两两相邻进行比较,将最值沉入最后一位置,要进行N-1轮比较, 第一轮要比较N-1次,第2轮只要比较N-1-1次,因为第一次已经把最值沉入最后一位置,故 不需在进行比较一次,也就是说每一轮都减少一次,所以第2个for循环中j < n-1;下列代码是升序排序 1 void bubble_sort(int *num, int n) 2 { 3 int num_temp; 4 for (int i=0; i<n; i++) 5 for (int j=0; j<n-i

Android 四种常见的线程池

引入线程池的好处 1)提升性能.创建和消耗对象费时费CPU资源 2)防止内存过度消耗.控制活动线程的数量,防止并发线程过多. 我们来看一下线程池的简单的构造 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecution