未来村村长
未来村村长

【To .NET】C#集合类源码解析

大家好！我是未来村村长，就是那个“请你跟我这样做，我就跟你这样做！”的村长‍！

‍“人生苦短，你用Python”，“Java内卷，我用C#”。

​ 从Java到C#，不仅仅是语言使用的改变，更是我从理想到现实，从象牙塔到大熔炉的第一步。.NET是微软的一盘棋，而C#是我的棋子，只希望微软能下好这盘棋，而我能好好利用这个棋子。

​ 上一篇文章：【C#数据模型，从Entity Framework Core到LINQ】，我们介绍了C#如何通过EF Core与SQL Server如何建立映射关系并进行交互。这节我们通过C#集合的源码来探究集合的使用。

文章目录

    • 一、接口与实现类
    • 二、ArrayList️
      • 1、声明
      • 2、属性与变量
        • （1）公有属性
        • （2）私有变量
      • 3、关键方法
        • （1）构造方法
        • （2）Add
        • （3）AddRange
        • （4）Containers
        • （5）Insert
        • （6）Remove
      • 4、其它方法
        • （1）Reverse
        • （2）Sort
        • （3）ToArray
        • （4）Clear
      • 5、说说索引器和？⛺
        • （1）可空类型修饰符（?）
        • （2） 三元（运算符）表达式（?: )
        • （3）空合并运算符(??)
        • （4）NULL检查运算符（?.）
    • 三、SortedList
      • 1、声明
      • 2、属性和变量
        • （1）私有变量
        • （2）属性
      • 3、关键方法
        • （1）构造器
        • （2）Add
        • （3）GetKey
        • （4）GetKeyList和GetValueList
        • （5）Remove
      • 4、说说Array
    • 四、LinkedList
      • 1、声明
      • 2、属性与变量
        • （1）变量
        • （2）节点密封类
      • 3、关键方法
        • （1）构造函数
        • （2）AddFirst
        • （3）AddLast
        • （4）Remove
        • （5）Find
      • 4、其它方法
        • （1）Contains
        • （2）Clear
        • （3）GetEnumerator
      • 5、说说泛型
    • 五、Queue️
      • 1、声明
      • 2、属性与变量
        • （1）私有变量与常量
        • （2）属性
      • 3、关键方法
        • （1）构造方法
        • （2）Enqueue：入队
        • （3）Dequque：出队
        • 4、其它方法
        • （1）Peek
        • （2）Contains
    • 六、Stack️
      • 1、声明
      • 2、属性与变量
        • （1）私有变量
        • （2）属性
      • 3、关键方法
        • （1）Push：入栈
        • （2）Pop：出栈
        • （3）Peek
      • 4、说说lock
    • 七、HashTable
      • 1、声明
      • 2、属性和变量
      • 3、说说预处理器指令️
      • 4、关键方法
        • （1）构造方法
        • （2）Add
        • （3）InitHash
        • （4）this索引器
        • （5）Remove

一、接口与实现类

所有集合类或与集合相关的接口命名空间都是 System.Collections，在该命名空间中提供的常用接口如下:

  • IEnumerable：使用LINQ查询数据常以该类型作为返回对象接收类型，使用foreach进行遍历时需要该对象实现IEnumerable。
  • IEnumerator：迭代器模式被IEnumerator和IEnumerable及其对应的泛型接口所封装。如果一个类实现了IEnumerable接口，那么就能够被迭代；调用GetEnumerator方法将返回IEnumerator接口的实现，它就是迭代器本身。
  • ICollection：定义所有非泛型集合的大小、枚举数和同步方法。
  • IList：IList 泛型接口是 ICollection 泛型接口的子代，并且是所有泛型列表的基接口，并继承了 IEnumerable。

​ 针对上述的接口有一些常用的接口实现类，如下表所示。

类名称 实现接口 特点
ArrayList ICollection、IList、IEnumerable、ICloneable 集合中元素的个数是可变的，提供添加、删除等方法
Queue ICollection、IEnumerable、ICloneable 集合实现了先进先出的机制，即元素将在集合的尾部添加、在集合的头部移除
Stack ICollection、IEnumerable、ICloneable 集合实现了先进后出的机制，即元素将在集合的尾部添加、在集合的尾部移除
Hashtable IDictionary、ICollection、IEnumerable、 ICloneable 等接口 集合中的元素是以键值对的形式存放的，是 DictionaryEntry 类型的
SortedList IDictionary、ICollection、IEnumerable、 ICloneable 等接口 与 Hashtable 集合类似，集合中的元素以键值对的形式存放，不同的是该集合会按照 key 值自动对集合中的元素排序

二、ArrayList️

​ ArrayList源码：https://referencesource.microsoft.com/#mscorlib/system/collections/arraylist.cs,3e3f6715773d6643

​ 在源码讲解中，我会将详细讲解放到源码注释中，并且会删去错误验证（throw）或不影响原理的代码来达到便于阅读的效果。

1、声明

​ ArrayList是一个非泛型集合，它只实现了 IList, ICloneable接口而没有实现其泛型接口，因此无法使用标准查询运算。

public class ArrayList : IList, ICloneable

2、属性与变量

（1）公有属性

​ ArrayList定义了以下公有属性，其作用见注释。

//获取或设置 ArrayList 可以包含的元素个数。
public virtual int Capacity { get; set; }
//获取一个值，表示 ArrayList 是否具有固定大小。
public virtual bool IsFixedSize { get; }
//获取 ArrayList 中实际包含的元素个数。
public virtual int Count { get; }
//定义了索引器
public virtual object? this[int index] { get; set; }
//获取一个值，表示访问 ArrayList 是否同步（线程安全）。
public virtual bool IsSynchronized { get; }
//获取一个值，表示 ArrayList 是否只读。
public virtual bool IsReadOnly { get; }
//获取一个对象用于同步访问 ArrayList。
public virtual object SyncRoot { get; }

（2）私有变量

​ 除此ArrayList还定义了一系列私有变量，用于内部实现。

//声明了_items数组，用于存放数据，类型为Object
private Object[] _items;
//大小
private int _size;
//定义了version，作为Array的变动版本记录
private int _version;
//定义了const常量，默认容量为4
private const int _defaultCapacity = 4;
//只读的空数组
private static readonly Object[] emptyArray = EmptyArray.Value; 
 
  
3、关键方法
 
  
（1）构造方法
 
  
ArrayList构造器有三类，为了便于阅读我们删去了含有throw关键字的语句，相关解释见注释。
 
  
//空参数构造构造器
public ArrayList() {
    //项目数组，初始构造时为只读的空数组
    _items = emptyArray;
}

//指定容量构造器
public ArrayList(int capacity) {
    //如果指定大小为0，则初始为只读空数组
    if (capacity == 0)
        _items = emptyArray;
    //若不为0则初始化并定义数组大小
    else
        _items = new Object[capacity];
}

