快捷搜索:
来自 计算机编程 2019-07-28 23:18 的文章
当前位置: 67677新澳门手机版 > 计算机编程 > 正文

扩展方法,高性能篇

不久前写代码,遇到一个难题,微软基于List<T>自带的措施是public bool Remove(T item);,可是不时候大家兴许会用到诸如RemoveAll<IEnumerable<T>>的艺术,坦白的说,便是流传的参数是贰个IEnumerable<T>,实际不是一个T,这种光景是随时大概用到的。当然大家会随随意便的意识List<T>里小编就封装了三个措施public int RemoveAll(Predicate<T> match),不过前边大家的测量检查验质量量上的话,真不敢恭维。被逼无耐,只好想艺术封装一个IEnumerable<T>扩充方法。然而那时毫无忘了写那篇文章的宏旨,封装的目标,正是‘质量’须求求好!

不久前写代码,遇到一个难点,微软基于List<T>自带的不二诀借使public bool Remove(T item);,但是不常候大家大概会用到诸如RemoveAll<IEnumerable<T>>的方式,坦白的说,正是流传的参数是一个IEnumerable<T>,而不是三个T,这种现象是随时或许用到的。当然大家会随意的意识List<T>里作者就封装了一个措施public int RemoveAll(Predicate<T> match),可是前面大家的测量检验品质上的话,真不敢恭维。被逼无耐,只好想艺术封装叁个IEnumerable<T>扩张方法。不过那时不用忘了写那篇小说的宏旨,封装的指标,正是‘品质’必须要好!

上边大家一步一步讲讲自身境遇的经历分享给大家。

下边大家一步一步讲讲小编超出的经验分享给我们。

只要如下的数码:

假如如下的多少:

1.Source IEnumerable Items:A  B  C  D  A  E  F  G  H

1.Source IEnumerable Items:A  B  C  D  A  E  F  G  H

2.Remove IEnumerable Items:A  B  C  D  A  E

2.Remove IEnumerable Items:A  B  C  D  A  E

3.Result IEnumerable Items:F  G  H

3.Result IEnumerable Items:F  G  H

第1行是土生土养的IEnumerable数据

第1行是原来的IEnumerable数据

第2行是要去除(remove)的数额

第2行是要删减(remove)的数据

第3行是最终删除结果的数目

第3行是最后删除结果的数额

从地点数据,我们解析下怎么神速的取得第3行数据吧?记得,绝对要‘高效’,失去高效的法子,作者感到不是本节议论的内容,因为未有其余意义,当然,高效是绝对的,不是说,前日讲的点子是最便捷的,起码异常高效,恩~ 请不要骂作者,确实是费话!

从地点数据,大家深入分析下怎么高效的获得第3行数据吧?记得,必须要‘高效’,失去高效的主意,笔者感到不是本节商酌的开始和结果,因为从没任何意义,当然,高效是相对的,不是说,后天讲的措施是最赶快的,起码很迅猛,恩~ 请不要骂笔者,确实是费话!

 

 

不错,比比较多程序员想必和小编同样,大多数会如此做

没错,非常多程序猿想必和本身同样,大非常多会那样做

图片 1图片 2

图片 3图片 4

 for (int index = 0; index < source.Count; index  )
            {
                var item = source.ElementAt(i);
                if (remove.Contains(item))
                {
                    source.Remove(item);
                }
            }
 for (int index = 0; index < source.Count; index  )
            {
                var item = source.ElementAt(i);
                if (remove.Contains(item))
                {
                    source.Remove(item);
                }
            }

View Code

View Code

好啊,那样做,指标是达到了,不过,接下去的测量检验,令人纠心。

好啊,那样做,指标是达到规定的规范了,不过,接下去的测量试验,令人纠心。

小编们来摸拟下多少

大家来摸拟下多少

新建三个Source IEnumerable 随机发生10万条数据 和Remove IEnumerable 随机发生1万条数据

新建一个Source IEnumerable 随机发生10万条数据 和Remove IEnumerable 随机产生1万条数据

图片 5图片 6

