GXPT(二)——初识集合

集合是什么??集合就是容器,主要用于存储和管理对象。

 

*******基本集合:

 

Collecion:是构造类集框架的基础。它声明所有类集都将拥有的核心方法。所有的类集实现Collection。

 

List:有序的Collection,使用此接口能精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素。List允许有相同的元素。

 

Set:一种不包含重复的元素的Collection。

 

 Map:没有继承Collection接口,在数组中我们是通过数组下标来对其内容索引的,而在Map中我们通过对象来对对象进行索引,用来索引的对象叫做key,其对应的对象叫做value。这就是我们平时说的键值对Map提供keyvalue的映射。一个Map中不能包含相同的key,每个key只能映射一个value

 GXPT(二)——初识集合_第1张图片

 

 

*******自定义实体集合:

方式一:复用性差的实体集合类

实体类:

		using System;  
		using System.Collections.Generic;  
		using System.Linq;  
		using System.Text;  
		using 集合.集合.灵活性差的ORMapping;  
		  
		namespace TableToCollection.实体  
		{  
		    public class Person  
		    {  
		        public string strID { get; set; }  
		        public string strName { get; set; }  
		        public int intAge { get; set; }  
		    }  
		  
		}  


实体集合类:

		using System;  
		using System.Collections.Generic;  
		using System.Linq;  
		using System.Text;  
		using System.Collections;  
		using TableToCollection.实体;  
		  
		namespace TableToCollection.集合.灵活性差的集合  
		{  
		    public class PersonCollection_bad:IEnumerable  
		    {  
		  
		        private ArrayList list;  
		  
		        public int Count   
		        {  
		            get { return list.Count; }  
		        }  
		 
		        #region 构造函数  
		        public PersonCollection_bad()  
		        {  
		            list = new ArrayList();  
		        }  
		 
		        #endregion  
		         
		        #region 添加  
		        public void Add(Person p)  
		        {  
		            this.list.Add(p);  
		        }  
		        public void AddAr(Person[] ps)   
		        {  
		            this.list.AddRange(ps);  
		        }  
		        #endregion  
		 
		        #region 删除  
		        public void Remove(Person p)   
		        {  
		            this.list.Remove(p);  
		        }  
		        public void RemoveAt(int index)   
		        {  
		            this.list.RemoveAt(index);  
		        }  
		        public void RemoveRange(int index, int count)   
		        {  
		            this.list.RemoveRange(index, count);  
		        }  
		        public void Clear() {  
		            this.list.Clear();  
		        }  
		        #endregion  
		 
		        #region 自定义索引器  
		        public Object this[int index]  
		        {  
		            get  
		            {  
		                return list[index];  
		            }  
		            set  
		            {  
		                list[index] = value;  
		            }  
		        }       
		        #endregion  
		 
		        #region 支持foreach语句遍历  
		        public IEnumerator GetEnumerator()   
		        {  
		            return list.GetEnumerator();  
		        }  
		        #endregion  
		    }  
		}  
 

方式二:复用性好的实体集合类