//传入集合参数的构造器
public ArrayList(ICollection c) {
    //获取集合的大小
    int count = c.Count;
    //大小为0，则初始化为只读空数组
    if (count == 0)
    {
       _items = emptyArray;
    }
    //大小不为0，则初始化相应大小，并通过AddRange将集合C加入到该ArrayList中
    else {
       _items = new Object[count];
       AddRange(c);
}
}

 
  
（2）Add
 
  
public virtual int Add(Object value) {
    //判断容量是否足够
     if (_size == _items.Length) EnsureCapacity(_size + 1);
    //存放数据
     _items[_size] = value;
    //版本更新
     _version++;
    //返回集合大小
     return _size++;
}

//确保容量足够，如果不够则执行_items.Length * 2，进行二倍扩容
private void EnsureCapacity(int min) {
    if (_items.Length < min){
    	int newCapacity = _items.Length == 0? _defaultCapacity: _items.Length * 2;
    	if ((uint)newCapacity > Array.MaxArrayLength) newCapacity = Array.MaxArrayLength;
    	if (newCapacity < min) newCapacity = min;
    	Capacity = newCapacity;
	}
}

 
  
（3）AddRange
 
  
public virtual void AddRange(ICollection c) {
    //调用InsertRange方法，传入数组大小和集合c
    InsertRange(_size, c);
}

public virtual void InsertRange(int index, ICollection c) {
    //获取集合c的大小
	int count = c.Count;
    if (count > 0) {
        //确保容量足够，否则扩容
        EnsureCapacity(_size + count);              
		//创建一个新的数组itemsToInsert
        Object[] itemsToInsert = new Object[count];
        //将集合c中的元素，复制到数组itemsToInsert中
        c.CopyTo(itemsToInsert, 0);
        //将itemsToInsert数组复制到ArrayList集合中的_items数组中
        itemsToInsert.CopyTo(_items, index);
        //增加容量
        _size += count;
        //更新版本
        _version++;
   }
}

 
  
（4）Containers
 
  
​ for循环遍历_items数组，通过Equals方法进行比较。
 
  
public virtual bool Contains(Object item) {
     if (item==null) {
         for(int i=0; i<_size; i++)
             if (_items[i]==null)
                return true;
             return false;
         }
     else {
         for(int i=0; i<_size; i++)
             if ( (_items[i] != null) && (_items[i].Equals(item)) )
                return true;
             return false;
        }
}

 
  
（5）Insert
 
  
​ 通过Copy将index后的元素向后移动位，最后空出index进行赋值。
 
  
public virtual void Insert(int index, Object value) {
      if (_size == _items.Length) EnsureCapacity(_size + 1);
      if (index < _size) {
           Array.Copy(_items, index, _items, index + 1, _size - index);
      }
      _items[index] = value;
      _size++;
      _version++;
}

 
  
（6）Remove
 
  
​ 先通过IndexOf找到被删除元素的索引，然后通过RemoveAt，进行删除，此处是将index后的元素集体向前移动一位，最后将末尾元素置为null。
 
  
 public virtual void Remove(Object obj) {
      int index = IndexOf(obj);
      if (index >=0) 
      RemoveAt(index);
}

public virtual void RemoveAt(int index) {
     _size--;
     if (index < _size) {
          Array.Copy(_items, index + 1, _items, index, _size - index);
     }
     _items[_size] = null;
     _version++;
}

 
  
4、其它方法
 
  
​ 在其它方法中，不解读，只保留关键代码。
 
  
（1）Reverse
 
  
public virtual void Reverse(int index, int count) {
    Array.Reverse(_items, index, count);
    _version++;
}

 
  
（2）Sort
 
  
public virtual void Sort(int index, int count, IComparer comparer) {
    Array.Sort(_items, index, count, comparer);
    _version++;
}

 
  
（3）ToArray
 
  
public virtual Array ToArray(Type type) {
    Array array = Array.UnsafeCreateInstance(type, _size);
    Array.Copy(_items, 0, array, 0, _size);
    return array;
}

 
  
（4）Clear
 
  
public virtual void Clear() {
     Array.Clear(_items, 0, _size); 
     _size = 0;
     _version++;
}

 
  
5、说说索引器和？⛺
 
  
​ 我们发现C#中的集合中很少看到GET方法，因为C#集合统一使用索引器来进行集合元素的访问。像Get(int index)或Get(String key)都可以使用collection[index]或collection[key]，来进行访问和修改。
 
  
​ 当您为类定义一个索引器时，该类的行为就会像一个 虚拟数组（virtual array） 一样。您可以使用数组访问运算符 [ ] 来访问该类的的成员。
 
  
​ 索引器格式为：
 
  
Type this[int index]{get{};set{};}

 
  
​ ArrayList的索引器：
 
  
public virtual object? this[int index] { get; set; }

 
  
​ 这里使用了？，我们来回顾以下C#中的？相关语法糖。来源：[https://www.cnblogs.com/youmingkuang/p/11459615.html]
 
  
（1）可空类型修饰符（?）
 
  
​ 引用类型可以使用空引用表示一个不存在的值，而值类型通常不能表示为空。
 
  
​ 例如：string str=null; 是正确的，int i=null; 编译器就会报错。
 
  
​ 为了使值类型也可为空，就可以使用可空类型，即用可空类型修饰符"？“来表示，表现形式为"T？”
 
  
（2） 三元（运算符）表达式（?: )
 
  
​ 例如：x?y:z 表示如果表达式x为true，则返回y；
 
  
​ 如果x为false，则返回z，是省略if{}else{}的简单形式。
 
  
（3）空合并运算符(??)
 
  
​ 用于定义可空类型和引用类型的默认值。
 
  
​ 如果此运算符的左操作数不为null，则此运算符将返回左操作数，否则返回右操作数。
 
  
​ 例如：a??b 当a为null时则返回b，a不为null时则返回a本身。
 
  
（4）NULL检查运算符（?.）
 
  
​ 如果对象为NULL，则不进行后面的获取成员的运算，直接返回NULL。
 
  
三、SortedList
 
  
​ 它可以使用键和索引来访问列表中的项。
 
  
​ 排序列表是数组和哈希表的组合。它包含一个可使用键或索引访问各项的列表。如果您使用索引访问各项，则它是一个动态数组（ArrayList），如果您使用键访问各项，则它是一个哈希表（Hashtable）。集合中的各项总是按键值排序。
 
  
1、声明
 
  
public class SortedList : IDictionary, ICloneable

 
  
2、属性和变量
 
  
（1）私有变量
 
  
//两个数组
private Object[] keys;
private Object[] values;
private int _size;
private int version;
private IComparer comparer;
private KeyList keyList;
private ValueList valueList;
[NonSerialized]
private Object _syncRoot;
private const int _defaultCapacity = 16;
private static Object[] emptyArray = EmptyArray.Value; 
 
  
（2）属性
 
  
public virtual int Capacity;
public virtual int Count;
public virtual ICollection Keys;
public virtual ICollection Values;
public virtual bool IsSynchronized;
public virtual Object SyncRoot;
public virtual bool IsReadOnly;

 
  