图片 7图片 8

  List<string> source = new List<string>();
            List<string> remove = new List<string>();

            int i = 0;
            Random rad = new Random();

            while (i < 100000)
            {
                source.Add(rad.Next(Int32.MaxValue).ToString());
                i  ;
            }

            i = 0;

            while (i < 10000)
            {
                remove.Add(rad.Next(Int32.MaxValue).ToString());
                i  ;
            }

            DateTime now = DateTime.Now;
            for (int index = 0; index < source.Count; index  )
            {
                var item = source.ElementAt(i);
                if (remove.Contains(item))
                {
                    source.Remove(item);
                }
            }

            Console.WriteLine("Remove Running time:"   (DateTime.Now - now).TotalSeconds);
            Console.ReadKey();
  List<string> source = new List<string>();
            List<string> remove = new List<string>();

            int i = 0;
            Random rad = new Random();

            while (i < 100000)
            {
                source.Add(rad.Next(Int32.MaxValue).ToString());
                i  ;
            }

            i = 0;

            while (i < 10000)
            {
                remove.Add(rad.Next(Int32.MaxValue).ToString());
                i  ;
            }

            DateTime now = DateTime.Now;
            for (int index = 0; index < source.Count; index  )
            {
                var item = source.ElementAt(i);
                if (remove.Contains(item))
                {
                    source.Remove(item);
                }
            }

            Console.WriteLine("Remove Running time:"   (DateTime.Now - now).TotalSeconds);
            Console.ReadKey();

View Code

View Code

上述代码消耗的大运是 Remove Running time:16.6678431s

上述代码消耗的岁月是 Remove Running time:16.6678431s

由此蒙受这种意况,测量检验结果表明,消耗的时候太长,大家历来等不起,而且放在程序里正是四个炸弹。

于是遇到这种地方,测验结果注明,消耗的时候太长,大家历来等不起,何况放在程序里正是叁个炸弹。

本来,大家摸拟的数据也许太过度变得庞大,但不得不承三个从客观事实,这几个主意功能不是太好!

理所必然,大家摸拟的多少恐怕太过分庞大,但不得不承二个从客观事实,这一个方法功能不是太好!

 

 

下面大家探究过 IEnumerable<T>.RemoveAll<IEnumerable<T>>(IEnumerable<T> Items)方法

上面大家谈谈过 IEnumerable<T>.RemoveAll<IEnumerable<T>>(IEnumerable<T> Items)方法

费话非常的少说,直接上来测验下,看看哪些。

费话相当的少说,直接上来测量试验下,看看哪些。

代码如下:很轻松,仅需一行:

代码如下:很轻松,仅需一行:

图片 9图片 10

图片 11图片 12

 List<string> source = new List<string>();
            List<string> remove = new List<string>();

            int i = 0;
            Random rad = new Random();

            while (i < 100000)
            {
                source.Add(rad.Next(Int32.MaxValue).ToString());
                i  ;
            }

            i = 0;

            while (i < 10000)
            {
                remove.Add(rad.Next(Int32.MaxValue).ToString());
                i  ;
            }

            DateTime now = DateTime.Now;
            source.RemoveAll(m => remove.Contains(m));
            Console.WriteLine("RemoveAll Running time:"   (DateTime.Now - now).TotalSeconds);
 List<string> source = new List<string>();
            List<string> remove = new List<string>();

            int i = 0;
            Random rad = new Random();

            while (i < 100000)
            {
                source.Add(rad.Next(Int32.MaxValue).ToString());
                i  ;
            }

            i = 0;

            while (i < 10000)
            {
                remove.Add(rad.Next(Int32.MaxValue).ToString());
                i  ;
            }

            DateTime now = DateTime.Now;
            source.RemoveAll(m => remove.Contains(m));
            Console.WriteLine("RemoveAll Running time:"   (DateTime.Now - now).TotalSeconds);

View Code

View Code

 

 

测量试验结果所耗费时间是 RemoveAll Running time:16.1175443s

测量试验结果所消耗费时间间是 RemoveAll Running time:16.1175443s

和率先种情势相比较,消耗的时光并未太大加强,大致一致,唉,真是令人白圭之玷。

和率先种方法相比较,消耗的小时并未太大抓实,大约同样,唉,真是令人失望。

那个时候,我们来探问linq to object 看看。

本条时候,大家来看看linq to object 看看。

图片 13图片 14

图片 15图片 16

 DateTime now = DateTime.Now;

            /**注册这里ToList()主要是让查询真正的执行,不然,只是生成语句
            var r = (from item in source
                     where !remove.Contains(item)
                     select item).ToList();
            **/
            var r = source.Where(item => !remove.Contains(item)).ToList();

            Console.WriteLine("RemoveAll Running time:"   (DateTime.Now - now).TotalSeconds);
            Console.ReadKey();
 DateTime now = DateTime.Now;

            /**注册这里ToList()主要是让查询真正的执行,不然,只是生成语句
            var r = (from item in source
                     where !remove.Contains(item)
                     select item).ToList();
            **/
            var r = source.Where(item => !remove.Contains(item)).ToList();

            Console.WriteLine("RemoveAll Running time:"   (DateTime.Now - now).TotalSeconds);
            Console.ReadKey();

