1.ArrayList
1.ArrayList的本质
ArrayList是一个C#为我们封装好的类
它的本质是一个object类型的数组
ArrayList类帮助我们实现了很多方法
比如数组的增删查改
2.申明
需要引用命名空间 using System.Collections;
ArrayList array = new ArrayList();
3.增删查改
1.增
array.Add(1);
array.Add("123");
array.Add(true);
array.Add(new object());
array.Add(new Test());
array.Add(1);
array.Add(true);
ArrayList array2 = new ArrayList();
array2.Add(123);
//范围增加 （批量增加 把另一个list容器里面的内容加到后面）
array.AddRange(array2);
//插入元素 （位置，插入内容）
array.Insert(1, "123456");
Console.WriteLine(array[1]);//123456
2.删
//移除指定元素 从头找 找到就删
array.Remove(1);
//移除指定位置的元素
array.RemoveAt(2);
//清空
//array.Clear();
3.查
//得到指定位置的元素
Console.WriteLine(array[0]);
//查看元素是否存在
if (array.Contains("123"))
{
Console.WriteLine("存在123");
}
//正向查找元素位置
//找到的返回值 是位置 找不到 返回值就是-1
int index = array.IndexOf(true);
Console.WriteLine(index);//1
index = array.IndexOf(false);
Console.WriteLine(index);//-1
//反向查找元素位置
//返回是从头开始的索引数
index = array.LastIndexOf(true);
Console.WriteLine(index);//4
4.改
Console.WriteLine(array[0]);
array[0] = "999";
Console.WriteLine(array[0]);
5.遍历
//长度
Console.WriteLine(array.Count);//7
//容量
//避免产生过多的垃圾
Console.WriteLine(array.Capacity);//16
Console.WriteLine("*******************");
for (int i = 0; i < array.Count; i++)
{
Console.Write(array[i]);
}
Console.WriteLine("");
//迭代器遍历
foreach (object item in array)
{
Console.Write(item);
}
4.装箱拆箱
ArrayList本质上是一个可以自动扩容的object数组
由于用万物之父来存储数据，自然存在装箱拆箱
当往其中进行值类型存储时就是在装箱，当将值类型对象取出来转换使用时，就是在拆箱
所以ArrayList尽量少用，之后我们会学习更好的数据容器
int k = 1;
array[0] = k;//装箱
k = (int)array[0];//拆箱
2.Stack
1.Stack的本质
Stack(栈)是一个C#为我们封装好的类
它的本质也是object[]数组，只是封装了特殊的存储规则
Stack是栈存储容器，栈是一种先进后出的数据结构
先存入的数据后获取，后存入的数据先获取
栈是先进后出
2.申明
需要引用命名空间 using System.Collections;
Stack stack = new Stack();
3.增取查改
1.增
//压栈
stack.Push(1);
stack.Push("123");
stack.Push(true);
stack.Push(1.2f);
stack.Push(new Test());
2.取
//栈中不存在删除的概念
//只有取的概念
//弹栈
object v = stack.Pop();
Console.WriteLine(v);
v = stack.Pop();
Console.WriteLine(v);//1.2f
3.查
//1.栈无法查看指定位置的 元素
// 只能查看栈顶的内容
v = stack.Peek();//只查看，不取出
Console.WriteLine(v);
Console.WriteLine(v);
//2.查看元素是否存在于栈中
if (stack.Contains(1.2f))
{
Console.WriteLine("存在1.2f");
}
//无输出
if (stack.Contains("123"))
{
Console.WriteLine("存在123");
}
//存在123
4.改
//栈无法改变其中的元素 只能压（存）和弹（取）
//实在要改 只有清空
stack.Clear();
Console.WriteLine(stack.Count);//0
stack.Push("1");
stack.Push(2);
stack.Push("哈哈哈");
5.遍历
//1.长度
Console.WriteLine(stack.Count);//3
//2.用foreach遍历
// 而且遍历出来的顺序 也是从栈顶到栈底
foreach (object item in stack)
{
Console.WriteLine(item);
}
//3.还有一种遍历方式
// 将栈转换为object数组
// 遍历出来的顺序 也是从栈顶到栈底
object[] array = stack.ToArray();
for (int i = 0; i < array.Length; i++)
{
Console.WriteLine(array[i]);
}
//4.循环弹栈
while (stack.Count > 0)
{
/*object o = stack.Pop();
Console.WriteLine(o);*/
Console.WriteLine(stack.Pop());
}
Console.WriteLine(stack.Count);
4.装箱拆箱
由于用万物之父来存储数据，自然存在装箱拆箱
当往其中进行值类型存储时就是在装箱
当将值类型对象取出来转换使用时，就存在拆箱
3.Queue
1.Queue本质
Queue是一个C#为我们封装好的类
它的本质也是object[]数组，只是封装了特殊的存储规则
Queue是队列存储容器
队列是一种先进先出的数据结构
先存入的数据先获取，后存入的数据后获取
2.申明
需要引用命名空间 using System.Collections;
Queue queue = new Queue();
3.增取查改
1.增
queue.Enqueue(1);
queue.Enqueue("123");
queue.Enqueue(1.4f);
queue.Enqueue(new Test());
2.取
//队列中不存在删除概念
//只有取的概念 取出先加入的对象
object v = queue.Dequeue();
Console.WriteLine(v);//1
v = queue.Dequeue();
Console.WriteLine(v);//123
3.查
//1.查看队列头部元素但不会移除
v = queue.Peek();
Console.WriteLine(v);//1.4
v = queue.Peek();
Console.WriteLine(v);//1.4
//2.查看元素是否存在于队列中
if (queue.Contains(1.4f))
{
Console.WriteLine("队列中存在1.4f");
}
4.改
//队列无法改变其中的元素 只能进出队列
//实在要改 只有清空
Console.WriteLine(queue.Count);//2
queue.Clear();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
5.遍历
//1.长度
Console.WriteLine(queue.Count);//3
//2.用foreach遍历
foreach (object item in queue)
{
Console.WriteLine(item);
}
//3.还有一种遍历方式
// 将队列转换为object数组
object[] array = queue.ToArray();
for (int i = 0; i < queue.Count; i++)
{
Console.WriteLine(array[i]);
}
//4.循环出列
while (queue.Count > 0)
{
Console.WriteLine(queue.Dequeue());
}
4.装箱拆箱
由于用万物之父来存储数据，自然存在装箱拆箱
当往其中进行值类型存储时就是在装箱
当将值类型对象取出来转换使用时，就存在拆箱
4.Hashtable
1.Hashtable的本质
Hashtable（又称散列表）是基于键的哈希代码组织起来的 键/值对
它的主要作用是提高数据查询的效率
使用键来访问集合中的元素
2.申明
需要引用命名空间 using System.Collections;
Hashtable hashtable = new Hashtable();
3.增删查改
1.增
hashtable.Add(1, "123");
hashtable.Add("123", 1);
hashtable.Add(true, false);
hashtable.Add(false, false);
//注意：不能出现相同键
2.删
//1.只能通过键去删除
hashtable.Remove(1);
//2.删除不存在的键 没反应
hashtable.Remove(2);
//3.或者直接清空
hashtable.Clear();
hashtable.Add(1, "123");
hashtable.Add(2, "1234");
hashtable.Add(3, "123");
hashtable.Add("123123", 12);
3.查
//1.通过键查看值
// 找不到会返回空
Console.WriteLine(hashtable[1]);//123
Console.WriteLine(hashtable[4]);//返回空
Console.WriteLine(hashtable["123123"]);//12
//2.查看是否存在
// 根据键检测
if (hashtable.Contains(2))
{
Console.WriteLine("存在键为2的键值对");
}
if (hashtable.ContainsKey(2))
{
Console.WriteLine("存在键为2的键值对");
}
// 根据值去检测
if (hashtable.ContainsValue(12))
{
Console.WriteLine("存在值为12的键值对");
}
4.改
//只能改 键对应的值内容 无法修改键
Console.WriteLine(hashtable[1]);
hashtable[1] = 100.5f;
Console.WriteLine(hashtable[1]);
5.遍历
//得到键值对 对数
Console.WriteLine(hashtable.Count);
//1.遍历所有键
foreach (object item in hashtable.Keys)
{
Console.WriteLine("键:"+item);
Console.WriteLine("值:" + hashtable[item]);
}
Console.WriteLine();
//2.遍历所有值
foreach (object item in hashtable.Values)
{
Console.WriteLine("值:"+item);
}
//3.键值对一起遍历
foreach (DictionaryEntry item in hashtable)
{
Console.WriteLine("键：" + item.Key + " 值：" + item.Value);
}
//4.迭代器遍历法
IDictionaryEnumerator myEnumerator = hashtable.GetEnumerator();
bool flag = myEnumerator.MoveNext();
while (flag)
{
Console.WriteLine("键：" + myEnumerator.Key + " 值：" + myEnumerator.Value);
flag = myEnumerator.MoveNext();
}
4.装箱拆箱
由于用万物之父来存储数据，自然存在装箱拆箱
当往其中进行值类型存储时就是在装箱
当将值类型对象取出来转换使用时，就存在拆箱
![Unity游戏开发背景知识[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)