初识c#---泛型集合,哈希表,堆栈,队列,索引器



ArrayList是线性数据结构----对应的泛型线性结构list

泛型集合List<T>

            为什么使用泛型?

            1.泛型集合比非泛型集合对于数据这一块来说,是安全的.没有脏数据

            2.在一定数据量的前提下,泛型比非泛型写入数据和读取数据要快的多

            3.泛型集合处理数据快的原因是少了装箱和拆箱的操作

            ArrayList al = new ArrayList();

            al.Add(1);

            al.Add(2);

            al.Add("3");

            foreach (var item in al)

            {

              Console.WriteLine(item); 

            }

            //初始化List集合,限定内部数据仅为int

            List<int> list = new List<int>();

            list.Add(1);

            list.Add(2);

            //list.Add("3");  错误,数据类型不匹配

            int[] arrs = { 1, 2, 3, 4 };

            //char[] chars = { '1', '2', '3', '4' };

            list.AddRange(arrs);

            Console.WriteLine(list.Count);

            //list.RemoveAt()

            //list.Remove()

            //list.Sort()

            //list.Sum();

            //list.Insert

            //list.InsertRange

            //list.IndexOf

            //哈希表(字典)key--value

            //Hashtable

            Dictionary<TKEY,TVALUE>

            //key唯一,key不能对应多个value,但是value可以对应多个key

            Student s1 = new Student("刘德华1", 9527, 95.8f);

            Student s2 = new Student("刘德华2", 9527, 95.8f);

            Student s3 = new Student("刘德华3", 9527, 95.8f);

            Hashtable ht = new Hashtable();

            //添加key-value

            ht.Add(1, s1);

            ht.Add(2, s2);

            ht.Add(3, s3);

            ht.Add(4, s3);

            //遍历所有的键(1)

            foreach (var item in ht.Keys)

            {

                Console.WriteLine(item);

            }

            //遍历所有的值(2)

            foreach (var item in ht.Values)

            {

                Console.WriteLine(item);

            }

            //遍历3全部key-value

            DictionaryEntry

            //字典实体-->内部的内容

            foreach (DictionaryEntry item in ht)

            {

                int key = (int)item.Key;

                Student values = (Student)item.Value;

                Console.WriteLine("key值为{0}:{1}",key,values.stu_name);

            }

            //遍历4

            IDictionaryEnumerator ide = ht.GetEnumerator();

            while (ide.MoveNext())

            {

               //ide.Entry

               DictionaryEntry de =(DictionaryEntry)ide.Current;

               Student s = de.Value as Student;

               int key = (int)de.Key;

               Console.WriteLine(s.stu_name + s.stu_id);

            }

            //指定一个key移除key-value

            ht.Remove(3);

            //判断哈希表中是否存在某个key,存在返回true

            if (ht.ContainsKey(3))

            {

                Console.WriteLine("存在key值为5的key-value对");

            }

            //清除全部的key-value

            ht.Clear();

            Student s1 = new Student("刘德华1", 9527, 95.8f);

            Student s2 = new Student("刘德华1", 9526, 99.8f);

            Student s3 = new Student("刘德华3", 9529, 92.8f);

            List<Student> list = new List<Student>();

            list.Add(s1);

            list.Add(s2);

            list.Add(s3);

            list.Remove(s1);

            foreach (Student s in list)

            {

                Console.WriteLine(s.stu_name);

            }

            //对于sort来说返回-1位置不会发生变化

            //返回1,交换顺序

            list.Sort();

            list.Reverse();

            int i = s1.CompareTo(s2);

            int i2 = s2.CompareTo(s3);

            Console.WriteLine(i);

            Console.WriteLine(i2);

            string stu1 = "1";   //49

            string stu2 = "2";   //50

            Console.WriteLine(stu1.CompareTo(stu2));

            //1  前面的比后面的大

            //-1 前面的比后面的小

            //0

            int i1 = s1.CompareTo(s2);

            int i2 = s2.CompareTo(s3);

            Console.WriteLine(i1);

            Console.WriteLine(i2);

            foreach (Student stu in list)

            {

                Console.WriteLine(stu.stu_score + ":" + stu.stu_id);

            }

            ArrayList al = new ArrayList();

            Text t1 = new Text("1");

            Text t2 = new Text("1");

            al.Add(t1);

            al.Add(t2);

            al.Remove(t1);

            foreach (Text tt in al)

            {

                Console.WriteLine(tt.name);

            }

            //Stack--堆栈

            Stack<T>

            int a = 10;

            int b = 20;

            int c = 30;

            Stack sk = new Stack();

            sk.Push("A");

            sk.Push("B");

            sk.Push("C");//栈顶数据

            //栈的长度

            Console.WriteLine(sk.Count);     

            string str = (string)sk.Pop();  //取得栈顶数据,并把栈顶数据删除

            Console.WriteLine(sk.Count);

            //返回不移除

            Console.WriteLine(sk.Peek());//取得栈顶数据,不删除

            //判断栈内是否存在某个元素

            if (sk.Contains("C"))

            {

                Console.WriteLine("存在");

            }

            //清空栈

            sk.Clear();