View Code

View Code

测量试验结果所耗时是 RemoveAll Running time:16.1112403s

测量试验结果所耗时是 RemoveAll Running time:16.1112403s

实际上大家留神的辨析下代码 m => remove.Contains(m) 本来还是一种遍历,外层又一层遍历。再回去过看看Linq To Object 实际上也是变相的双层遍历

实际大家紧凑的深入分析下代码 m => remove.Contains(m) 本来依然一种遍历,外层又一层遍历。再回来过看看Linq To Object 实际上也是变相的双层遍历

从时间开支来讲,二种办法时间消耗大约同一 O(M*N);

从时间开支来讲,三种办法时间消耗大致等同 O(M*N);

到此为至,大家并未找到真正的短平快的点子。‘办法’嘛,总是想靠人想的,不可能说,就好像此算了吧?

到此为至,大家并从未找到真正的快速的不二秘诀。‘办法’嘛,总是想靠人想的,无法说,就这么算了吧?

仔仔想想,List<T> 在遍历上,是非常的慢的,而选取诸如字典Dictionary<T> 查找有个别键(Key)值(Value),品质是十三分急迅的,因为它是依附'索引'(下面会详细的证实)的,理论上讲在时光开销是O(1)。即然那样,大家回过头来再看看大家的例子

仔仔想想,List<T> 在遍历上,是相当慢的,而选择诸如字典Dictionary<T> 查找某些键(Key)值(Value),质量是老大飞快的,因为它是依附'索引'(下边会详细的求证)的,理论上讲在时光费用是O(1)。即然那样,大家回过头来再看看我们的例子

 

 

 

 

1.Source IEnumerable Items:A  B  C  D  A  E  F  G  H

1.Source IEnumerable Items:A  B  C  D  A  E  F  G  H

2.Remove IEnumerable Items:A  B  C  D  A  E

2.Remove IEnumerable Items:A  B  C  D  A  E

3.Result IEnumerable Items:F  G  H

3.Result IEnumerable Items:F  G  H

综上说述,字典Key 是独一的,若是大家把Remove IEnumverable Items 放入字典Dictionary<Remove Items>里,用三个Foreach遍历所用项,在时光上反驳上应该是O(N),然后再对Source IEnumberable Items遍历比较Dictionary<Remove Items>IEnumverable Items ,若是双方是一律的项那么continue for遍历,不然,把遍历到的Source IEnumberable Items 项存入四个数组里,那么那个数组里,就是我们需求的Result IEnumberable items结果项了。这一个艺术有一点点像‘装脑袋’。哈哈~,不要喜欢的过早,由于Remove IEnumverable Items 是同意有双重的项,那么放在字典里,不是有一点点扯了呢?不用怕,看来,我们一贯玩字典得换个点子,把字典的Key归入Remove Item,把Value存入三个计数器值作为标计,以此假使存在多项重复的重新载入参数value=1,不重复出现的项平素赋值1。仔仔想想,方法有效。

鲜明性,字典Key 是当世无双的,倘使大家把Remove IEnumverable Items 放入字典Dictionary<Remove Items>里,用多少个Foreach遍历所用项,在岁月上反驳上应该是O(N),然后再对Source IEnumberable Items遍历相比较Dictionary<Remove Items>IEnumverable Items ,固然两岸是均等的项那么continue for遍历,不然,把遍历到的Source IEnumberable Items 项存入三个数组里,那么那些数组里,就是我们要求的Result IEnumberable items结果项了。这几个格局有一点像‘装脑袋’。哈哈~,不要喜欢的太早,由于Remove IEnumverable Items 是允许有再一次的项,那么放在字典里,不是有一点点扯了吧?不用怕,看来,大家直接玩字典得换个方法,把字典的Key放入Remove Item,把Value存入二个计数器值作为标计,以此若是存在多项重复的重新设置value=1,不重复出现的项一向赋值1。仔仔想想,方法有效。

图片 17

图片 18

地点是一个暗中提示图,A B C D E 作为Key 在那之中Value值匀为1。

下边是一个暗指图,A B C D E 作为Key 在那之中Value值匀为1。

大家看出,A重复了三遍,那么在字典里value 标计匀重新初始化为1,B出现了一遍,标计为1,那样做不是小题大做吗?