3、关键方法
 
  
（1）构造器
 
  
public SortedList(int initialCapacity) {
	keys = new Object[initialCapacity];
	values = new Object[initialCapacity];
	comparer = new Comparer(CultureInfo.CurrentCulture);            
}

public SortedList(IComparer comparer):this() {
    if (comparer != null) this.comparer = comparer;
}

public SortedList(IComparer comparer, int capacity):this(comparer) {
    Capacity = capacity;
}

 
  
​ IComparer：继承IComparer接口,可以自定义比较器，IComparable提供了方法int CompareTo(object obj)用于两个对象的比较。
 
  
（2）Add
 
  
public virtual void Add(Object key, Object value) {
	int i = Array.BinarySearch(keys, 0, _size, key, comparer);
    Insert(~i, key, value);
}

private void Insert(int index, Object key, Object value) {
    //扩容
	if (_size == keys.Length) EnsureCapacity(_size + 1);
    //如果插入到中间，则将index之后的元素后移一位
	if (index < _size) {
		Array.Copy(keys, index, keys, index + 1, _size - index);
		Array.Copy(values, index, values, index + 1, _size - index);
	}
    //插入元素到index
	keys[index] = key;
	values[index] = value;
	_size++;
	version++;
}

 
  
~ 运算符通过反转每个位产生其操作数的按位求补
 
  
（3）GetKey
 
  
public virtual Object GetKey(int index) {
	return keys[index];
}

 
  
（4）GetKeyList和GetValueList
 
  
public virtual IList GetKeyList() {
	if (keyList == null) keyList = new KeyList(this);
	return keyList;
}

public virtual IList GetValueList() {
	if (valueList == null) valueList = new ValueList(this);
	return valueList;
}

 
  
（5）Remove
 
  
public virtual void Remove(Object key) {
	int i = IndexOfKey(key);
	if (i >= 0)  RemoveAt(i);
}

public virtual void RemoveAt(int index) {
	_size--;
    //如果删除到中间，则将index之前的元素后移一位
	if (index < _size) {
		Array.Copy(keys, index + 1, keys, index, _size - index);
		Array.Copy(values, index + 1, values, index, _size - index);
    }
    keys[_size] = null;
    values[_size] = null;
    version++;
}

 
  
4、说说Array
 
  
​ C#中的Array是一个很强大的类。Array 类是 C# 中所有数组的基类，它是在 System 命名空间中定义。Array 类提供了各种用于数组的属性和方法。
 
  
public abstract class Array : ICloneable, IList, IStructuralComparable, IStructuralEquatable 

 
  
其常用方法如下：
 
  
//Copy
public static void Copy(Array sourceArray, Array destinationArray, int length);
public static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);
//CopyTo
public void CopyTo(Array array, int index);
//IndexOf
public static int IndexOf(Array array, Object value);
public static int LastIndexOf(Array array, Object value);
//Sort
public static void Sort(Array array);
//Reverse
public static void Reverse(Array array);
public static void Reverse(Array array, int index, int length);

 
  
四、LinkedList
 
  
​ LinkedList源码：https://referencesource.microsoft.com/#System/compmod/system/collections/generic/linkedlist.cs
 
  
​ 在源码讲解中，我会将详细讲解放到源码注释中，并且会删去错误验证（throw）或不影响原理的代码来达到便于阅读的效果。
 
  
1、声明
 
  
​ 与ArrayList不同的是LinkedList的命名空间为namespace System.Collections.Generic，除此还实现了ICollection，是泛型类集合[本文只有该集合来自Generic]。
 
  
public class LinkedList: ICollection, System.Collections.ICollection, IReadOnlyCollection,ISerializable, IDeserializationCallback 

 
  
2、属性与变量
 
  
（1）变量
 
  
//内部变量
//头节点
internal LinkedListNode head;
//大小
internal int count;
internal int version;
//私有变量
private Object _syncRoot;
private SerializationInfo siInfo; //A temporary variable which we need during deserialization.   //常量
const String VersionName = "Version";
const String CountName = "Count";  
const String ValuesName = "Data";

 
  
（2）节点密封类
 
  
​ sealed的中文意思是密封，由它修饰的类或方法将不能被继承或是重写，sealed修饰符不能和 abstract 同时使用,因为抽象类必须由提供抽象方法或属性的实现的类来继承,密封类不能同时又是抽象类，因为抽象总是希望被继承的。abstract是抽象，那sealed就是硬性标准。
 
  
public sealed class LinkedListNode {
        //变量
    	//链表
        internal LinkedList list;
    	//后置节点
        internal LinkedListNode next;
    	//前驱节点
        internal LinkedListNode prev;
    	//存放数据
        internal T item;
      
        //属性
    	//对应item
         public T Value {
            get { return item;}
            set { item = value;}
        }
        //对应链表
        public LinkedList List {
            get { return list;}
        }
 		//对应后置节点
        public LinkedListNode Next {
            get { return next == null || next == list.head? null: next;}
        }
 		//对应前驱节点
        public LinkedListNode Previous {
            get { return prev == null || this == list.head? null: prev;}
        }
 
		//方法
        public LinkedListNode(T value) {
            this.item = value;
        }
 		
        internal LinkedListNode(LinkedList list, T value) {
            this.list = list;
            this.item = value;
        }
 
    	//使无效:当前节点以及节点引用置为空
        internal void Invalidate() {
            list = null;
            next = null;
            prev = null;
        }           
    }   
}
 

 
  
3、关键方法
 
  
（1）构造函数
 
  
//空参构造
public LinkedList() {}

//传入泛型集合类型参数构造
public LinkedList(IEnumerable collection) {
		//遍历泛型集合类对象，将该对象节点逐个加入到LinkedList尾部
        foreach( T item in collection) {
            AddLast(item);
        }
}

 
  
（2）AddFirst
 
  
public LinkedListNode AddFirst(T value) {
    //传入当前list对象和value，生成节点
    LinkedListNode result = new LinkedListNode(this, value);
    //如果头节点为空
    if (head == null) {
        //插入为头节点
        InternalInsertNodeToEmptyList(result);
    } 
    else {
        //头节点不为空，新节点作为头节点
        InternalInsertNodeBefore(head, result);               
        head = result;                
    }
    return result;
}

private void InternalInsertNodeToEmptyList(LinkedListNode newNode) {
    //将该节点的前后节点都指向新节点
	newNode.next = newNode;
	newNode.prev = newNode;
    //将该节点赋值成为头节点
	head = newNode;
	version++;
	count++; 
}

private void InternalInsertNodeBefore(LinkedListNode node, LinkedListNode newNode) {
    //将该节点的下一个节点指向传入节点[传入的是头节点的话，指向头节点]
	newNode.next = node;
    //新节点的前驱指向传入节点的前驱
	newNode.prev = node.prev;
    //将传入节点的前驱节点的后置指向新节点
	node.prev.next = newNode;
    //将传入节点的前驱指向新节点
	node.prev = newNode;            
    version++;
    count++;
}

 
  