//当空栈的时候,不要进行Pop和Peek的操作,会出现异常

            sk.GetEnumerator()

            foreach (var item in sk)

            {

                Console.WriteLine(item);

            }

            //队列Queue

            Queue que = new Queue();

            //进队

            que.Enqueue("a");

            que.Enqueue("b");

            que.Enqueue("c");

            //出队,移除并返回队头元素

            Console.WriteLine(que.Dequeue());

            //返回队头元素不移除

            Console.WriteLine(que.Peek());

            //判断队列是否包含某个元素

            Console.WriteLine(que.Contains("a"));

            object[] objs = que.ToArray();

            //如何将object数组转换到ArrayList

            ArrayList al = new ArrayList(objs);

            Console.WriteLine(al.Count);

            Console.WriteLine(al[0]);

            //整型数组

            int[] arr = { 1, 2, 3 };

            arr[0] = 22;

            arr[1] = 33;

            //索引器

            ClassIndex ci = new ClassIndex();

            ci[0] = 100;

            ci[1] = 200;

            ci[2] = 222;

            ci[3] = 300;

            ci[4] = 4;

            ci[9] = 9;

            for (int i = 0; i < ci.Length; i++)

            {

                Console.WriteLine(ci[i]);

            }

            Console.WriteLine(ci[10]);

            //foreach (int i in ci)

           // {

            //   Console.WriteLine();

           // }

/**

*  索引器

*  作用:让对象具有快速访问元素的能力

* 

*  索引器和数组的区别:

*  1.索引器的索引类型(index)不限定为整数

*  2.索引器支持方法重载

*  3.索引器实际上跟属性是一样的,也属于特殊的方法

*    同样具备set和get访问器

* 

*  索引器和属性的区别:

*  1.索引器是以关键字this来标识的,属性数任意字符,

*    首字母大写

*  2.索引器可以重载,属性不能

*  3.索引器是可以有参数的,但是属性没有

*  4.索引器不能用static修饰,但是属性可以

*/

namespace _14ClassCode

{

    class ClassIndex

    {

        //数组

        private int[] intArray = new int[10];

        public int Length

        {

            get

            {

                return this.intArray.Length;

            }

        }

        //定义索引器

        public int this [int index]

        {

            set

            {

                if(index >= 0 && index < this.intArray.Length)

                {

                    intArray[index] = value;

                }

            }

            get

            {

                if(index < 0 || index >= this.intArray.Length)

                {

                    Console.WriteLine("数组越界!~");

                    return 0;

                }

                return intArray[index];

            }

        }

    }

}

队列和栈的应用:判断一个字符串是否是回文字符串

string str =Console.ReadLine();

Stark<char> s=new Stark<char>();

Queue<char> que=new Queue<char>();

for(int i;i<str.Length;i++){

s.Push(str[i]);

que.Enqueue(str[i]);

}

bool isHui=true;

while(s.Count>0)

{

if(s.Pop()!=que.Dequeue()){

isHui=false;

break;

}

}

Console.WriteLine("是否是回文字符串"+isHui);