四种简单数据结构类

下场～呜呜呜

开始补课咯

简单数据结构类：

  • ArrayList
  • Stack
  • Queue
  • Hashtable

ArrayList：

知识点一：ArrayList的本质

  • ArrayList是一个C#为我们封装📦好的类 -------- 本质是一个object类型的数组
  • ArrayList类帮助我们实现了很多方法 ------- 比如数组的增删改查

知识点二：申明

//需要引用命名空间using System.Collections;
ArrayList array = new ArrayList();

知识点三 ：增删改查

  • 增
 ArrayList array = new ArrayList();
						
				// 因为本是object类型 所以可以增加任何类型
            array.Add(1);
            array.Add("123");
            array.Add("true");
            array.Add(new object());
						array.Add("true");

            ArrayList array2 = new ArrayList();
            array2.Add(123);
            
					//范围增加（批量增加） 把另一个list容器里面的内容加到后面
           array.AddRange(array2);
						
					//插入 可以自选位置
				   array.Insert(1, "abc");
  • 删
//移除指定元素 从头找到删除
            array.Remove(1);

            //移除指定位置的元素 (里面是下标)
            array.RemoveAt(2);

            //清空
            array.Clear();
  • 改
            array[0] = "999";
  • 查
            //得到指定位置的元素
            Console.WriteLine(array[0]);

            //查看元素是否存在
            if (array.Contains("123")) { };

            //正向查找元素位置  找到的返回值是位置   找不到返回值是-1
            int index = array.IndexOf(true);  //里面具体的数组内容，不是下标‼️

            //反向查找元素位置  找到的返回值是位置   找不到返回值是-1
            int index2 = array.LastIndexOf(true);
  • 遍历
//长度
            Console.WriteLine(array.Count);
            //容量----避免产生过多垃圾
            Console.WriteLine(array.Capacity);

            //遍历1：for循环
            for(int i = 0;i<array.Count;i++)
            {
                Console.WriteLine(array[i]);
            }

            //遍历2:迭代器
            foreach (object item in array)
            {
                Console.WriteLine(item);
            }

知识点四：装箱拆箱

  • ArrayList本质上是一个可以自动扩容的object数组-------由object存储数据，自然存在装箱拆箱

  • 当往其中存储值类型就是在装箱，当将值类型对象取出来转换使用时就是拆箱

  • 所以ArrayList尽量少用，之后我们会学习更好的数据容器

    //简单的例子
int i = 1;
//装箱
array[0] = i;
//拆箱
i = (int)array[0];

Stack：

知识点一：Stack的本质

  • Stack（栈）是一个C#为我们封装📦好的类
  • 他的本质也是object[ ]数组，只是封装了特殊的存储规则
  • Stack是一种先进后出的数据结构

知识点二：申明

  • 需要引用命名空间 System.Collections

    Stack stack = new Stack();

知识点三：增取查改

  • 增

    //压栈    只能一个一个的赠哦
            stack.Push(1);
            stack.Push("123");
            stack.Push(true);
            stack.Push(new Test());

  • 取

    //栈中不存在删除的概念  只有取的概念  弹栈
object v =stack.Pop();
Console.WriteLine(v);---弹出Test对象

v = stack.Pop();
Console.WriteLine(v);---弹出 true

  • 查

    //栈无法查看指定位置的元素
//1.只能查看栈顶的内容
v = stack.Peek();
Console.WriteLine(v);

v = stack.Peek();
Console.WriteLine(v);---两次Peek对Stack无变化
  
//2.查看元素是否存在于栈中
  if(stack.Contains("123"))
  {
    	Console.WriteLine("存在123 ");
  }

  • 改

    //栈无法改变其中的元素 只能压（存）弹（取）
//实在要改 只能清空
stack.Clear( );

知识点四：遍历

  //长度
Console.WriteLine(stack.Count);

 //由于Stack不提供索引器通过[ ]访问，所以不能用for循环下标遍历
 //用foreach遍历  顺序---从栈顶到栈底
foreach(object item in stack )
{
   Console.WriteLine(item);
}
//还有一种遍历方式
//将栈转换为object数组  顺序也是---从栈顶到栈底
object[] array = stack.ToArray();
for(int i=0; i<array.Length; i++)
{
  Console.WriteLine(array[i]);
}