（3）AddLast
 
  
public LinkedListNode AddLast(T value) {
	LinkedListNode result = new LinkedListNode(this, value);        
	if (head==null) {
		InternalInsertNodeToEmptyList(result);
    } 
    else {
        InternalInsertNodeBefore(head, result);               
    }       
    return result;
}

 
  
​ 我们发现这个方法和AddFirst方法十分相似，唯一缺少的一步是[head = result;]，那如此新节点就会插入到头节点的前一个节点。那每次节点的插入都是插到head头节点的前面，前插则新节点成为新头节点，尾插则头节点的前一个节点就是尾节点。（此处不同于Java中的LinkedList属性中含有头尾节点）。
 【To .NET】C#集合类源码解析_第1张图片
 
  
（4）Remove
 
  
public bool Remove(T value) {
    LinkedListNode node = Find(value);
    if (node != null) {
        InternalRemoveNode(node); 
        return true;
    }
    return false;
}

internal void InternalRemoveNode(LinkedListNode node) {
    //该节点后置的前驱指向该节点的前驱
    node.next.prev = node.prev;
    //该节点的前驱的后置指向该节点的后置
    node.prev.next = node.next;
    //如果是头节点，则该节点的后置节点成为头节点
    if ( head == node) {
         head = node.next;
    }
    node.Invalidate();  
    count--;
    version++;          
}

 
  
（5）Find
 
  
public LinkedListNode Find(T value) {
    //获取头节点
	LinkedListNode node = head;
    EqualityComparer c = EqualityComparer.Default;
    //如果头节点不为null
    if (node != null) {
        if (value != null) {
			do {
                //直到当前节点等于查询节点
            	if (c.Equals(node.item, value)) {
                return node;   
              	}
                //迭代到下一个节点
           		node = node.next;
           //循环遍历
           } while (node != head);
         } 
     else {
        	do {
            	if (node.item == null) {
             	return node;
            	}
            	node = node.next;
        		} while (node != head);
     	}
     }
     return null;        
}

 
  
4、其它方法
 
  
（1）Contains
 
  
public bool Contains(T value) {
     return Find(value) != null;    
}

 
  
（2）Clear
 
  
 public void Clear() {
     LinkedListNode current = head;  
     //循环遍历
     while (current != null ) {
         LinkedListNode temp = current;
         current = current.Next;
         //使每个节点置为空[使无效]
         temp.Invalidate();                
     }
     //头节点置为null
	 head = null;
     count = 0;             
     version++;     
}

 
  
（3）GetEnumerator
 
  
​ 获取迭代器。
 
  
public Enumerator GetEnumerator() {
    return new Enumerator(this);
}

 
  
5、说说泛型
 
  
​ 泛型（Generic）允许您延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。换句话说，泛型允许您编写一个可以与任何数据类型一起工作的类或方法。
 
  
​ 泛型类：
 
  
public class MyGenericArray
{
	private T[] array;
	public MyGenericArray(int size)
	{
		array = new T[size + 1];
	}
	public T getItem(int index)
	{
	return array[index];
	}
    
	public void setItem(int index, T value)
	{
		array[index] = value;
	}
}

 
  
​ 泛型方法：
 
  
static void Swap(ref T lhs, ref T rhs)
{
	T temp;
	temp = lhs;
	lhs = rhs;
	rhs = temp;
}

 
  
五、Queue️
 
  
1、声明
 
  
​ Queue同样也是非泛型集合。
 
  
public class Queue : ICollection, ICloneable

 
  
​ 实现ICloneable接口使一个类型成为可克隆的（cloneable），这需要提供Clone方法来提供该类型的对象的副本。Clone方法不接受任何参数，返回object类型的对象（不管是何种类型实现该接口）。所以我们获得副本后仍需要进行显式地转换。
 
  
​ 深拷贝与浅拷贝：如果自定义类型包含引用类型的数据成员，必须考虑Clone方法是实现浅拷贝（shallow copy）还是深拷贝（deep copy）。浅拷贝是指副本对象中的引用类型的数据成员与源对象的数据成员指向相同的对象。而如果是深拷贝，则必须创建整个对象的结构，副本对象中的引用类型的数据成员与源对象的数据成员指向不同的对象。
 
  
2、属性与变量
 
  
（1）私有变量与常量
 
  
private Object[] _array;//数组
private int _head;//头部  
private int _tail;//尾部
private int _size;//大小
private int _growFactor;
private int _version;//版本
[NonSerialized]
private Object _syncRoot;//同步源
//私有常量    
private const int _MinimumGrow = 4;
private const int _ShrinkThreshold = 32;

 
  
（2）属性
 
  
public virtual int Count {
    get { return _size; }
}

public virtual bool IsSynchronized {
    get { return false; }
}

public virtual Object SyncRoot {
    get { 
          if( _syncRoot == null) {
            System.Threading.Interlocked.CompareExchange(ref _syncRoot, new Object(), null);    
          }
        return _syncRoot;                 
        }
}

 
  
3、关键方法
 
  
（1）构造方法
 
  
public Queue(int capacity, float growFactor) {
    //传入容量
	_array = new Object[capacity];
	_head = 0;
	_tail = 0;
	_size = 0;
	_growFactor = (int)(growFactor * 100);
}

//空参构造
public Queue():this(32, (float)2.0){}
//指定容量构造
public Queue(int capacity) : this(capacity, (float)2.0) {} 

 
  
（2）Enqueue：入队
 
  
public virtual void Enqueue(Object obj){
    //如果_size等于数组大小，则进行扩容
    if (_size == _array.Length) {
        int newcapacity = (int)((long)_array.Length * (long)_growFactor / 100);
        if (newcapacity < _array.Length + _MinimumGrow) {
             newcapacity = _array.Length + _MinimumGrow;
        }
        //扩容方法
        SetCapacity(newcapacity);
    }
    //加入到索引tail处
	_array[_tail] = obj;
    //更新索引_tail
	_tail = (_tail + 1) % _array.Length;
	_size++;
	_version++;
}

//设置容量大小
private void SetCapacity(int capacity) {
    //新建数组
	Object[] newarray = new Object[capacity];
    //将原数组元素复制到新数组
	if (_size > 0) {
		if (_head < _tail) {
			Array.Copy(_array, _head, newarray, 0, _size);
		} else {
			Array.Copy(_array, _head, newarray, 0, _array.Length - _head);
			Array.Copy(_array, 0, newarray, _array.Length - _head, _tail);
        }
    }
    //数组更新为新容量数组
	_array = newarray;
    //更新头尾索引
	_head = 0;
	_tail = (_size == capacity) ? 0 : _size;            
	_version++;
}

 
  
（3）Dequque：出队
 
  
public virtual Object Dequeue() {
    //获取头索引元素
	Object removed = _array[_head];
    //移除头索引元素
	_array[_head] = null;
    //更新头索引
	_head = (_head + 1) % _array.Length;
	_size--;
	_version++;
	return removed;
}

 
  
