C#进阶

Arraylist

ArryList array = new ArrayList();

Stack

本质是object[]数组,后进先出

Stack stack = new Stack();
//压栈
stack.push(1);
//取
object v = stack.Pop();
//查，只能查看栈顶的内容
v = stack.peek;
//查看是否存在于栈中
stack.contains("123");
//清空
stack.Clear();
//遍历
stack.Count;
foreach(object item in stack)
{
    Console.WriteLine(item);
}
//将栈转换为object数组，遍历出来的顺序也是从栈顶到栈底
object[] array = stack.ToArray();
//循环弹栈
while(stack.Count > 0)
{
    object o = stack.Pop();
    Console.WriteLine(stack.Count);
}

Queue

//队列本质也是object[]数组，先进先出
Queue q = new Queue();
//增
Queue.Enqueue(1);
//取
object v = queue.Dequeue();
//查看队列头部元素但不会移除
v = queue.Peek();
//清空
queue.Clear();
//遍历
foreach(object item in queue)
{
    Console.WriteLine(item);
}
//循环出列
while(queue.Count>0)
{
    object o = queue.Dequeue();
}

Hashtable

//基于键的哈希代码组织起来的键/值对，主要作用是提高数据查询的效率
Hashtable hashtable = new Hashtable();
//增
hashtable.Add(1,"123");
hashtable.Add("123",2);
//注意：不能出现相同的键
//删，只能通过键去删除
hashtable.Remove(1);
//直接清空
hashtable.Clear();
//查,通过键查看值
Console.WriteLine(hashtable[1]);
//查看是否存在
//根据键检测
if(hashtable.ContainsKey(2))
{
    return true;
}
//根据值检测
if(hashtable.ContainsValue(1))
{
    return true;
}
//改，只能改键对应的值，无法修改键
hashtable[1]=100.2f;
//遍历
//遍历所有键
foreach(object item in hashtable.Keys)
{
    Console.WriteLine("键："+item);
    Console.WriteLine("值："+hashtable[item]);
}
//遍历所有值
foreach(object item in hashtable.Values)
{
    
    Console.WriteLine("值："+item);
}
//键值对一起遍历
foreach(DictionaryEntry in hashtable)
{
    
    Console.WriteLine("键："+item.key+"值："+item.velue);
}

泛型

//泛型类
class TestClass<T>
{
    public T value;
}
//泛型接口
interface TestInterface<T>
{
    T value{get;set;}
}
class Test:TestInterface<int>
{
    public int value{get=>throw new Exception();set=>throw new Exception();}
}
class Program
{
    static void Main(string[] args)
    {
        TestClass<int> t = new TestClass<int>();
        t.value = 1;
        TestClass<string> t2 = new TestClass<string>();
        t2.value = "123";
    }
}
//普通类中的泛型方法
class Test2
{
    public T TestFun<T>(T value)
    {
        return value;
    }
    public void TestFun<T>()
    {
        //用泛型类型，在里面做一些逻辑处理
        T t = default(T);
    }
}
//泛型类中的泛型方法
class Test2<t>
{
    public T value;
    public void TestFun<K>(K k)
    {
        console.WriteLine(k);
    }
}

泛型约束

//值类型
class Test1<T> where T:struct
{

}
//引用类型
class Test1<T> where T:class
{

}
//存在公共无参构造函数
class Test1<T> where T:new()
{

}

List

本质是一个可变类型的泛型数组

//声明
List<int> list = new List<int>();
List<string> list2 = new List<string>();
//增
list.Add(1);
list2.Add("123");
//删
list.Remove(1);
//查
Console.WriteLine(list[0]);
//改
list[0] = 99;

Dictionary

拥有泛型的Hashtable

Dictioary<int,string> dic = new Dictionary<int,string>();
//增,不能出现相同键
dic.Add(1,"123");
dic.Add(2,"111");
//删，只能通过键去删除
dic.Remove(1);
//清空
dic.Clear();
//查，通过键查看值，找不到直接报错
Console.WriteLine(dic[1]);
//改
dic[1] = "222";

顺序存储和链式存储

顺序存储：用一组地址连续的存储单元依次存储线性表的各个数据元素
链式存储：用一组任意的存储单元存储线性表中的各个数据元素