小编们看出,A重复了一次,那么在字典里value 标计匀复位为1,B出现了二遍,标计为1,这样做不是少见多怪吗?

要了然字典是通过Key搜索键值的,速度远远超越foreach 遍历List强的多。

要通晓字典是通过Key寻觅键值的,速度远远当先foreach 遍历List强的多。

好了,我们依据上边的思绪写出方法:

好了,大家依据地点的思绪写出艺术:

  public static IEnumerable<T> RemoveAll<T>(this IEnumerable<T> source, IEnumerable<T> items)
        {
            var removingItemsDictionary = new Dictionary<T, int>();
            var _count = source.Count();
            T[] _items = new T[_count];
            int j = 0;
            foreach (var item in items)
            {
                if (!removingItemsDictionary.ContainsKey(item))
                {
                    removingItemsDictionary[item] = 1;
                }
            }
            for (var i = 0; i < _count; i  )
            {
                var current = source.ElementAt(i);
                if (!removingItemsDictionary.ContainsKey(current))
                {
                    _items[j  ] = current;
                }
            }
            return _items;
        }
  public static IEnumerable<T> RemoveAll<T>(this IEnumerable<T> source, IEnumerable<T> items)
        {
            var removingItemsDictionary = new Dictionary<T, int>();
            var _count = source.Count();
            T[] _items = new T[_count];
            int j = 0;
            foreach (var item in items)
            {
                if (!removingItemsDictionary.ContainsKey(item))
                {
                    removingItemsDictionary[item] = 1;
                }
            }
            for (var i = 0; i < _count; i  )
            {
                var current = source.ElementAt(i);
                if (!removingItemsDictionary.ContainsKey(current))
                {
                    _items[j  ] = current;
                }
            }
            return _items;
        }

艺术很简短吗,其实大家爱慕想选拔字典的Key 快速同盟,至于值就没那么首要了。

措施很简单吗,其实大家重要想使用字典的Key 火速合营,至于值就没那么重大了。

字典的目录时间上是O(1),遍历source时间是O(M) 总括时间理论上应有上O(M N)并不是O(M*N)。

字典的目录时间上是O(1),遍历source时间是O(M) 总括时间理论上应有上O(M N)并不是O(M*N)。

上边的代码,大家为了让调用方便,故去扩展IEnumerable<T>,下边我们来测量检验下看看时间有未有增高多少?

上边的代码,大家为了让调用方便,故去扩大IEnumerable<T>,上边大家来测验下看看时间有没有增高多少?

     IEnumerable<string> dd = source.RemoveAll(remove);
     IEnumerable<string> dd = source.RemoveAll(remove);

这一次,哈哈,既然仅仅只用了0.016001...s,下面多少个例子用了16s 相差太大了,足足加强了一千倍之多,果然选用字典形式,质量上来了,那样的代码,放在项目才有所实际意义!

此次,哈哈,既然仅仅只用了0.016001...s,上面多少个例证用了16s 相差太大了,足足巩固了一千倍之多,果然采取字典格局,质量上来了,那样的代码,放在项目才享有实际意义!

骨子里稳重深入分析下面代码仍然不正常的

实则留神深入分析上面代码照旧有标题标

T[] _items = new T[_count]; //那边只是差比比较少的三回性定义了多少个_count大小的数组,那样的数码远远超过真正使用的数组

T[] _items = new T[_count]; //此地只是大约的二遍性定义了叁个_count大小的数组,这样的数目远远胜出真正使用的数组

 

 

经过地点的辨析,发生了许多项NULL的剩余项,假设一旦能够自动扩充大小,那就更好可是了。

透过地方的分析,发生了数不胜数项NULL的盈余项,若是假定能够自动扩大大小,那就更加好可是了。

本条时候,想起了链表格局的事物。

以此时候,想起了链表情势的事物。

为了在进更一步的进步下质量,人所共知,hashcode为标记三个数量的'目的',若是大家能够看清hashcode是不是等于,也许能够巩固一点属性,要是见到字典的源码,很五个人会飞快想起,是如何组织了一个近似Set<T>的'数据组'。

为了在进更一步的加强下质量,妇孺皆知,hashcode为标记二个数量的'指标',假如大家能够看清hashcode是不是等于,可能可以进步级中学一年级点属性,假若见到字典的源码,很几个人会急迅想起,是怎么着组织了叁个看似Set<T>的'数据组'。