//循环弹栈   ---边取边用 用完即空
while(stack.Count > 0)
{
  object o = stack.Pop();
  Console.WriteLine(o);
}

知识点五：装箱拆箱

  • 由于用万物之父来存储数据，自然存在装箱拆箱

  • 当往其中进行值类型存储时就是在装箱

  • 当将值类型对象取出来转换使用时，就存在拆箱

Queue：

知识点一：Quene本质

  • Quene是一个C#为我们封装📦好的类
  • Quene的本质也是object[ ]数组，知识封装了特殊的存储规则
  • Quene是队列存储结构，是一种先进先出的存储结构

知识点二：申明

  • 需要引用命名空间System.Collections

    Quene quene = new Quene();

知识点三：增取查改

  • 增
//增--进入队列
quene.Enqueue(1);
quene.Enqueue("123");
quene.Enqueue(1.4f);
quene.Enqueue(new Test());
  • 取
//队列中不存在删除的概念
//只有取的概念 取出先加入的对象
object v = quene.Dequene(); 
Console.WriteLine(v);
  • 查
//1.查看队列头部元素但不会取出
v = queue.Peek();
Console.WriteLine(v);
//2.查看元素是否存在于队列当中
if(queue.Contains("1.4f"))
{
  Console.WriteLine("存在1.4f");
}
  • 改
//队列无法改变其中的元素 只能进出队列
//实在要改 只有清
queue.Clear();

知识点四：遍历

//长度
Console.WriteLine(queue.Count);

 //由于Queue不提供索引器通过[ ]访问，所以不能用for循环下标遍历
 //用foreach遍历  顺序---先进先出
foreach(object item in queue )
{
   Console.WriteLine(item);
}
//还有一种遍历方式
//将栈转换为object数组  顺序也是---先进先出
object[] array = queue.ToArray();
for(int i=0; i<array.Length; i++)
{
  Console.WriteLine(array[i]);
}

//循环出列   ---边取边用 用完即空
while(queue.Count > 0)
{
  object o = queue.Dequeue():
  Console.WriteLine(o);
}

知识点五：装箱拆箱

  • 由于用万物之父来存储数据，自然存在装箱拆箱
  • 当往其中进行值类型存储时就是在装箱
  • 当将值类型对象取出来转换使用时，就存在拆箱

Hashtable：

知识点一：Hashtable的本质

  • Hashtable（又称散列表）是基于键的哈希代码组织起来 键 / 值对
  • （key，value）键和值都是object类型
  • 它的主要作用是提高数据查询的效率
  • 使用键来访问集合中的元素

知识点二：申明

  • 需要引用命名空间System.Collections
Hashtable hashtable = new Hashtable();

知识点三：增删查改

  • 增 注意⚠️不能出现相同键
hashtable.Add(1."123");
hashtable.Add("123",2);
hashtable.Add(true,true);
  • 删
 //只能通过键去删
hashtable.Remove(1);
 //删除不存在的键 没反应
hashtable.Remove(2);
 //或者直接清空
hashtable.Clear();
  • 查
//1.通过键查看值    找不到会返回空
Console.WriteLine(hashtable[1]);-----键Key
 
 //2.查看是否存在
//根据键检测
  if(hashtable.Contains("2"))
{
  Console.WriteLine("存在 键为2 的键值对");
}
 if(hashtable.ContainsKey("2"))
{
  Console.WriteLine("存在 键为2 的键值对");
}
//根据值检测
 if(hashtable.ContainsValue(12))
{
  Console.WriteLine("存在 值为12 的键值对");
}
  • 改
//只能改 键对应的值的内容 无法修改键
hashtable[1] = 100.5f;

知识点四：遍历

//得到键值对 对数
Console.WriteLine(hashtable.Count);

//1.遍历所有键
foreach(object item in hashtable.Keys )
{
   Console.WriteLine("键；"+item);
   Console.WriteLine("值："+hashtable[item]);
}
//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();
}

知识点五：装箱拆箱

  • 由于用万物之父来存储数据，自然存在装箱拆箱
  • 当往其中进行值类型存储时就是在装箱
  • 当将值类型对象取出来转换使用时，就存在拆箱

posted on 2022-05-25 00:23  AcherLoveCode  阅读(43)  评论(0)  编辑  收藏  举报

导航