​ 看了出队入队以后，我们发现C#的队列实现是一个循环数组，通过%数组长度来达到循环效果。
 
  
【To .NET】C#集合类源码解析_第2张图片
 
  
4、其它方法
 
  
（1）Peek
 
  
public virtual Object Peek() {
	return _array[_head];
}    

 
  
（2）Contains
 
  
public virtual bool Contains(Object obj) {
	int index = _head;
	int count = _size;
    //循环遍历，从头节点开始
	while (count-- > 0) {
		if (obj == null) {
			if (_array[index] == null)
				return true;
        } else if (_array[index] != null && _array[index].Equals(obj)) {
            return true;
		}
        //需要注意的是index不是从0开始，每次取索引都需要%
    	index = (index + 1) % _array.Length;
    }
	return false;
}

 
  
六、Stack️
 
  
1、声明
 
  
public class Stack : ICollection, ICloneable

 
  
2、属性与变量
 
  
（1）私有变量
 
  
private Object[] _array;     // Storage for stack elements
[ContractPublicPropertyName("Count")]
private int _size;           // Number of items in the stack.
private int _version;        // Used to keep enumerator in sync w/ collection.
[NonSerialized]
private Object _syncRoot;
private const int _defaultCapacity = 10;

 
  
（2）属性
 
  
public virtual int Count  
public virtual bool IsSynchronized
public virtual Object SyncRoot

 
  
3、关键方法
 
  
（1）Push：入栈
 
  
public virtual void Push(Object obj) {
    //扩容
	if (_size == _array.Length) {
		Object[] newArray = new Object[2*_array.Length];
		Array.Copy(_array, 0, newArray, 0, _size);
		_array = newArray;
    }
    //按照顺序存放
    _array[_size++] = obj;
    _version++;
}

 
  
（2）Pop：出栈
 
  
public virtual Object Pop() {
	_version++;
    //后进先出
	Object obj = _array[--_size];
	_array[_size] = null;
	return obj;
}

 
  
（3）Peek
 
  
​ 取到size-1，这里说明size处没有具体存放元素。
 
  
public virtual Object Peek() {
	return _array[_size-1];
}

 
  
4、说说lock
 
  
​ 我们在这里说说之前一直没提到的同步方法。
 
  
[HostProtection(Synchronization=true)]
public static Stack Synchronized(Stack stack) {
	return new SyncStack(stack);
}

internal SyncStack(Stack stack) {
	_s = stack;
	_root = stack.SyncRoot;
}

 
  
​ 这里使用Synchronized使栈同步，实际上是调用其私有同步栈的构造器。
 
  
[Serializable]
private class SyncStack : Stack
	{
	private Stack _s;
	private Object _root;
    
	internal SyncStack(Stack stack) {
	_s = stack;
	_root = stack.SyncRoot;
	}
    
	public override bool IsSynchronized {get { return true; }}
    
	public override Object SyncRoot {get {return _root;}}
    
	public override int Count { 
        get { 
			lock (_root) {
				return _s.Count;
			} 
		}
	}
}

 
  
​ 我们看来几个较为关键的方法。
 
  
public override void Push(Object value) {
	lock (_root) {
		_s.Push(value);
	}
}
 
public override Object Pop() {
	lock (_root) {
		return _s.Pop();
	}
}
   
public override Object Peek() {
	lock (_root) {
		return _s.Peek();
    }
}

 
  
​ 我们发现每一个方法都使用如下结构。
 
  
lock (_root) {
	方法名();
}

 
  
​ 这里的_root是一个Object对象，用为。
 
  
​ lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。它可以定义一段代码为临界区代码段（线程访问互斥），一个时刻只允许一个线程进入临界区代码段，其它线程必须等待。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。
 
  
​ lock关键字定义： lock（expression） statement_block，其中expression代表你希望跟踪的对象，通常是对象引用。
 
  
​ 通常，应避免锁定 public 类型，否则实例将超出代码的控制范围。 lock (this)、lock (typeof (MyType)) 同步控制的范围较大，我们尽量通过集合类中lock(private object _root)这样的方式，缩小临界范围。因为lock锁定的对象是一个程序块的内存边界，我们应当缩小该边界范围。
 
  
​ 最后：
 
  
     
   
  • lock不能锁定空值
    •  
   
  • lock不能锁定string类型：相同内容的字符串都代表着同一个实例
    •  
   
  • lock不能锁定值类型：值类型不是引用类型的，虽然可以装箱，但是会报错
    •  
   
  • lock(this)的缺点：该实例被一个线程访问后，便不允许其它线程进行访问，哪怕访问的内容非临界区代码
    •  
   
  • lock最好不要锁定public修饰的类型引用或不受程序控制的对象，否则将超出代码的控制范围
    •  
  
 
  
七、HashTable
 
  
​ C#中实现了哈希表数据结构的集合类有System.Collections.Hashtable和System.Collections.Generic.Dictionary，前者为一般类型的哈希表，后者是泛型版本的哈希表。Dictionary和Hashtable之间并非只是简单的泛型和非泛型的区别，两者使用了完全不同的哈希冲突解决办法。
 
  
1、声明
 
  
public class Hashtable : IDictionary, ISerializable, IDeserializationCallback, ICloneable

 
  
2、属性和变量
 
  
//这里定义了结构体—桶
private struct bucket {
	public Object key;//键
	public Object val;//值
	public int hash_coll;//Hash码
}
//桶数组，用于存放key-value对
private bucket[] buckets;
private int count;       
private int occupancy;
private int loadsize;
//装填因子
private float loadFactor;
private volatile int version;
private volatile bool isWriterInProgress;        
private ICollection keys;
private ICollection values;
private IEqualityComparer _keycomparer;
private Object _syncRoot;

 
  
3、说说预处理器指令️
 
  
【以下来自官方文档】
 
  
使用四个预处理器指令来控制条件编译：
 
  
     
   
  • #if：打开条件编译，其中仅在定义了指定的符号时才会编译代码。
    •  
   
  • #elif：关闭前面的条件编译，并基于是否定义了指定的符号打开一个新的条件编译。
    •  
   
  • #else：关闭前面的条件编译，如果没有定义前面指定的符号，打开一个新的条件编译。
    •  
   
  • #endif：关闭前面的条件编译。
    •  
  
 
  
如果 C# 编译器遇到 #if 指令，最后跟着一个 #endif 指令，则仅当定义指定的符号时，它才编译这些指令之间的代码。 与 C 和 C++ 不同，不能将数字值分配给符号。 C# 中的 #if 语句是布尔值，且仅测试是否已定义该符号。 例如：
 
  
#if DEBUG
    Console.WriteLine("Debug version");
#endif

 
  