试想下,假若大家今后有二个‘特殊字典’,特殊在,大家加多同样的key的时候,重返的是false,而唯有不另行的项才得以成功的充足进来,这样我们所得的‘数组’正是我们想要的。

试想下,假诺我们未来有一个‘特殊字典’,特殊在,我们增添相同的key的时候,再次回到的是false,而唯有不另行的项才方可成功的丰裕跻身,那样大家所得的‘数组’便是我们想要的。

莫不本身说的略微抽像,就如上面那样

也许本人说的多少抽像,就如上面那样

    public static IEnumerable<TSource> Iterator<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            Set<TSource> iteratorVariable = new Set<TSource>(comparer);
            foreach (TSource local in second)
            {
                iteratorVariable.Add(local);
            }
            foreach (TSource iteratorVariable1 in first)
            {
                if (!iteratorVariable.Add(iteratorVariable1))//这儿是过滤性添加,如果添加失败,说明此项已添加 return false
                {
                    continue;
                }
                yield return iteratorVariable1;//yield语句为我们有机会创造枚举数组
            }
        }
    public static IEnumerable<TSource> Iterator<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            Set<TSource> iteratorVariable = new Set<TSource>(comparer);
            foreach (TSource local in second)
            {
                iteratorVariable.Add(local);
            }
            foreach (TSource iteratorVariable1 in first)
            {
                if (!iteratorVariable.Add(iteratorVariable1))//这儿是过滤性添加,如果添加失败,说明此项已添加 return false
                {
                    continue;
                }
                yield return iteratorVariable1;//yield语句为我们有机会创造枚举数组
            }
        }

在那之中yield iteratorVariable1 发生的便是大家想要的‘数组’,这里只所以那么勇敢,归功于Set<TSource>

内部yield iteratorVariable1 产生的就是大家想要的‘数组’,这里只所以那么威猛,归功于Set<TSource>

 

 

自个儿先把富有的代码贴出来,然后一点一点的教学,不至于片面包车型客车眩晕

自身先把具有的代码贴出来,然后一点一点的任课,不至于片面包车型地铁眩晕

 

 

Set<T>构造器:Slots

