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);