20一个自定义集合的自述

最新推荐文章于 2021-02-16 20:18:14 发布
最新推荐文章于 2021-02-16 20:18:14 发布
阅读量94 收藏
点赞数
原文链接：http://www.cnblogs.com/darrenji/p/3635333.html
版权


大家好，我是集合，可能大家对我已经很熟悉了，IEnumerable<T>, IList<T>,List<T>,IQueryable<T>......我就这样被大家使用着，今天，我想与大家走进一步，让您了解更真实的我。

 

我们就专门为Book类来打造一个集合类吧：

    public class Book
    {
        public string Id { get; set; }
        public string Name { get; set; }
 
        public override string ToString()
        {
            return String.Format("ID:{0},Name:{1}", Id, Name);
        }
    }

 

  为什么我可以被遍历？

很多朋友问我：为什么我们可以遍历你？其实，我之所以能被遍历，是因为我实现了IEnumerable<T>接口：

public interface IEnumerable<out T> : IEnumerable
{
    IEnumerator<T> GetEnumerator();
}

而IEnumerable<T>接口实现了IEnumerable接口：

public interface IEnumerable
{
    IEnumerator GetEnuemrator();
}

 

既然我实现了2个接口，那这2个接口的方法IEnumerator<T> GetEnumerator()和IEnumerator GetEnuemrator()，我都需要实现，稍后会为大家呈现。我大致上是这样的：

public class BookCollection : IEnumerable<Book>
{    
}

 

  我是怎样被初始化的？

在我的内部，我会把所有的元素放到一个容器里，我就把这个容器叫做哈希表，是以键值对存放的，键是字符串，值是object类型：

//key是字符串，value是object类型
private Hashtable table;

 

每次你们创建我的时候，我都会初始化这个哈希表：

        public BookCollection()
        {
            table = new Hashtable();
        }

 

有些朋友喜欢在初始化我的时候，就把元素添加进来，比如这样：

        public static BookCollection GetInitialCollection()
        {
            return new BookCollection()
           {
               new Book(){Id="1",Name = "阳光灿烂的日子"},
               new Book(){Id = "2", Name = "痛并快乐着"}
           };
        }

 

是的，你确实可以这么做，因为我为大家准备了：

        public BookCollection(params Book[] array)
        {
            table = new Hashtable();
            foreach (Book item in array)
            {
                this.Add(item);
            }
        }
 
        //添加把Book的Id作为哈希表的key
        public void Add(Book book)
        {
            foreach (string key in table.Keys)
            {
                if(key == book.Id)
                    throw new Exception("不能重复");
            }
            table.Add(book.Id, book);
        }

 

  为什么可以通过元素位置找到对应元素？    

有时候，大家希望通过报上某个位置来获取集合中的元素，对于这点，我提供了索引：

        public Book this[int index]
        {
            get 
            {
                string key = getKey(index);
                return table[key] as Book;
            }
            set
            {
                string key = getKey(index);
                table[key] = value;
            }
        }
 
        //根据整型获得哈希表中的字符串索引
        private string getKey(int index)
        {
            //边界考虑
            if (index < 0 || index > table.Keys.Count)
            {
                throw new Exception("索引超出了范围");
            }
            string selected = "";
            int i = 0;
            foreach (string key in table.Keys)
            {
                if (i == index)
                {
                    selected = key;
                    break;
                }
                i++;
            }
            return selected;
        }
 
        //根据字符串类型获得哈希表中的字符串索引
        private string getKey(string key)
        {
            foreach (string k in table.Keys)
            {
                if (key == k)
                {
                    return key;
                }
            }
            throw new Exception("不存在此键");
        }
 
        public Book this[string key]
        {
            get
            {
                string selected = getKey(key);
                return table[selected] as Book;
            }
            set
            {
                string selected = getKey(key);
                table.Remove(table[selected]);
                this.Add(value);
            }
        }

 

  我所倚重的迭代器   

大家已经知道，之所以能遍历我，是因为我实现了IEnumerable<T>接口，而IEnumerable<T>接口的作用就是通过方法返回一个迭代器。

 

迭代器实现了IEnumerator<T>接口：

public interface IEnumerator<out T> : IDisposable, IEnuemrator
{
    T Current{get;}
}

 