基础实体集合类:

		using System;  
		using System.Collections.Generic;  
		using System.Linq;  
		using System.Text;  
		  
		namespace 集合.集合.灵活性好的集合  
		{  
		    public class BaseCollection<T>:IEnumerable<T>,IEnumerator<T>,IList<T>  
		    {  
		        private List<T> list;  
		        //定义索引  
		        private int position;  
		  
		        public int Count   
		        {  
		            get {  
		                if (list != null)  
		                {  
		                    return list.Count;  
		                }  
		                return -1;  
		            }  
		        }  
		          
		        /// <summary>  
		        /// 确定集合中特定对象的索引  
		        /// </summary>  
		        /// <param name="TObject">特定的对象</param>  
		        /// <returns>如果在列表中找到,则为item 的索引;否则为 -1</returns>  
		        public int IndexOf(T TObject)   
		        {  
		            return this.list.IndexOf(TObject);  
		        }  
		 
		        #region 构造方法  
		        public BaseCollection(){  
		            this.list = new List<T>();  
		            this.position = -1;  
		        }  
		        #endregion  
		         
		        #region 添加  
		        /// <summary>  
		        /// 将对象添加到集合的尾部  
		        /// </summary>  
		        /// <param name="TObject">要添加到集合尾部的对象</param>  
		        public void Add(T TObject)  
		        {  
		            this.list.Add(TObject);  
		        }  
		        /// <summary>  
		        /// 将指定集合里的元素添加到集合尾部  
		        /// </summary>  
		        /// <param name="TCollection">要添加到集合尾部的集合对象</param>  
		        public void AddRange(ICollection<T> TCollection)  
		        {  
		            this.list.AddRange(TCollection);  
		        }  
		        #endregion  
		 
		        #region 删除  
		        /// <summary>  
		        /// 从集合中移除特定对象的第一个匹配项  
		        /// </summary>  
		        /// <param name="TObject">TObject</param>  
		        /// <returns>true:移除成功;false:移除失败</returns>  
		        public bool Remove(T TObject) {  
		            return this.list.Remove(TObject);  
		        }  
		        /// <summary>  
		        /// 从集合中移除指定索引处的对象  
		        /// </summary>  
		        /// <param name="index">索引值,从0开始</param>  
		        public void RemoveAt(int index)  
		        {  
		            this.list.RemoveAt(index);  
		        }  
		        /// <summary>  
		        /// 集合删除所有对象  
		        /// </summary>  
		        public void Clear() {  
		            this.list.Clear();  
		        }  
		        #endregion  
		 
		        #region 插入  
		        /// <summary>  
		        /// 在集合的特定位置插入对象  
		        /// </summary>  
		        /// <param name="index">索引,从0开始</param>  
		        /// <param name="TObject">被插入的对象</param>  
		        public void Insert(int index, T TObject)  
		        {  
		            this.list.Insert(index, TObject);  
		        }  
		        #endregion  
		 
		        #region 取值  
		        /// <summary>  
		        /// 获取或设置指定索引处的元素  
		        /// </summary>  
		        /// <param name="index">索引值从0开始</param>  
		        /// <returns>TObject</returns>  
		        public T this[int index]   
		        {  
		            get  
		            {  
		                return this.list[index];  
		            }  
		            set   
		            {  
		                this.list[index] = value;   
		            }  
		        }  
		        #endregion  
		 
		        #region 实现ICollection<T>,因为IList<T>继承ICollection<T>  
		        //获取一个值,该值指示 System.Collections.Generic.ICollection<T> 是否为只读。  
		        public bool IsReadOnly  
		        {  
		            get  
		            {  
		                return true;  
		            }  
		        }        
		        //确定 System.Collections.Generic.ICollection<T> 是否包含特定值。  
		        public bool Contains(T item)  
		        {  
		            return this.list.Contains(item);  
		        }          
		        //从特定的 System.Array 索引处开始,将 System.Collections.Generic.ICollection<T> 的元素复制到一个  
		        public void CopyTo(T[] array, int arrayIndex)   
		        {   
		            this.list.CopyTo(array, arrayIndex);   
		        }  
		        #endregion          
		 
		        #region 支持foreach语句遍历  
		        #region 实现IEnumerable<T>接口  
		        System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator()   
		        {  
		            return (System.Collections.Generic.IEnumerator<T>)this;  
		        }  
		 
		        #region 实现IEnumerable接口,因为IEnumerable<T>继承IEnumerable  
		        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()   
		        {  
		            return (System.Collections.IEnumerator)this;  
		        }  
		        #endregion  
		        #endregion  
		 
		        #region 实现IEnumerator<T>接口  
		        //获取集合中的当前元素。  
		        T System.Collections.Generic.IEnumerator<T>.Current  
		        {  
		            get {  
		                try  
		                {  
		                    return this.list[position];  
		                }  
		                catch (IndexOutOfRangeException)  
		                {  
		                    throw new InvalidOperationException();  
		                }  
		            }  
		        }  
		 
		        #region 实现IEnumerator接口,因为IEnumerator<T>继承IEnumerator  
		        //获取集合中的当前元素。  
		        object System.Collections.IEnumerator.Current  
		        {  
		            get  
		            {  
		                try  
		                {  
		                    return this.list[position];  
		                }  
		                catch (IndexOutOfRangeException)  
		                {  
		                    throw new InvalidOperationException();  
		                }  
		            }  
		        }  
		        //将枚举数推进到集合的下一个元素。  
		        bool System.Collections.IEnumerator.MoveNext()  
		        {  
		            this.position++;              
		            return (this.position < this.list.Count);  
		        }  
		        //将枚举数设置为其初始位置,该位置位于集合中第一个元素之前。  
		        void System.Collections.IEnumerator.Reset()  
		        {  
		            this.position = -1;  
		        }        
		        #endregion  
		 
		        #region 实现IDisposable接口,因为IEnumerator<T>继承IDisposable  
		        public void Dispose()  
		        {  
		            this.position = -1;  
		        }  
		        #endregion  
		        #endregion  
		        #endregion  
		    }  

}

 

具体实体集合类:

		using System;  
		using System.Collections.Generic;  
		using System.Linq;  
		using System.Text;  
		using TableToCollection.实体;  
		  
		namespace 集合.集合.灵活性好的集合  
		{  
		    public class PersonBaseCollection:BaseCollection<Person>  
		    {          
		    }  
		}  

 

*******比较:

 

为什么说方式二的灵活性好,复用性高呢?原因是它采用了泛型,解决了方式一种服务类型固定的问题。方式二将95%重复的代码抽象出来,将需要扩展的,或者是属于某个实体集合类本身的代码,写到自己的实体集合类中。

 

*******总结:

问题一:

从上面我们知道了实体的样子,也知道了实体集合的样子和作用,那么有一个问题就来了:是否可以用实体集合类代替实体呢?难道只是为了解耦合(实体:属性 ,便于参数传递; 实体集合:提供操作,管理实体对象),才有实体和实体集合这两种东西出现吗?

 

问题二:

老师说过,集合其实就是容器,可是我怎么没有体会出来呢??


你可能感兴趣的:(GXPT(二)——初识集合)