Set<T>构造器:Slots

  internal class Set<TElement>
    {

        private IEqualityComparer<TElement> comparer;
        private int count;
        private int freeList;
        private Slot<TElement>[] slots;
        private int[] buckets;

        public Set()
            : this(null)
        { }

        public Set(IEqualityComparer<TElement> comparer)
        {
            if (comparer == null)
            {
                comparer = EqualityComparer<TElement>.Default;
            }
            this.comparer = comparer;
            this.slots = new Slot<TElement>[7];
            this.buckets = new int[7];
            this.freeList = -1;
        }


        private bool Find(TElement value, bool add)
        {
            int hashCode = this.InternalGetHashCode(value);
            for (int i = this.buckets[hashCode % this.buckets.Length] - 1; i >= 0; i = this.slots[i].next)
            {
                if ((this.slots[i].hashCode == hashCode) && this.comparer.Equals(this.slots[i].value, value))
                {
                    return true;
                }
            }
            if (add)
            {
                int freeList;
                if (this.freeList >= 0)
                {
                    freeList = this.freeList;
                    this.freeList = this.slots[freeList].next;
                }
                else
                {
                    if (this.count == this.slots.Length)
                    {
                        this.Resize();
                    }
                    freeList = this.count;
                    this.count  ;
                }
                int index = hashCode % this.buckets.Length;
                this.slots[freeList].hashCode = hashCode;
                this.slots[freeList].value = value;
                this.slots[freeList].next = this.buckets[index] - 1;
                this.buckets[index] = freeList   1;
            }
            return false;
        }

        private void Resize()
        {
            int num = (this.count * 2)   1;
            int[] numArray = new int[num];
            Slot<TElement>[] destinationArray = new Slot<TElement>[num];
            Array.Copy(this.slots, 0, destinationArray, 0, this.count);
            for (int i = 0; i < this.count; i  )
            {
                int index = destinationArray[i].hashCode % num;
                destinationArray[i].next = numArray[index] - 1;
                numArray[index] = i   1;
            }
            this.buckets = numArray;
            this.slots = destinationArray;
        }

        public bool Add(TElement value)
        {
            return !this.Find(value, true);
        }

        internal int InternalGetHashCode(TElement value)
        {
            if (value != null)
            {
                return (this.comparer.GetHashCode(value));
            }
            return 0;
        }
    }

    internal struct Slot<TElement>
    {
        internal int hashCode;
        internal TElement value;
        internal int next;
    }
  internal class Set<TElement>
    {

        private IEqualityComparer<TElement> comparer;
        private int count;
        private int freeList;
        private Slot<TElement>[] slots;
        private int[] buckets;

        public Set()
            : this(null)
        { }

        public Set(IEqualityComparer<TElement> comparer)
        {
            if (comparer == null)
            {
                comparer = EqualityComparer<TElement>.Default;
            }
            this.comparer = comparer;
            this.slots = new Slot<TElement>[7];
            this.buckets = new int[7];
            this.freeList = -1;
        }


        private bool Find(TElement value, bool add)
        {
            int hashCode = this.InternalGetHashCode(value);
            for (int i = this.buckets[hashCode % this.buckets.Length] - 1; i >= 0; i = this.slots[i].next)
            {
                if ((this.slots[i].hashCode == hashCode) && this.comparer.Equals(this.slots[i].value, value))
                {
                    return true;
                }
            }
            if (add)
            {
                int freeList;
                if (this.freeList >= 0)
                {
                    freeList = this.freeList;
                    this.freeList = this.slots[freeList].next;
                }
                else
                {
                    if (this.count == this.slots.Length)
                    {
                        this.Resize();
                    }
                    freeList = this.count;
                    this.count  ;
                }
                int index = hashCode % this.buckets.Length;
                this.slots[freeList].hashCode = hashCode;
                this.slots[freeList].value = value;
                this.slots[freeList].next = this.buckets[index] - 1;
                this.buckets[index] = freeList   1;
            }
            return false;
        }

        private void Resize()
        {
            int num = (this.count * 2)   1;
            int[] numArray = new int[num];
            Slot<TElement>[] destinationArray = new Slot<TElement>[num];
            Array.Copy(this.slots, 0, destinationArray, 0, this.count);
            for (int i = 0; i < this.count; i  )
            {
                int index = destinationArray[i].hashCode % num;
                destinationArray[i].next = numArray[index] - 1;
                numArray[index] = i   1;
            }
            this.buckets = numArray;
            this.slots = destinationArray;
        }

        public bool Add(TElement value)
        {
            return !this.Find(value, true);
        }

        internal int InternalGetHashCode(TElement value)
        {
            if (value != null)
            {
                return (this.comparer.GetHashCode(value));
            }
            return 0;
        }
    }

    internal struct Slot<TElement>
    {
        internal int hashCode;
        internal TElement value;
        internal int next;
    }

 当数组非常不足时开始展览扩大容积(在脚下的底子上*2的蝇头质数( 1)),然后开始展览双重hashcode碰撞形成链表关系:

 当数组远远不够时开始展览扩大容积(在当下的底子上*2的细微质数( 1)),然后实行重复hashcode碰撞形成链表关系:

 private void Resize()
        {
            int num = (this.count * 2)   1;
            int[] numArray = new int[num];
            Slot<TElement>[] destinationArray = new Slot<TElement>[num];
            Array.Copy(this.slots, 0, destinationArray, 0, this.count);
            for (int i = 0; i < this.count; i  )
            {
                int index = destinationArray[i].hashCode % num;
                destinationArray[i].next = numArray[index] - 1;
                numArray[index] = i   1;
            }
            this.buckets = numArray;
            this.slots = destinationArray;
        }
 private void Resize()
        {
            int num = (this.count * 2)   1;
            int[] numArray = new int[num];
            Slot<TElement>[] destinationArray = new Slot<TElement>[num];
            Array.Copy(this.slots, 0, destinationArray, 0, this.count);
            for (int i = 0; i < this.count; i  )
            {
                int index = destinationArray[i].hashCode % num;
                destinationArray[i].next = numArray[index] - 1;
                numArray[index] = i   1;
            }
            this.buckets = numArray;
            this.slots = destinationArray;
        }

 

 

 

 

估摸看到地点的代码,能晕倒一大片,哈哈~晕倒笔者不辜负担哦。

估价看到地点的代码,能晕倒第一次全国代表大会片,哈哈~晕倒小编不担任哦。

下边大家来剖析部分原理,然后再回转眼睛上边的代码,就很清淅了,必竟写代码是创制在一种沉思根基上而来的呗!

下边大家来解析部分规律,然后再回过头看上边的代码,就很清淅了,必竟写代码是创设在一种思想基础上而来的呗!

本文由67677新澳门手机版发布于计算机编程,转载请注明出处:扩展方法,高性能篇

关键词: