C# 数组与集合

C# 数组与集合

Array

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

namespace _16._1_Array
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int[] ints1 = { 1, 2, 3, 4, 5,6,7,8 };

            //将数组中指定位置的数据恢复为对应类型的默认值
            //参数1:需要恢复的数组 参数2:开始的位置的索引 参数3恢复的个数
            Array.Clear(ints1,1,3);
            MyWriteArr(ints1);

            int[] ints2 = new int[10];
            //将参数1数组中的数据复制到参数2数组汇总,由参数3指定复制的个数
            //注意:复制的个数不能超过源数组的长度, 2.复制的个数不能超过新数组的长度
            Array.Copy(ints1, ints2, 6);
            MyWriteArr(ints2);
            //反转数组
            Array.Reverse(ints1);
            MyWriteArr(ints1);

            //查找对应的数据在数组中第一次出现的位置,有则返回当前数据的索引值,如果没有则返回-1
            Console.WriteLine(Array.IndexOf(ints1,8));


            int[] ages = { 15, 12, 31, 18, 14, 19 };

            //根据传入的数据和方法,返回第一个满足条件的数据,如果数组中没有满足条件的数据,则返回该类型的默认值
            //工作原理:循环该数组,并且每次循环调用传递的方法,将当前的数据通过参数传递到方法中,如果方法返回了true,则Find直接返回这个参数
            Console.WriteLine(Array.Find(ages,FinSamll18));
            Console.WriteLine(Array.Find(ages,v=>v<18));
            //FindIndex() 返回满足查询条件的这个值的索引的位置
            Console.WriteLine(Array.FindIndex(ages, v => v < 18));
            //从后往前查询第一个满足条件的数据
            Console.WriteLine(Array.FindLast(ages, v => v < 18));
            Console.WriteLine(Array.FindLastIndex(ages, v => v < 18));
            //查询所有满足条件的数据 返回值是一个数组
            int [] arr = Array.FindAll(ages, v => v < 18);
            MyWriteArr(arr);
            //判断数组中的数据是否都满足条件
            //所有的数据都满足条件 则返回true 有一个不满足就返回false
            Console.WriteLine(Array.TrueForAll(ages, v => v < 18));
            //判断数据中至少有一个满足条件
            //有一个满足条件就返回true 所有不满足就返回false
            Console.WriteLine(Array.Exists(ages, v => v < 18));


            string[] str1 = { "老李", "老王", "老五" };
            string[] str2 = new string[5];
            //将str1复制到str2中 从str2的位置开始放
            str1.CopyTo(str2,1);
            //获取指定维度的数据的数量,返回值是32位的整数
            Console.WriteLine(str1.GetLength(0));

            //等同于  str1[0] ="老王";
            str1.SetValue("老王",0);
            Console.WriteLine(str1.GetValue(0));
            //判断书中是否存在某个数据
            Console.WriteLine(str1.Contains("老王"));

        }
        public static void MyWriteArr(int[] arr)
        {
            string s = "[";
            for (int i = 0; i < arr.Length; i++)
            {
                s += arr[i] + ",";
            }
            s += "]";
            Console.WriteLine(s);
        }
        public static bool FinSamll18(int value)
        {
            //if (value<18)
            //{
            //    return true;
            //}
            //else
            //{
            //    return false;
            //}
            return value < 18;
           
        }
    }
    
}

C#集合（Collection）

C# 中的集合类（Collection）是专门用于数据存储和检索的类，类中提供了对栈（stack）、队列（queue）、列表（list）和哈希表（hash table）的支持。大多数集合类都实现了相同的接口。

集合类的用途多种多样，例如可以动态的为元素分配内存、根据索引访问列表项等等，这些类创建 Object 类的对象集合，Object 类是 C# 中所有数据类型的基类。

C# 中的集合类型

在 System.Collections.Generic，System.Collections.Concurrent 和 System.Collections 命名空间下提供了许多集合类型，每种集合类型都有特定的用途，下面以 System.Collection 命名空间为例，该命名空间下提供的集合类型如下表所示：

类	描述和用法
动态数组（ArrayList）	动态数组表示可被单独索引的对象的有序集合。 动态数组基本上与数组相似，唯一不同的是动态数组可以使用索引在指定的位置添加和移除项目，动态数组会自动重新调整自身的大小。 另外，动态数组也允许在列表中进行动态内存分配、增加、搜索、排序等等。
List	类似ArrayList,只是List只能存储相同类型的数据,List的长度也不是固定的
字典(Dictionary)	类似List.只能存储固定类型的数据,长度不固定
哈希表（Hashtable）	哈希表可以使用键来访问集合中的元素。 哈希表中的每一项都由一个键/值对组成，键用于访问集合中的指定项。
排序列表（SortedList)	排序列表是数组和哈希表的组合，可以使用键或索引来访问列表中的各项。 排序列表中包含一个可使用键或索引访问各项的列表，如果您使用索引访问各项，则它是一个动态数组，如果您使用键访问各项，则它就是一个哈希表。 另外，排序列表中的各项总是按键值进行排序的。
堆栈（Stack）	堆栈代表了一个后进先出的对象集合。 当您需要对各项进行后进先出的访问时，则可以使用堆栈。为堆栈中添加一项称为推入项目，从堆栈中移除一项称为弹出项目。
队列（Queue)	队列代表了一个先进先出的对象集合。 当您需要对各项进行先进先出的访问时，则可以使用队列。为队列中添加项目称为入队，为队列中移除项目称为出队。

C# ArrayList：动态数组

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

namespace _16._2_ArrayList
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //ArrayList 动态数组 就是不给固定长度和存储的数据的类型的集合

            //可以存储任意类型的数据,并且长度会随着数组内容的增加减少进行改变

            ArrayList list1 =new ArrayList() { "老王",1,true,new int[] {1} };

            Console.WriteLine(list1.Count);
            Console.WriteLine(list1[0]);

            //向ArrayList的尾部添加数据
            list1.Add("老李");

            int[] ints = { 666, 777, 888 };
            //将另一个集合的内容添加到ArrayList的尾部
            list1.AddRange(ints);
            //清空数组,删除动态数组所有的数据,并将Count重置为0
            list1.Clear();
            list1.Add("老李");
            //在指定的索引位置插入数据
            list1.Insert(1, "老王");
            //在指定的位置插入集合的内容
            list1.InsertRange(2, ints);
            Console.WriteLine(list1.Contains("老李"));
            //从数组中截取对应的数据,返回值是一个新的ArrayList
            //参数1:开始的索引 参数2:截取的个数
            list1.GetRange(1,3);
            Console.WriteLine(list1.IndexOf("老李"));
            list1.Remove("老李");
            list1.RemoveAt(1);
            list1.RemoveRange(1,2);

            for (int i = 0; i < list1.Count; i++)
            {
                Console.WriteLine(list1[i]);
            }
        }
    }
}

C# List：泛型集合

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

namespace _16._3_List
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //List 也是一个集合 类似ArrayList 只是List只能存储相同类型的数据,List的长度也是不固定
            //格式: List<数据类型> 变量名=new List<数据类型>();
            List<int> list = new List<int>();

            Console.WriteLine(list[0]);
            Console.WriteLine(list.Count);

            list.Add(1);
            list.Remove();
            list.RemoveAt();
            list.Reverse();
            //.....



        }
    }
}

C# Dictionary 字典

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

namespace _16._4_Dictionary
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //Dictionary:类似List 只能存储固定类型的数据 长度不固定
            //list使用索引进行数据的操作,字典使用"键"进行数据的操作

            //键:标识 在一个字典中 键是唯一的 并且不能为null

            //  Dictionary<键的数据类型,值的数据类型> 变量名 = new Dictionary<键的数据类型,值的数据类型>();
            Dictionary<string,int> keyValuePairs = new Dictionary<string, int>()
            {
                {"name",32423 },
                {"k",1 },
                {"aa",1232 }
            };

            keyValuePairs.Add("a", 1);
            Console.WriteLine(keyValuePairs.Count);

            Console.WriteLine(keyValuePairs["k"]);
            keyValuePairs["k"] = 132;
            Console.WriteLine(keyValuePairs.ContainsKey("a"));
            Console.WriteLine(keyValuePairs.ContainsValue(1));
        }
    }
}

C# Hashtable：哈希表

在 C# 中，Hashtable（哈希表） 类表示根据键的哈希代码进行组织的键（key）/值（value）对的集合，可以使用键来访问集合中的元素。也就是说当您需要使用键来访问指定元素时，可以选择使用哈希表。

Hashtable 类中的属性

下表中列出了 Hashtable 类中一些常用的属性：

属性	描述
Count	获取哈希表中包含的键值对的个数
IsFixedSize	获取一个值，用来表示哈希表是否具有固定大小
IsReadOnly	获取一个值，用来表示哈希表是否只读
Item	获取或设置与指定键关联的值
Keys	获取一个 ICollection，其中包含哈希表中的键
Values	获取一个 ICollection，其中包含哈希表中的值

Hashtable 类中的方法

下表中列出了 Hashtable 类中一些常用的方法：

方法名	描述
public virtual void Add(object key, object value)	向哈希表中添加一个带有指定的键和值的元素
public virtual void Clear()	从哈希表中移除所有的元素
public virtual bool ContainsKey(object key)	判断哈希表是否包含指定的键
public virtual bool ContainsValue(object value)	判断哈希表是否包含指定的值
public virtual void Remove(object key)	从哈希表中移除带有指定的键的元素