可以使用运算符 ==（相等）和 !=（不相等）来测试 bool 值是 true 还是 false。 true 表示定义该符号。 语句 #if DEBUG 具有与 #if (DEBUG == true) 相同的含义。 可以使用 && (and)、|| (or) 和 !(not) 运算符来计算是否已定义多个符号。 还可以用括号对符号和运算符进行分组。
 
  
#if 以及 #else、#elif、#endif、#define 和 #undef 指令，允许基于是否存在一个或多个符号包括或排除代码。 条件编译在编译调试版本的代码或编译特定配置的代码时会很有用。
 
  
以 #if 指令开头的条件指令必须以 #endif 指令显式终止。 #define 允许你定义一个符号。 通过将该符号用作传递给 #if 指令的表达式，该表达式的计算结果为 true。 还可以通过 DefineConstants 编译器选项来定义符号。 可以通过 #undef 取消定义符号。 使用 #define 创建的符号的作用域是在其中定义它的文件。 使用 DefineConstants 或 #define 定义的符号与具有相同名称的变量不冲突。 也就是说，变量名称不应传递给预处理器指令，且符号仅能由预处理器指令评估。
 
  
#elif 可以创建复合条件指令。 如果之前的 #if 和任何之前的可选 #elif 指令表达式的值都不为 true，则计算 #elif 表达式。 如果 #elif 表达式计算结果为 true，编译器将计算 #elif 和下一条件指令间的所有代码。 例如：
 
  
#define VC7
//...
#if debug
    Console.WriteLine("Debug build");
#elif VC7
    Console.WriteLine("Visual Studio 7");
#endif

 
  
#else 允许创建复合条件指令，因此，如果先前 #if 或（可选）#elif 指令中的任何表达式的计算结果都不是 true，则编译器将对介于 #else 和下一个 #endif 之间的所有代码进行求值。 #endif(#endif) 必须是 #else 之后的下一个预处理器指令。
 
  
#endif 指定条件指令的末尾，以 #if 指令开头。
 
  
4、关键方法
 
  
​ HashTable的源码较为复杂，此处未能详细解读，待以后补充。
 
  
（1）构造方法
 
  
public Hashtable() : this(0, 1.0f) {}

public Hashtable(int capacity, float loadFactor) {
	//0.72是基于性能测试的较优选  
	this.loadFactor = 0.72f * loadFactor;
    //确定Hashtable容量大小
	double rawsize = capacity / this.loadFactor; 
	int hashsize = (rawsize > InitialSize) ? HashHelpers.GetPrime((int)rawsize) : InitialSize;
    //初始化桶
    buckets = new bucket[hashsize];
	loadsize = (int)(this.loadFactor * hashsize);
    isWriterInProgress = false;
    // Based on the current algorithm, loadsize must be less than hashsize.
	Contract.Assert( loadsize < hashsize, "Invalid hashtable loadsize!");
}

 
  
（2）Add
 
  
public virtual void Add(Object key, Object value) {
	Insert(key, value, true);
}

 
  
（3）InitHash
 
  
private uint InitHash(Object key, int hashsize, out uint seed, out uint incr) {
	uint hashcode = (uint) GetHash(key) & 0x7FFFFFFF;
	seed = (uint) hashcode;
	incr = (uint)(1 + ((seed * HashPrime) % ((uint)hashsize - 1)));
	return hashcode;
}

 
  
（4）this索引器
 
  
​ 这里的索引器不通过index来进行索引，而是通过Object key进行索引。
 
  
public virtual Object this[Object key] {
	get {
		uint seed;
		uint incr;
		bucket[] lbuckets = buckets;
		uint hashcode = InitHash(key, lbuckets.Length, out seed, out incr);
		int  ntry = 0;
		bucket b;
		int bucketNumber = (int) (seed % (uint)lbuckets.Length); 
		do{
			int currentversion;
			int spinCount = 0;
			do {
					currentversion = version;
					b = lbuckets[bucketNumber];                        
					if( (++spinCount) % 8 == 0 ) {   
							Thread.Sleep(1); 
            		}
           		} while ( isWriterInProgress || (currentversion != version) );
			if (b.key == null) {
				return null;
			}
			if (((b.hash_coll & 0x7FFFFFFF) == hashcode) && KeyEquals (b.key, key))
                        return b.val;
            bucketNumber = (int) (((long)bucketNumber + incr)% (uint)lbuckets.Length);           			} while (b.hash_coll < 0 && ++ntry < lbuckets.Length);
           return null;
        }
	set {
         Insert(key, value, false);
	}
}

 
  