而IEnumerator<T>接口又实现了IEnuemrator接口和IDisposabe接口：

public intterface IEnuemrator
{
    object Current {get;}
    bool MoveNext();
    void Reset();
}
 
public interfac IDisposabe
{
    void Dispose();
}

 

所以，我自身的迭代器需要同时实现IEnumerator<T>和IEnuemrator这2个接口的方法。

什么是迭代器呢？简单地说，迭代器维护了一个集合和指针，通过指针位置的移动来遍历集合的元素。

       //迭代器维护着集合和指针
        public class BookEnumerator : IEnumerator<Book>
        {
            private BookCollection collection;
            private int index;
 
            //迭代器的初始化
            public BookEnumerator(BookCollection bc)
            {
                this.collection = bc;
                index = -1;
            }
 
            
            public BookCollection Collection
            {
                get { return collection; }
                set { collection = value; }
            }
 
            //IEnumerator<Book>的实现
            public Book Current { get { return collection[index]; } }
 
            //IEnumerator的实现
            object IEnumerator.Current
            {
                get { return collection[index]; }
            }
 
            //向下一个位置
            public bool MoveNext()
            {
                index++;
                if (index >= collection.Count)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
 
            //重设
            public void Reset()
            {
                index = -1;
            }
 
            //实现IDisposabe
            public void Dispose()
            {
 
            }
        }
 

 

  完整的我

好了，完整的我大致是这样：

展开   public class Book
    {
        public string Id { get; set; }
        public string Name { get; set; }

        public override string ToString()
        {
            return String.Format("ID:{0},Name:{1}", Id, Name);
        }
    }

    public class BookHelper
    {
        public static BookCollection GetInitialCollection()
        {
            return new BookCollection()
           {
               new Book(){Id="1",Name = "阳光灿烂的日子"},
               new Book(){Id = "2", Name = "痛并快乐着"}
           };
        }
    }

    public class BookCollection : IEnumerable<Book>
    {
        //key是字符串，value是object类型
        private Hashtable table;

        public BookCollection()
        {
            table = new Hashtable();
        }

        public BookCollection(params Book[] array)
        {
            table = new Hashtable();
            foreach (Book item in array)
            {
                this.Add(item);
            }
        }

        public ICollection Keys {get { return table.Keys; }}

        public Book this[int index]
        {
            get 
            {
                string key = getKey(index);
                return table[key] as Book;
            }
            set
            {
                string key = getKey(index);
                table[key] = value;
            }
        }

        //根据整型获得哈希表中的字符串索引
        private string getKey(int index)
        {
            //边界考虑
            if (index < 0 || index > table.Keys.Count)
            {
                throw new Exception("索引超出了范围");
            }
            string selected = "";
            int i = 0;
            foreach (string key in table.Keys)
            {
                if (i == index)
                {
                    selected = key;
                    break;
                }
                i++;
            }
            return selected;
        }

        //根据字符串类型获得哈希表中的字符串索引
        private string getKey(string key)
        {
            foreach (string k in table.Keys)
            {
                if (key == k)
                {
                    return key;
                }
            }
            throw new Exception("不存在此键");
        }

        public Book this[string key]
        {
            get
            {
                string selected = getKey(key);
                return table[selected] as Book;
            }
            set
            {
                string selected = getKey(key);
                table.Remove(table[selected]);
                this.Add(value);
            }
        }

        //添加把Book的Id作为哈希表的key
        public void Add(Book book)
        {
            foreach (string key in table.Keys)
            {
                if(key == book.Id)
                    throw new Exception("不能重复");
            }
            table.Add(book.Id, book);
        }

        public void Insert(int index, Book book)
        {}

        public bool Remove(Book book)
        {
            return true;
        }

        public bool RemoveAt(int index)
        {
            return true;
        }

        public void Clear()
        {
            table.Clear();
        }

        public int Count
        {
            get { return table.Keys.Count; }
        }


        public IEnumerator<Book> GetEnumerator()
        {
            return new BookEnumerator(this);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return new BookEnumerator(this);
        }

        //迭代器维护着集合和指针
        public class BookEnumerator : IEnumerator<Book>
        {
            private BookCollection collection;
            private int index;

            //迭代器的初始化
            public BookEnumerator(BookCollection bc)
            {
                this.collection = bc;
                index = -1;
            }

            
            public BookCollection Collection
            {
                get { return collection; }
                set { collection = value; }
            }

            //IEnumerator<Book>的实现
            public Book Current { get { return collection[index]; } }

            //IEnumerator的实现
            object IEnumerator.Current
            {
                get { return collection[index]; }
            }

            //向下一个位置
            public bool MoveNext()
            {
                index++;
                if (index >= collection.Count)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }

            //重设
            public void Reset()
            {
                index = -1;
            }

            //实现IDisposabe
            public void Dispose()
            {

            }
        }
            
    }

 

  集合的使用  

现在，你们可以使用我了。
通过foreach遍历：

        static void Main(string[] args)
        {
            BookCollection list = BookHelper.GetInitialCollection();
            list.Add(new Book(){Id = "3",Name = "晓说"});
            foreach (Book book in list)
            {
                Console.WriteLine(book.ToString());
            } 
            Console.ReadKey();
        }

 

或通过获取迭代器，移动迭代器指针的位置：

        static void Main(string[] args)
        {
            BookCollection list = BookHelper.GetInitialCollection();
            list.Add(new Book(){Id = "3",Name = "晓说"});
            IEnumerator<Book> e = list.GetEnumerator();
            while (e.MoveNext())
            {
                Console.WriteLine(e.Current.ToString());
            }
            Console.ReadKey();
        }

 

得到的结果都是一样的：
2

 

  总结

 

最后，我想感谢哈希表，正是因为有了它，我才能把这么多的元素存放起来。也要感谢IEnumerable<T>和IEnumerator<T>，正是因为实现了这哥俩的接口方法，大家才可以遍历我的集合元素。

转载于:https://www.cnblogs.com/darrenji/p/3635333.html

weixin_30415801
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spicetify-themes：一个由社区驱动的Spicetify主题集合（https：github.comkhanhasspicetify-cli）
02-03
丰富社区主题 这是的主题集合， 是用于自定义Spotify的命令行工具。 您只需打开“拉取请求”即可添加您自己的主题（“贡献”部分中的更多信息）。...使用您的主题名称创建另一个文件夹。 主题名称应
Unity学习之C#_如何自己定义一个List集合
OJMars的博客
04-18 6534
如何使用C#自己创建一个和List集合功能大致相同的自定义集合 首先在介绍如何自己创建一个集合之前，先介绍几个概念：数据结构、数据（data）、数据元素（Data Element）、数据项（Data Item）、数据对象（Data Object）、数据类型（Data Type） 1、数据结构：数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。 这里的定义来自...
自定义集合
Ryker的博客
12-19 383
1.如何让普通的类具备foreach功能   2.本类是缓存类,提供添加,删除,清除,移除等方法来管理对象(你想存的东西)      缓存:   1.用户的一些设置      为什么要自定义集合? using System; using System.Collections; namespace 补充自定义集合 { class CacheManager:IEnu
自定义集合实体类
张青山
06-28 3264
概述         对于实体层，在学习三层架构的时候，我们大家都接触过，并且在之后的项目中也运用过，我们也知道，在层和层之间传递的是实体或者是实体集合，那么，在这里问一下大家，你们是如何构建自己的实体集的呢？是通过数组，是通过系统提供的集合，或者是自己针对于每个实体都创建一个自己的集合(每个集合和都是一个套代码)，还是其它的方法。        本片博客，本人会通过实例向大家阐释两种方式，这
foodcritic-rules:CustomInk的食品评论规则集合
05-08
在存储库的根目录中创建一个foodcritic文件夹，并使用cd进入该目录： git clone [email protected]:customink-webops/foodcritic-rules.git foodcritic/customink 现在，您可以运行包括CustomInk食品评论规则，如下所...
clever-components：Clever Cloud的Web组件集合
02-06
自述文件 聪明云收集Web组件 这是什么？ 该项目包含由Clever Cloud制造的Web组件的集合。 其中一些组件是较低级别的，例如<cc> ， 或<cc> ，其他组件则更高级并且特定于Clever Cloud的域模型。 我们在不同的Web ...
svg-banners:在SVG中使用htmlcss制作的自述文件样式横幅！
03-19
:shooting_star: SVG标语-使用HTML / CSS为您的自述文件制作的易于自定义的动画SVG集合 :light_bulb:灵感 ： :construction:贡献： :right_arrow:添加更多SVG或为现有的SVG创建变体，请阅读 :hammer_and_wrench:...
ml_tidbits:我反复使用的可重复使用的ML代码片段的集合
04-12
这只是一个编译大量有用的ML代码片段的项目。 该项目并非旨在“运行”，并且各个部分不一定并存。 它们是可重用的代码段，我发现自己需要一遍又一遍。 我并不是说这些片段代表了我独特的见识和能力。 它们是我阅读...
HashMap底层实现原理
weixin_34324081的博客
12-21 731
HashMap概述HashMap实现了Map接口，我们常用HashMap进行put和get操作读存键值对数据。下面介绍基于jdk1.8深入了解HashMap底层原理。HashMap数据结构HashMap实际是一种“数组+链表”数据结构。在put操作中，通过内部定义算法寻止找到数组下标，将数据直接放入此数组元素中，若通过算法得到的该数组元素已经有了元素（俗称hash冲突，链表结构出现的实际意义也就是...
HashMap底层原理（详细介绍）
热门推荐
Yao_shen_yun的博客
07-03 7万+
数组：其实所谓的数组指的就是一组相关类型的变量集合，并且这些变量彼此之间没有任何的关联。存储区间连续，占用内存严重，数组有下标，查询数据快，但是增删比较慢； 链表：一种常见的基础数据结构，是一种线性表，但是不会按照线性的顺序存储数据，而是每一个节点里存到下一个节点的指针。存储区间离散，占用内存比较宽松，使用链表查询比较慢，但是增删比较快； 哈希表：Hash table 既满足了数据的快速查询（...
20.三个集合的小练习
resilienter的博客
01-10 142
三个集合的小练习 wordCount简单 /** * 对一个List进行wordCount,返回出现次数最多的三个单词，及其出现次数 */ object WordCountSimple { def main(args: Array[String]): Unit = { // WordCount val list = List("Hello&#34...
自定义集合（Set）
小华gogo
12-28 978
通过学习自定义集合，了解集合的数据结构。   本篇分别以链表的方式和以二分搜索树的方式实现了集合。   首先写一个集合的接口，描述其具有的基本功能。Set.java 然后写一个接口的实现类: 其中，方式一： 用的是链表的方式。 LinkedListSet.java     用到了     自定义链表   中的   LinkedList.java 方式二：用的是二分搜索树的方式。  ...
list排序sort降序_集合(一)——从这里开始List、Set
weixin_39967120的博客
12-04 5150
CollectionCollection集合体系Collection是一个集合接口，它提供了对集合对象进行基本操作的通用接口方法，所有集合都是它的子类，比如 List、Set 等。Collections是一个包装类，包含了很多静态方法，不能被实例化，就像一个工具类，比如提供的排序方法：Collections. sort(list)。Collections.sort排序内部原理Col...
自定义一个ArrayList类
chenkaibsw的专栏
04-26 3937
1.自定义ArrayList类功能1）添加元素：public void add(Item obj);2）根据索引删除某个元素：public Item remove(int index)3）删除ArrayList中的某个元素：public boolean remove(Item item)4）根据索引获取某个元素：public Item get(int index)5）实现迭代器，可以遍历列表6）获...
java定义一个集合_自定义Java集合
weixin_28977123的博客
02-16 1030
packagecom.collection.linkedList;public class MyLinkedList{private Node header;//链表的节点头private Node tail;//链表的结尾private int size;//记录当前元素的大小publicMyLinkedList() {}/*** 在某个位置插入元素*@paramindex*@paramobj*...
集合去重的常用技巧——自定义类去重
qq_42758551的博客
07-05 706
自定义类集合去重，重写hashCode 和 equals 方法。Set 中的元素保证唯一性，因此可以借助 Set 集合的这个特性对其他集合中的元素进行去重操作：
请帮我写一份教学能力自述
最新发布
09-11
好的，以下是一份教学能力自述的范文： 我是一名有多年教学经验的教师，我有着深厚的学科知识和较高的教学技能，能够帮助学生更好地掌握知识。 在我看来，优秀的教学需要多方面的能力，包括教学设计、教学方法、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值