C# SortedList：排序列表

在 C# 中，SortedList 类用来表示键/值对的集合，这些键/值对按照键值进行排序，并且可以通过键或索引访问集合中的各个项。

我们可以将排序列表看作是数组和哈希表的组合，其中包含了可以使用键或索引访问各项的列表。如果您使用索引访问各项，那么它就是一个动态数组（ArrayList），如果您使用键访问各项，那么它就是一个哈希表（Hashtable）。另外，集合中的各项总是按键值进行排序。

SortedList 类的中的属性

下表列出了 SortedList 类中一些常用的属性：

属性	描述
Capacity	获取或设置排序列表中可包含的元素个数
Count	获取排序列表中的元素个数
IsFixedSize	判断排序列表是否具有固定大小
IsReadOnly	判断排序列表是否只读
Item	获取或设置排序列表中指定键所关联的值
Keys	获取一个包含排序列表中所有键的集合
Values	获取一个包含排序列表中所有值的集合

SortedList 类的中的方法

下表列出了 SortedList 类中一些常用的方法：

方法名	描述
public virtual void Add(object key, object value)	向排序列表中添加一个带有指定的键和值的元素
public virtual void Clear()	从排序列表中移除所有的元素
public virtual bool ContainsKey(object key)	判断排序列表中是否包含指定的键
public virtual bool ContainsValue(object value)	判断排序列表中是否包含指定的值
public virtual object GetByIndex(int index)	获取排序列表中指定索引处的值
public virtual object GetKey(int index)	获取排序列表中指定索引处的键
public virtual IList GetKeyList()	获取排序列表中的键
public virtual IList GetValueList()	获取排序列表中的值
public virtual int IndexOfKey(object key)	返回排序列表中指定键的索引，索引从零开始
public virtual int IndexOfValue(object value)	返回排序列表中指定值第一次出现的索引，索引从零开始
public virtual void Remove(object key)	从排序列表中移除带有指定键的元素
public virtual void RemoveAt(int index)	移除排序列表中指定索引处的元素
public virtual void TrimToSize()	将排序列表的容量设置为排序列表中元素的实际个数

C# Stack：堆栈

在 C# 中，堆栈（Stack）类表示一个后进先出的对象集合，当您需要对项目进行后进先出的访问时，则可以使用堆栈。向堆栈中添加元素称为推入元素，从堆栈中移除元素称为弹出元素。

Stack 类中的属性

下表列出了 Stack 类中一些常用的属性：

属性	描述
Count	获取堆栈中包含的元素个数
IsSynchronized	判断是否同步对堆栈的访问（线程安全）
SyncRoot	获取可用于同步对堆栈访问的对象

Stack 类中的方法

下表列出了 Stack 类中一些常用的方法：

方法名	描述
public virtual void Clear()	从堆栈中移除所有的元素
public virtual bool Contains(object obj)	判断某个元素是否在堆栈中
public virtual object Peek()	返回在堆栈顶部的对象，但不移除它
public virtual object Pop()	移除并返回在堆栈顶部的对象
public virtual void Push(object obj)	向堆栈顶部添加一个对象
public virtual object[] ToArray()	复制堆栈到一个新的数组中

C# Queue：队列

在 C# 中，队列（Queue 类）与堆栈类似，它代表了一个先进先出的对象集合，当您需要对项目进行先进先出访问时，则可以使用队列。向队列中添加元素称为入队（enqueue），从堆栈中移除元素称为出队（deque）。

Queue 类中的属性

下表列出了 Queue 类的一些常用的属性：

属性	描述
Count	获取队列中包含的元素个数
IsSynchronized	判断是否同步对队列的访问（线程安全）
SyncRoot	获取可用于同步对队列访问的对象

Queue 类中的方法

下表列出了 Queue 类的一些常用的方法：

方法名	描述
public virtual void Clear()	从队列中移除所有的元素
public virtual bool Contains(object obj)	判断某个元素是否在队列中
public virtual object Dequeue()	移除并返回在队列开头的对象
public virtual void Enqueue(object obj)	向队列的末尾处添加一个对象
public virtual object[] ToArray()	复制队列到一个新的数组中
public virtual void TrimToSize()	将队列的容量设置为队列中元素的实际个数

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

namespace _16._6_Stack和Queue
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //声明一个堆栈

            Stack<string> stack = new Stack<string>();
            //添加一个数据
            stack.Push("a");
            //删除一个数据(只能删除最后的那个数据)
            stack.Pop();
            //获取堆栈中最上层的数据
            Console.WriteLine(stack.Peek());
            Console.WriteLine(stack.ToArray());
            stack.Clear();

            Queue<string> queue = new Queue<string>();

            //入队
            queue.Enqueue("a");
            Console.WriteLine(queue.Dequeue());
        }
    }
}