（5）Remove
 
  
public virtual void Remove(Object key) {
	uint seed;
	uint incr;
    //获取hash码
	uint hashcode = InitHash(key, buckets.Length, out seed, out incr);
	int ntry = 0;
	bucket b;
    //桶的号码定位
	int bn = (int) (seed % (uint)buckets.Length);
	do {
		b = buckets[bn];
		if (((b.hash_coll & 0x7FFFFFFF) == hashcode) && KeyEquals (b.key, key)) {
			isWriterInProgress = true;
			buckets[bn].hash_coll &= unchecked((int)0x80000000);
            
			if (buckets[bn].hash_coll != 0) {
				buckets[bn].key = buckets;
			} 
			else {
				buckets[bn].key = null;
        	}
            
			buckets[bn].val = null;
			count--;
			UpdateVersion();
			isWriterInProgress = false;    
			return;
       	}
			bn = (int) (((long)bn + incr)% (uint)buckets.Length);                               
       } while (b.hash_coll < 0 && ++ntry < buckets.Length);
}

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(.NET之旅,c#,.net,C#集合,Collections)

        

            

                
    
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • C#中使用split分割字符串
                        互联网打工人no1
c#
                        
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
    
                    
    • 
                    
  • python os.environ_python os.environ 读取和设置环境变量
                        weixin_39605414
pythonos.environ
                        
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
    
                    
    • 
                    
  • Git常用命令－修改远程仓库地址
                        猿大师
LinuxJavagitjava
                        
    查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
    
                    
    • 
                    
  • Faiss：高效相似性搜索与聚类的利器
                        网络·魚
大数据faiss
                        
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
    
                    
    • 
                    
  • 【无标题】达瓦达瓦
                        JhonKI
考研
                        
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
    
                    
    • 
                    
  • 上图为是否色发
                        JhonKI
考研
                        
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
    
                    
    • 
                    
  • 143234234123432
                        JhonKI
考研
                        
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
    
                    
    • 
                    
  • 【勾心原创】《去年夏天》
                        不勾心的豆角

                        
    （原创作者：不勾心的豆角）本期【勾心原创】，继续本人不勾心的豆角的现代诗创作之旅。《去年夏天》原创作者：不勾心的豆角那里芳草茵茵绿柳成行澄净蓝天下屋顶们相亲相爱闪着橙色紫色的馨香溪流温柔偎依着村庄牛儿羊儿信步徜徉还有成群的白鸽在尖顶的教堂盘旋歌唱孩子们是自由的蒲公英奔跑在希望的田野上任由天真的笑声肆无忌惮烂漫这人间天堂夜幕小心翼翼呵护着甜美的梦乡只剩尽职的晚风陪伴顽皮的星子们游荡快告诉我心爱的姑娘
    
                    
    • 
                    
  • 厦门自由行之第一天:
                        大苏子在广漂

                        
    厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
    
                    
    • 
                    
  • Python中深拷贝与浅拷贝的区别
                        yuxiaoyu.

                        
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
    
                    
    • 
                    
  • 你可能遗漏的一些C#/.NET/.NET Core知识点
                        追逐时光者
C#.NETDotNetGuide编程指南c#.net.netcoremicrosoft
                        
    前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
    
                    
    • 
                    
  • Python实现简单的机器学习算法
                        master_chenchengg
pythonpython办公效率python开发IT
                        
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
    
                    
    • 
                    
  • 【韩玲】领读小组2月21日打卡文集合
                        9ce517ee104c

                        
    【输出者】健芳【打卡素材】对财富说是Day50【作者】［澳］奥南朵【标题】让努力看得见【字数】7931建立新信念做事情失败的原因都由我们自己无意识的旧有的信念去掌控着。故步自封，没让自己去更新迭代自己的信念。建立新的信念，相信自己的财富会越来越多。2改掉坏习惯以前的懒床、刷手机、煲剧、这些都是封锁自己思想的坏习惯，以为这样就可以让自己过得充实。其实真的不是，而是带给自己一种伤害，阻碍自己努力上进的
    
                    
    • 
                    
  • 用Python实现读取统计单词个数
                        程序媛了了
python游戏java
                        
    完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
    
                    
    • 
                    
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通
                        学习3人组
大数据大数据
                        
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • 光盘文件系统 (iso9660) 格式解析
                        穷人小水滴
光盘文件系统iso9660denoGNU/Linuxjavascript
                        
    越简单的系统,越可靠,越不容易出问题.光盘文件系统(iso9660)十分简单,只需不到200行代码,即可实现定位读取其中的文件.参考资料:https://wiki.osdev.org/ISO_9660相关文章:《光盘防水嘛?DVD+R刻录光盘泡水实验》https://blog.csdn.net/secext2022/article/details/140583910《光驱的内部结构及日常使用》ht
    
                    
    • 
                    
  • 科幻游戏 《外卖员模拟器》 主要地理环境设定 (1)
                        穷人小水滴
游戏科幻设计
                        
    游戏名称:《外卖员模拟器》(英文名称:waimai_se)作者:穷人小水滴本故事纯属虚构,如有雷同实属巧合.故事发生在一个(架空)平行宇宙的地球,21世纪(超低空科幻流派).相关文章:https://blog.csdn.net/secext2022/article/details/141790630目录1星球整体地理设定2巨蛇国主要设定3海蛇市主要设定3.1主要地标建筑3.2交通3.3能源(电力)
    
                    
    • 
                    
  • react-intl——react国际化使用方案
                        苹果酱0567
面试题汇总与解析java开发语言中间件springboot后端
                        
    国际化介绍i18n：internationalization国家化简称，首字母+首尾字母间隔的字母个数+尾字母，类似的还有k8s(Kubernetes)React-intl是React中最受欢迎的库。使用步骤安装#usenpmnpminstallreact-intl-D#useyarn项目入口文件配置//index.tsximportReactfrom"react";importReactDOMf
    
                    
    • 
                    
  • Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net
                        佛一脚
errorreactmongodb数据库
                        
    背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
    
                    
    • 
                    
  • C++ lambda闭包消除类成员变量
                        barbyQAQ
c++c++java算法
                        
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
    
                    
    • 
                    
  • tiff批量转png
                        诺有缸的高飞鸟
opencv图像处理pythonopencv图像处理
                        
    目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
    
                    
    • 
                    
  • 笋丁网页自动回复机器人V3.0.0免授权版源码
                        希希分享
软希网58soho_cn源码资源笋丁网页自动回复机器人
                        
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
    
                    
    • 
                    
  • [Unity]在场景中随机生成不同位置且不重叠的物体
                        Bartender_Jill
Graphics图形学笔记unity游戏引擎动画
                        
    1.前言最近任务需要用到Unity在场景中随机生成物体，且这些物体不能重叠，简单记录一下。参考资料:Howtoensurethatspawnedtargetsdonotoverlap?2.结果与代码结果如下所示：代码如下所示：usingSystem.Collections.Generic;usingUnityEngine;namespaceAssets.Scripts{publicclassNew
    
                    
    • 
                    
  • matlab delsat = setdiff(1:69,unique(Eph(30,:)))； 语句含义
                        黄卷青灯77
matlab开发语言setdiff
                        
    这行MATLAB代码用于计算在范围1:69中不包含在Eph矩阵第30行的唯一值集合中的所有元素。具体解释如下：delsat=setdiff(1:69,unique(Eph(30,:)));解释Eph(30,:)Eph(30,:)提取矩阵Eph的第30行的所有列元素。这是一个行向量，包含了第30行的所有值。unique(Eph(30,:))unique函数返回Eph(30,:)中的唯一元素。这意味着
    
                    
    • 
                    
  • 【树一线性代数】005入门
                        Owlet_woodBird
算法
                        
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • Ubuntu18.04 Docker部署Kinship(Django)项目过程
                        Dante617

                        
    1Docker的安装https://blog.csdn.net/weixin_41735055/article/details/1003551792下载镜像dockerpullprogramize/python3.6.8-dlib下载的镜像里包含python3.6.8和dlib19.17.03启动镜像dockerrun-it--namekinship-p7777:80-p3307:3306-p55
    
                    
    • 
                                
  • html
                                    周华华
html
                                    
    js 
 1，数组的排列 
var arr=[1,4,234,43,52,]; 
 for(var x=0;x<arr.length;x++){ 
   for(var y=x-1;y<arr.length;y++){ 
     if(arr[x]<arr[y]){ 
    &
    
                                
    • 
                                
  • 【Struts2 四】Struts2拦截器
                                    bit1129
struts2拦截器
                                    
    Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。 
  
Struts2中自定义拦截器的步骤是：
    
                                
    • 
                                
  • make:cc 命令未找到解决方法
                                    daizj
linux命令未知make cc
                                    
    安装rz sz程序时，报下面错误： 
  
[root@slave2 src]# make posix 
cc   -O -DPOSIX -DMD=2 rz.c -o rz 
make: cc：命令未找到 
make: *** [posix] 错误 127 
  
系统：centos 6.6 
环境：虚拟机 
  
错误原因：系统未安装gcc，这个是由于在安
    
                                
    • 
                                
  • Oracle之Job应用
                                    周凡杨
oracle job
                                    
      
最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。 
  
一：查看相关job信息 
   1、相关视图  
 dba_jobs  
 all_jobs  
 user_jobs  
 dba_jobs_running 包含正在运行
    
                                
    • 
                                
  • 多线程机制
                                    朱辉辉33
多线程
                                    
    转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx 
程序、进程和线程： 
 程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（一）
                                    老A不折腾
web报表finereportjava报表报表工具
                                    
    FineReport使用中遇到的常见报错及解决办法（一） 
这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
  
1、address pool is full： 
含义：地址池满，连接数超过并发数上
    
                                
    • 
                                
  • mysql rpm安装后没有my.cnf
                                    林鹤霄
没有my.cnf
                                    
    Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的， 
至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法， 
第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动， 
第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
    
                                
    • 
                                
  • Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题
                                    aigo
root
                                    
    原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/ 
  
Step 4: Run ADB command from your PC 
  
On the PC, you need install Amazon Fire ADB driver and instal
    
                                
    • 
                                
  • javascript 中var提升的典型实例
                                    alxw4616
JavaScript
                                    
    // 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧
myname = 'global';
var fn = function () {
	console.log(myname); // undefined
	var myname = 'local';
	console.log(myname); // local
};
fn()

// 上述代码实际上等同于以下代码
m
    
                                
    • 
                                
  • 定时器和获取时间的使用
                                    百合不是茶
时间的转换定时器
                                    
    定时器:定时创建任务在游戏设计的时候用的比较多 
  Timer();定时器 
TImerTask();Timer的子类  由 Timer 安排为一次执行或重复执行的任务。 
  
  
  定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
    
                                
    • 
                                
  • JDK1.5 Queue
                                    bijian1013
javathreadjava多线程Queue
                                    
    JDK1.5 Queue 
LinkedList： 
LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
    
                                
    • 
                                
  • http认证原理和https
                                    bijian1013
httphttps
                                    
    一.基础介绍 
        在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。 
        Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。 
http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
    
                                
    • 
                                
  • 【Java范型五】范型继承
                                    bit1129
java
                                    
    定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2 
  
package com.tom.lang.generics;

public abstract class SuperGenerics<T1, T2> {
    private T1 t1;
    private T2 t2;

    public abstract void doIt(T
    
                                
    • 
                                
  • 【Nginx六】nginx.conf常用指令(Directive)
                                    bit1129
Directive
                                    
    1. worker_processes    8; 
表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行 
  
nobody    53879 118449  0 Apr22 ?        00:26:15 nginx: worker process          
    
                                
    • 
                                
  • lua 遍历Header头部
                                    ronin47
lua header 遍历　
                                    
     
 local headers = ngx.req.get_headers()   
 ngx.say("headers begin", "<br/>")   
 ngx.say("Host : ", he
    
                                
    • 
                                
  • java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。
                                    bylijinnan
java
                                    
    
import java.util.Arrays;

public class MinSumASumB {

	/**
	 * Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序.
	 * 
	 * 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。 
	 * 例如: 
	 * int[] a = {100,99,98,1,2,3
    
                                
    • 
                                
  • redis
                                    开窍的石头
redis
                                    
    在redis的redis.conf配置文件中找到# requirepass foobared 
把它替换成requirepass 12356789 后边的12356789就是你的密码 
 
打开redis客户端输入config get requirepass 
返回 
redis 127.0.0.1:6379> config get requirepass 
1) "require
    
                                
    • 
                                
  • [JAVA图像与图形]现有的GPU架构支持JAVA语言吗？
                                    comsci
java语言
                                    
     
 
      无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情 
 
 
       
    
                                
    • 
                                
  • 安装ubuntu14.04登录后花屏了怎么办
                                    cuiyadll
ubuntu
                                    
    这个情况，一般属于显卡驱动问题。 
可以先尝试安装显卡的官方闭源驱动。 
按键盘三个键：CTRL + ALT  +  F1 
进入终端，输入用户名和密码登录终端： 
安装amd的显卡驱动       
sudo  
apt-get  
install  
fglrx       
安装nvidia显卡驱动       
sudo  
ap
    
                                
    • 
                                
  • SSL 与 数字证书 的基本概念和工作原理
                                    darrenzhu
加密ssl证书密钥签名
                                    
    SSL 与 数字证书 的基本概念和工作原理 

http://www.linuxde.net/2012/03/8301.html 
 
SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。 
 
 
 

http://www.ibm.com/developerworks/cn/webspher
    
                                
    • 
                                
  • Ubuntu设置ip的步骤
                                    dcj3sjt126com
ubuntu
                                    
    在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。 
转载不是错： 
Ubuntu命令行修改网络配置方法 
/etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载. 
1. 以D
    
                                
    • 
                                
  • php包管理工具推荐
                                    dcj3sjt126com
PHPComposer
                                    
    http://www.phpcomposer.com/ 
       Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。  
中文文档  
入门指南  
下载  
安装包列表   
Composer 中国镜像      
    
                                
    • 
                                
  • Gson使用四（TypeAdapter）
                                    eksliang
jsongsonGson自定义转换器gsonTypeAdapter
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述 
       Gson的TypeAapter可以理解成自定义序列化和返序列化 二、应用场景举例 
       例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
    
                                
    • 
                                
  • JQM控件之Navbar和Tabs
                                    gundumw100
htmlxmlcss
                                    
    在JQM中使用导航栏Navbar是简单的。 
 
只需要将data-role="navbar"赋给div即可： 
 

<div data-role="navbar">
    <ul>
        <li><a href="#" class="ui-btn-active&qu
    
                                
    • 
                                
  • 利用归并排序算法对大文件进行排序
                                    iwindyforest
java归并排序大文件分治法Merge sort
                                    
      
归并排序算法介绍，请参照Wikipeida 
zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F 
基本思想： 
大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数 
低于限制行数的子文件直接排序 
两个排序好的子文件归并到父文件 
直到最后所有排序好的父文件归并到输入
    
                                
    • 
                                
  • iOS UIWebView URL拦截
                                    啸笑天
UIWebView
                                    
    本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
    
                                
    • 
                                
  • 索引的碎片整理SQL语句
                                    macroli
sql
                                    
    SET NOCOUNT ON
DECLARE @tablename VARCHAR (128)
DECLARE @execstr VARCHAR (255)
DECLARE @objectid INT
DECLARE @indexid INT
DECLARE @frag DECIMAL
DECLARE @maxfrag DECIMAL
--设置最大允许的碎片数量,超过则对索引进行碎片
    
                                
    • 
                                
  • Angularjs同步操作http请求with $promise
                                    qiaolevip
每天进步一点点学习永无止境AngularJS纵观千象
                                    
    // Define a factory
app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) {
      var deferred = $q.defer();
      AccountService.getProfile().then(function(res) {
  
    
                                
    • 
                                
  • hibernate联合查询问题
                                    sxj19881213
sqlHibernateHQL联合查询
                                    
    最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。 
针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2） 
  
1 几个常识： 
 （1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。 
 （2）hql的默认查询策略，在进行联合查询时，会产
    
                                
    • 
                                
  • struts2.xml
                                    wuai
struts
                                    
    <?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE struts PUBLIC 
 "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" 
 "http://struts.apache
    
                                
    •