大语言模型掘墓人
大语言模型掘墓人

C#，List＜T＞ 与 Vector＜T＞

List 是 C# 中最常用的动态数组实现，位于 System.Collections.Generic 命名空间。

Add(T)

将对象添加到 List的末尾。
AddRange(IEnumerable)

将指定集合的元素添加到 List的末尾。
AsReadOnly()

返回当前集合的只读 ReadOnlyCollection 包装器。
BinarySearch(Int32, Int32, T, IComparer)

使用指定的比较器在排序 List 中搜索元素的范围，并返回元素的从零开始的索引。
BinarySearch(T)

使用默认比较器搜索整个排序 List 元素，并返回元素的从零开始的索引。
BinarySearch(T, IComparer)

使用指定的比较器搜索整个排序 List 元素，并返回该元素的从零开始的索引。
Clear()

从 List中删除所有元素。
Contains(T)

确定元素是否在 List中。
ConvertAll(Converter)

将当前 List 中的元素转换为另一种类型，并返回包含转换后的元素的列表。
CopyTo(Int32, T[], Int32, Int32)

从 List 到兼容的一维数组（从目标数组的指定索引开始）复制一系列元素。
CopyTo(T[])

从目标数组的开头开始，将整个 List 复制到兼容的一维数组。
CopyTo(T[], Int32)

将整个 List 复制到兼容的一维数组，从目标数组的指定索引处开始。
EnsureCapacity(Int32)

确保此列表的容量至少为指定的 capacity。 如果当前容量小于 capacity，则它至少增加到指定的 capacity。
Equals(Object)

确定指定的对象是否等于当前对象。

(继承自 Object)
Exists(Predicate)

确定 List 是否包含与指定谓词定义的条件匹配的元素。
Find(Predicate)

搜索与指定谓词定义的条件匹配的元素，并返回整个 List中的第一个匹配项。
FindAll(Predicate)

检索与指定谓词定义的条件匹配的所有元素。
FindIndex(Int32, Int32, Predicate)

搜索与指定谓词定义的条件匹配的元素，并返回从指定索引开始且包含指定数量的元素的 List 中第一个匹配项的从零开始的索引。
FindIndex(Int32, Predicate)

搜索与指定谓词定义的条件匹配的元素，并在从指定索引扩展到最后一个元素的 List 元素范围内返回第一个匹配项的从零开始的索引。
FindIndex(Predicate)

搜索与指定谓词定义的条件匹配的元素，并返回整个 List中第一个匹配项的从零开始的索引。
FindLast(Predicate)

搜索与指定谓词定义的条件匹配的元素，并返回整个 List中的最后一个匹配项。
FindLastIndex(Int32, Int32, Predicate)

搜索与指定谓词定义的条件匹配的元素，并返回 List 中最后一个匹配项的从零开始的索引，该索引包含指定数量的元素并在指定索引处结束。
FindLastIndex(Int32, Predicate)

搜索与指定谓词定义的条件匹配的元素，并返回从第一个元素扩展到指定索引的 List 中最后一个匹配项的从零开始的索引。
FindLastIndex(Predicate)

搜索与指定谓词定义的条件匹配的元素，并返回整个 List中最后一个匹配项的从零开始的索引。
ForEach(Action)

对 List的每个元素执行指定的操作。
GetEnumerator()

返回循环访问 List的枚举数。
GetHashCode()

用作默认哈希函数。

(继承自 Object)
GetRange(Int32, Int32)

在源 List中创建一系列元素的浅表副本。
GetType()

获取当前实例的 Type。

(继承自 Object)
IndexOf(T)

搜索指定的对象，并返回整个 List中第一个匹配项的从零开始的索引。
IndexOf(T, Int32)

搜索指定的对象，并返回从指定索引扩展到最后一个元素的 List 中第一个匹配项的从零开始的索引。
IndexOf(T, Int32, Int32)

搜索指定的对象，并返回从指定索引开始且包含指定数量的元素的 List 中第一个匹配项的从零开始的索引。
Insert(Int32, T)

将元素插入指定索引处的 List。
InsertRange(Int32, IEnumerable)

将集合的元素插入到指定索引处的 List 中。
LastIndexOf(T)

搜索指定的对象，并返回整个 List中最后一个匹配项的从零开始的索引。
LastIndexOf(T, Int32)

搜索指定的对象，并返回从第一个元素扩展到指定索引的 List 中最后一个匹配项的从零开始的索引。
LastIndexOf(T, Int32, Int32)

搜索指定的对象，并返回 List 中包含指定数量的元素并在指定索引处结束的最后一个匹配项的从零开始的索引。
MemberwiseClone()

创建当前 Object的浅表副本。

(继承自 Object)
Remove(T)

从 List中删除特定对象的第一个匹配项。
RemoveAll(Predicate)

删除与指定谓词定义的条件匹配的所有元素。
RemoveAt(Int32)

移除 List的指定索引处的元素。
RemoveRange(Int32, Int32)

从 List中删除一系列元素。
Reverse()

反转整个 List中的元素的顺序。
Reverse(Int32, Int32)

反转指定区域中元素的顺序。
Slice(Int32, Int32)

在源 List中创建一系列元素的浅表副本。
Sort()

使用默认比较器对整个 List 中的元素进行排序。
Sort(Comparison)

使用指定的 Comparison对整个 List 中的元素进行排序。
Sort(IComparer)

使用指定的比较器对整个 List 中的元素进行排序。
Sort(Int32, Int32, IComparer)

使用指定的比较器对 List 中一系列元素中的元素进行排序。
ToArray()

将 List 的元素复制到新数组。
ToString()

返回一个表示当前对象的字符串。

(继承自 Object)
TrimExcess()

将容量设置为 List中实际元素数（如果该数字小于阈值）。
TrueForAll(Predicate)

确定 List 中的每个元素是否与指定谓词定义的条件匹配。

ICollection.CopyTo(Array, Int32)

从特定 Array 索引开始，将 ICollection 的元素复制到 Array。
ICollection.IsSynchronized

获取一个值，该值指示是否同步对 ICollection 的访问（线程安全）。
ICollection.SyncRoot

获取可用于同步对 ICollection的访问的对象。
ICollection.IsReadOnly

获取一个值，该值指示 ICollection 是否为只读。
IEnumerable.GetEnumerator()

返回循环访问集合的枚举器。
IEnumerable.GetEnumerator()

返回循环访问集合的枚举器。
IList.Add(Object)

将项添加到 IList。
IList.Contains(Object)

确定 IList 是否包含特定值。
IList.IndexOf(Object)

确定 IList中特定项的索引。
IList.Insert(Int32, Object)

将项插入到指定索引处的 IList。
IList.IsFixedSize

获取一个值，该值指示 IList 是否具有固定大小。
IList.IsReadOnly

获取一个值，该值指示 IList 是否为只读。
IList.Item[Int32]

获取或设置指定索引处的元素。
IList.Remove(Object)

从 IList中删除特定对象的第一个匹配项。

ToFrozenDictionary(IEnumerable, Func, IEqualityComparer)

根据指定的键选择器函数从 IEnumerable 创建 FrozenDictionary。
ToFrozenDictionary(IEnumerable, Func, Func, IEqualityComparer)

根据指定的键选择器和元素选择器函数从 IEnumerable 创建 FrozenDictionary。
ToFrozenSet(IEnumerable, IEqualityComparer)

创建具有指定值的 FrozenSet。
AddRange(List, ReadOnlySpan)

将指定范围的元素添加到 List的末尾。
AsReadOnly(IList)

返回指定列表的只读 ReadOnlyCollection 包装器。
CopyTo(List, Span)

将整个 List 复制到范围。
InsertRange(List, Int32, ReadOnlySpan)

将跨度的元素插入到指定索引处的 List 中。
ToImmutableArray(IEnumerable)

从指定的集合创建不可变数组。
ToImmutableDictionary(IEnumerable, Func)

从现有元素集合构造不可变字典，将转换函数应用于源键。
ToImmutableDictionary(IEnumerable, Func, IEqualityComparer)

基于序列的某些转换构造不可变字典。
ToImmutableDictionary(IEnumerable, Func, Func)

枚举和转换序列，并生成其内容的不可变字典。
ToImmutableDictionary(IEnumerable, Func, Func, IEqualityComparer)

枚举和转换序列，并使用指定的键比较器生成其内容的不可变字典。
ToImmutableDictionary(IEnumerable, Func, Func, IEqualityComparer, IEqualityComparer)

枚举和转换序列，并使用指定的键和值比较器生成其内容的不可变字典。
ToImmutableHashSet(IEnumerable)

枚举序列并生成其内容的不可变哈希集。
ToImmutableHashSet(IEnumerable, IEqualityComparer)

枚举序列，生成其内容的不可变哈希集，并为集类型使用指定的相等比较器。
ToImmutableList(IEnumerable)

枚举序列并生成其内容的不可变列表。
ToImmutableSortedDictionary(IEnumerable, Func, Func)

枚举和转换序列，并生成其内容的不可变排序字典。
ToImmutableSortedDictionary(IEnumerable, Func, Func, IComparer)

枚举和转换序列，并使用指定的键比较器生成其内容的不可变排序字典。
ToImmutableSortedDictionary(IEnumerable, Func, Func, IComparer, IEqualityComparer)

枚举和转换序列，并使用指定的键和值比较器生成其内容的不可变排序字典。
ToImmutableSortedSet(IEnumerable)

枚举序列并生成其内容的不可变排序集。
ToImmutableSortedSet(IEnumerable, IComparer)

枚举序列，生成其内容的不可变排序集，并使用指定的比较器。
CopyToDataTable(IEnumerable)

返回一个包含 DataRow 对象副本的 DataTable，给定 IEnumerable 对象的输入 IEnumerable 对象，其中泛型参数 TDataRow。
CopyToDataTable(IEnumerable, DataTable, LoadOption)

给定泛型参数 TDataRow的输入 IEnumerable 对象，将 DataRow 对象复制到指定的 DataTable。
CopyToDataTable(IEnumerable, DataTable, LoadOption, FillErrorEventHandler)

给定泛型参数 TDataRow的输入 IEnumerable 对象，将 DataRow 对象复制到指定的 DataTable。
Aggregate(IEnumerable, Func)

对序列应用累加器函数。
Aggregate(IEnumerable, TAccumulate, Func)

对序列应用累加器函数。 指定的种子值用作初始累加器值。
Aggregate(IEnumerable, TAccumulate, Func, Func)

对序列应用累加器函数。 指定的种子值用作初始累加器值，并且指定函数用于选择结果值。
AggregateBy(IEnumerable, Func, TAccumulate, Func, IEqualityComparer)

表示可由索引访问的强类型对象列表。 提供用于搜索、排序和操作列表的方法。
AggregateBy(IEnumerable, Func, Func, Func, IEqualityComparer)

表示可由索引访问的强类型对象列表。 提供用于搜索、排序和操作列表的方法。
All(IEnumerable, Func)

确定序列的所有元素是否满足条件。
Any(IEnumerable)

确定序列是否包含任何元素。
Any(IEnumerable, Func)

确定序列的任何元素是否满足条件。
Append(IEnumerable, TSource)

将值追加到序列的末尾。
AsEnumerable(IEnumerable)

返回类型化为 IEnumerable的输入。
Average(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Decimal 值的序列的平均值。
Average(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Double 值的序列的平均值。
Average(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Int32 值的序列的平均值。
Average(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Int64 值的序列的平均值。
Average(IEnumerable, Func>)

计算一系列可为 null 的 Decimal 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average(IEnumerable, Func>)

计算一系列可为 null 的 Double 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average(IEnumerable, Func>)

计算一系列可为 null 的 Int32 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average(IEnumerable, Func>)

计算一系列可为 null 的 Int64 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average(IEnumerable, Func>)

计算一系列可为 null 的 Single 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Single 值的序列的平均值。
Cast(IEnumerable)

将 IEnumerable 的元素强制转换为指定类型。
Chunk(IEnumerable, Int32)

将序列的元素拆分为大小块，最多 size。
Concat(IEnumerable, IEnumerable)

连接两个序列。
Contains(IEnumerable, TSource)

使用默认相等比较器确定序列是否包含指定的元素。
Contains(IEnumerable, TSource, IEqualityComparer)

确定序列是否使用指定的 IEqualityComparer包含指定的元素。
Count(IEnumerable)

返回序列中的元素数。
Count(IEnumerable, Func)

返回一个数字，该值代表指定序列中满足条件的元素数。
CountBy(IEnumerable, Func, IEqualityComparer)

表示可由索引访问的强类型对象列表。 提供用于搜索、排序和操作列表的方法。
DefaultIfEmpty(IEnumerable)

如果序列为空，则返回指定序列的元素或类型参数在单一实例集合中的默认值。
DefaultIfEmpty(IEnumerable, TSource)

如果序列为空，则返回指定序列的元素或单个实例集合中的指定值。
Distinct(IEnumerable)

通过使用默认相等比较器比较值，从序列中返回不同的元素。
Distinct(IEnumerable, IEqualityComparer)

通过使用指定的 IEqualityComparer 来比较值，从序列中返回不同的元素。
DistinctBy(IEnumerable, Func)

根据指定的键选择器函数返回序列中的不同元素。
DistinctBy(IEnumerable, Func, IEqualityComparer)

根据指定的键选择器函数并使用指定的比较器比较键，从序列中返回不同的元素。
ElementAt(IEnumerable, Index)

返回序列中指定索引处的元素。
ElementAt(IEnumerable, Int32)

返回序列中指定索引处的元素。
ElementAtOrDefault(IEnumerable, Index)

返回序列中指定索引处的元素;如果索引范围不足，则返回默认值。
ElementAtOrDefault(IEnumerable, Int32)

返回序列中指定索引处的元素;如果索引范围不足，则返回默认值。
Except(IEnumerable, IEnumerable)

使用默认相等比较器来比较值，生成两个序列的集差。
Except(IEnumerable, IEnumerable, IEqualityComparer)

通过使用指定的 IEqualityComparer 来比较值，生成两个序列的集差异。
ExceptBy(IEnumerable, IEnumerable, Func)

根据指定的键选择器函数生成两个序列的集差异。
ExceptBy(IEnumerable, IEnumerable, Func, IEqualityComparer)

根据指定的键选择器函数生成两个序列的集差异。
First(IEnumerable)

返回序列的第一个元素。
First(IEnumerable, Func)

返回满足指定条件的序列中的第一个元素。
FirstOrDefault(IEnumerable)

返回序列的第一个元素;如果序列不包含任何元素，则返回默认值。
FirstOrDefault(IEnumerable, TSource)

返回序列的第一个元素;如果序列不包含任何元素，则返回指定的默认值。
FirstOrDefault(IEnumerable, Func)

返回满足条件的序列的第一个元素;如果未找到此类元素，则返回默认值。
FirstOrDefault(IEnumerable, Func, TSource)

返回满足条件的序列的第一个元素;如果未找到此类元素，则返回指定的默认值。
GroupBy(IEnumerable, Func)

根据指定的键选择器函数对序列的元素进行分组。
GroupBy(IEnumerable, Func, IEqualityComparer)

根据指定的键选择器函数对序列的元素进行分组，并使用指定的比较器比较键。
GroupBy(IEnumerable, Func, Func)

根据指定的键选择器函数对序列的元素进行分组，并使用指定的函数投影每个组的元素。
GroupBy(IEnumerable, Func, Func, IEqualityComparer)

根据键选择器函数对序列的元素进行分组。 通过使用比较器比较键，并且每个组的元素都通过使用指定的函数进行投影。
GroupBy(IEnumerable, Func, Func,TResult>)

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。
GroupBy(IEnumerable, Func, Func,TResult>, IEqualityComparer)

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。 使用指定的比较器比较键。
GroupBy(IEnumerable, Func, Func, Func,TResult>)

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。 每个组的元素是使用指定的函数投影的。
GroupBy(IEnumerable, Func, Func, Func, TResult>, IEqualityComparer)

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。 使用指定的比较器比较键值，并且每个组的元素都通过使用指定的函数进行投影。
GroupJoin(IEnumerable, IEnumerable, Func, Func, Func, TResult>)

根据键的相等性关联两个序列的元素，并对结果进行分组。 默认相等比较器用于比较键。
GroupJoin(IEnumerable, IEnumerable, Func, Func, Func, TResult>, IEqualityComparer)

根据键相等性关联两个序列的元素，并对结果进行分组。 指定的 IEqualityComparer 用于比较键。
Index(IEnumerable)

返回一个可枚举值，该枚举将元素的索引合并到元组中。
Intersect(IEnumerable, IEnumerable)

通过使用默认相等比较器来比较值，生成两个序列的集交集。
Intersect(IEnumerable, IEnumerable, IEqualityComparer)

通过使用指定的 IEqualityComparer 来比较值，生成两个序列的集交集。
IntersectBy(IEnumerable, IEnumerable, Func)

根据指定的键选择器函数生成两个序列的集交集。
IntersectBy(IEnumerable, IEnumerable, Func, IEqualityComparer)

根据指定的键选择器函数生成两个序列的集交集。
Join(IEnumerable, IEnumerable, Func, Func, Func)

根据匹配键关联两个序列的元素。 默认相等比较器用于比较键。
Join(IEnumerable, IEnumerable, Func, Func, Func, IEqualityComparer)

根据匹配键关联两个序列的元素。 指定的 IEqualityComparer 用于比较键。
Last(IEnumerable)

返回序列的最后一个元素。
Last(IEnumerable, Func)

返回满足指定条件的序列的最后一个元素。
LastOrDefault(IEnumerable)

返回序列的最后一个元素;如果序列不包含任何元素，则返回默认值。
LastOrDefault(IEnumerable, TSource)

返回序列的最后一个元素;如果序列不包含任何元素，则返回指定的默认值。
LastOrDefault(IEnumerable, Func)

返回满足条件的序列的最后一个元素;如果未找到此类元素，则返回默认值。
LastOrDefault(IEnumerable, Func, TSource)

返回满足条件的序列的最后一个元素;如果未找到此类元素，则返回指定的默认值。
LongCount(IEnumerable)

返回一个表示序列中元素总数的 Int64。
LongCount(IEnumerable, Func)

返回表示序列中满足条件的元素数的 Int64。
Max(IEnumerable)

返回泛型序列中的最大值。
Max(IEnumerable, IComparer)

返回泛型序列中的最大值。
Max(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最大 Decimal 值。
Max(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最大 Double 值。
Max(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最大 Int32 值。
Max(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最大 Int64 值。
Max(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回最大可为 null Decimal 值。
Max(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回最大可为 null Double 值。
Max(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回最大可为 null Int32 值。
Max(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回最大可为 null Int64 值。
Max(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回最大可为 null Single 值。
Max(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最大 Single 值。
Max(IEnumerable, Func)

对泛型序列的每个元素调用转换函数，并返回得到的最大值。
MaxBy(IEnumerable, Func)

根据指定的键选择器函数返回泛型序列中的最大值。
MaxBy(IEnumerable, Func, IComparer)

根据指定的键选择器函数和键比较器返回泛型序列中的最大值。
Min(IEnumerable)

返回泛型序列中的最小值。
Min(IEnumerable, IComparer)

返回泛型序列中的最小值。
Min(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最小 Decimal 值。
Min(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最小 Double 值。
Min(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最小 Int32 值。
Min(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最小 Int64 值。
Min(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Decimal 值。
Min(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Double 值。
Min(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Int32 值。
Min(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Int64 值。
Min(IEnumerable, Func>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Single 值。
Min(IEnumerable, Func)

对序列的每个元素调用转换函数，并返回最小 Single 值。
Min(IEnumerable, Func)

对泛型序列的每个元素调用转换函数，并返回生成的最小值。
MinBy(IEnumerable, Func)

根据指定的键选择器函数返回泛型序列中的最小值。
MinBy(IEnumerable, Func, IComparer)

根据指定的键选择器函数和键比较器返回泛型序列中的最小值。
OfType(IEnumerable)

根据指定类型筛选 IEnumerable 的元素。
Order(IEnumerable)

按升序对序列的元素进行排序。
Order(IEnumerable, IComparer)

按升序对序列的元素进行排序。
OrderBy(IEnumerable, Func)

根据键按升序对序列的元素进行排序。
OrderBy(IEnumerable, Func, IComparer)

使用指定的比较器按升序对序列的元素进行排序。
OrderByDescending(IEnumerable, Func)

根据键按降序对序列的元素进行排序。
OrderByDescending(IEnumerable, Func, IComparer)

使用指定的比较器按降序对序列的元素进行排序。
OrderDescending(IEnumerable)

按降序对序列的元素进行排序。
OrderDescending(IEnumerable, IComparer)

按降序对序列的元素进行排序。
Prepend(IEnumerable, TSource)

将值添加到序列的开头。
Reverse(IEnumerable)

反转序列中元素的顺序。
Select(IEnumerable, Func)

将序列的每个元素投影到一个新窗体中。
Select(IEnumerable, Func)

通过合并元素的索引，将序列的每个元素投影到一个新窗体中。
SelectMany(IEnumerable, Func>)

将序列的每个元素投影到 IEnumerable，并将生成的序列平展为一个序列。
SelectMany(IEnumerable, Func>)

将序列的每个元素投影到 IEnumerable，并将生成的序列平展为一个序列。 每个源元素的索引用于该元素的投影形式。
SelectMany(IEnumerable, Func>, Func)

将序列的每个元素投影到 IEnumerable，将生成的序列平展为一个序列，并在其中的每个元素上调用结果选择器函数。
SelectMany(IEnumerable, Func>, Func)

将序列的每个元素投影到 IEnumerable，将生成的序列平展为一个序列，并在其中的每个元素上调用结果选择器函数。 每个源元素的索引用于该元素的中间投影形式。
SequenceEqual(IEnumerable, IEnumerable)

通过使用其类型的默认相等比较器，确定两个序列是否相等。
SequenceEqual(IEnumerable, IEnumerable, IEqualityComparer)

通过使用指定的 IEqualityComparer，确定两个序列是否相等。
Single(IEnumerable)

返回序列的唯一元素，如果序列中没有完全有一个元素，则会引发异常。
Single(IEnumerable, Func)

返回满足指定条件的序列的唯一元素，如果存在多个此类元素，则会引发异常。
SingleOrDefault(IEnumerable)

返回序列的唯一元素;如果序列为空，则返回默认值;如果序列中有多个元素，此方法将引发异常。
SingleOrDefault(IEnumerable, TSource)

返回序列的唯一元素;如果序列为空，则返回指定的默认值;如果序列中有多个元素，此方法将引发异常。
SingleOrDefault(IEnumerable, Func)

返回满足指定条件的序列的唯一元素;如果没有此类元素，则返回默认值;如果多个元素满足条件，此方法将引发异常。
SingleOrDefault(IEnumerable, Func, TSource)

返回满足指定条件的序列的唯一元素;如果没有此类元素，则返回指定的默认值;如果多个元素满足条件，此方法将引发异常。
Skip(IEnumerable, Int32)

绕过序列中的指定数量的元素，然后返回其余元素。
SkipLast(IEnumerable, Int32)

返回一个新的可枚举集合，该集合包含 source 的元素，其中省略了源集合的最后一个 count 元素。
SkipWhile(IEnumerable, Func)

只要指定条件为 true，即可绕过序列中的元素，然后返回其余元素。
SkipWhile(IEnumerable, Func)

只要指定条件为 true，即可绕过序列中的元素，然后返回其余元素。 元素的索引用于谓词函数的逻辑。
Sum(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Decimal 值序列的总和。
Sum(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Double 值序列的总和。
Sum(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Int32 值序列的总和。
Sum(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Int64 值序列的总和。
Sum(IEnumerable, Func>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Decimal 值的序列的总和。
Sum(IEnumerable, Func>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Double 值的序列的总和。
Sum(IEnumerable, Func>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Int32 值的序列的总和。
Sum(IEnumerable, Func>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Int64 值的序列的总和。
Sum(IEnumerable, Func>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Single 值的序列的总和。
Sum(IEnumerable, Func)

计算通过对输入序列的每个元素调用转换函数获得的 Single 值序列的总和。
Take(IEnumerable, Int32)

从序列的开头返回指定的连续元素数。
Take(IEnumerable, Range)

返回序列中连续元素的指定范围。
TakeLast(IEnumerable, Int32)

返回一个新的可枚举集合，该集合包含来自 source的最后一个 count 元素。
TakeWhile(IEnumerable, Func)

只要指定的条件为 true，就从序列中返回元素。
TakeWhile(IEnumerable, Func)

只要指定的条件为 true，就从序列中返回元素。 元素的索引用于谓词函数的逻辑。
ToArray(IEnumerable)

从 IEnumerable创建数组。
ToDictionary(IEnumerable, Func)

根据指定的键选择器函数从 IEnumerable 创建 Dictionary。
ToDictionary(IEnumerable, Func, IEqualityComparer)

根据指定的键选择器函数和键比较器从 IEnumerable 创建 Dictionary。
ToDictionary(IEnumerable, Func, Func)

根据指定的键选择器和元素选择器函数从 IEnumerable 创建 Dictionary。
ToDictionary(IEnumerable, Func, Func, IEqualityComparer)

根据指定的键选择器函数、比较器和元素选择器函数从 IEnumerable 创建 Dictionary。
ToHashSet(IEnumerable)

从 IEnumerable创建 HashSet。
ToHashSet(IEnumerable, IEqualityComparer)

使用 comparer 比较键从 IEnumerable 创建 HashSet。
ToList(IEnumerable)

从 IEnumerable创建 List。
ToLookup(IEnumerable, Func)

根据指定的键选择器函数从 IEnumerable 创建 Lookup。
ToLookup(IEnumerable, Func, IEqualityComparer)

根据指定的键选择器函数和键比较器从 IEnumerable 创建 Lookup。
ToLookup(IEnumerable, Func, Func)

根据指定的键选择器和元素选择器函数从 IEnumerable 创建 Lookup。
ToLookup(IEnumerable, Func, Func, IEqualityComparer)

根据指定的键选择器函数、比较器和元素选择器函数从 IEnumerable 创建 Lookup。
TryGetNonEnumeratedCount(IEnumerable, Int32)

尝试在不强制枚举的情况下确定序列中的元素数。
Union(IEnumerable, IEnumerable)

使用默认相等比较器生成两个序列的集并集。
Union(IEnumerable, IEnumerable, IEqualityComparer)

使用指定的 IEqualityComparer生成两个序列的集并集。
UnionBy(IEnumerable, IEnumerable, Func)

根据指定的键选择器函数生成两个序列的集并集。
UnionBy(IEnumerable, IEnumerable, Func, IEqualityComparer)

根据指定的键选择器函数生成两个序列的集并集。
Where(IEnumerable, Func)

根据谓词筛选值序列。
Where(IEnumerable, Func)

根据谓词筛选值序列。 每个元素的索引都在谓词函数的逻辑中使用。
Zip(IEnumerable, IEnumerable)

生成包含两个指定序列中的元素的元组序列。
Zip(IEnumerable, IEnumerable, IEnumerable)

生成包含三个指定序列中的元素的元组序列。
Zip(IEnumerable, IEnumerable, Func)

将指定的函数应用于两个序列的相应元素，从而生成结果序列。
AsParallel(IEnumerable)

启用查询的并行化。
AsParallel(IEnumerable)

启用查询的并行化。
AsQueryable(IEnumerable)

将 IEnumerable 转换为 IQueryable。
AsQueryable(IEnumerable)

将泛型 IEnumerable 转换为泛型 IQueryable。
Ancestors(IEnumerable)

返回一个元素集合，其中包含源集合中每个节点的上级。
Ancestors(IEnumerable, XName)

返回一个筛选的元素集合，其中包含源集合中每个节点的上级。 集合中仅包含具有匹配 XName 的元素。
DescendantNodes(IEnumerable)

返回源集合中每个文档和元素的子代节点的集合。
Descendants(IEnumerable)

返回一个元素集合，其中包含源集合中每个元素和文档的子代元素。
Descendants(IEnumerable, XName)

返回一个筛选的元素集合，其中包含源集合中每个元素和文档的子代元素。 集合中仅包含具有匹配 XName 的元素。
Elements(IEnumerable)

返回源集合中每个元素和文档的子元素的集合。
Elements(IEnumerable, XName)

返回源集合中每个元素和文档的子元素的筛选集合。 集合中仅包含具有匹配 XName 的元素。
InDocumentOrder(IEnumerable)

返回一个节点集合，其中包含源集合中的所有节点，按文档顺序排序。
Nodes(IEnumerable)

返回源集合中每个文档和元素的子节点的集合。
Remove(IEnumerable)

从源集合的父节点中删除每个节点。


在 C# 中，Vector 是 System.Numerics 命名空间下的 SIMD (单指令多数据) 向量类型。

Abs(Vector)

返回一个新向量，其元素是给定向量元素的绝对值。
Add(Vector, Vector)

返回一个新向量，其值是两个给定向量中每对元素的总和。
AndNot(Vector, Vector)

通过对两个向量中的每个对应元素对执行按位且不运算来返回一个新向量。
As(Vector)

将 Vector 重新解释为新的 Vector。
AsPlane(Vector4)

将 Vector4 重新解释为新的 Plane。
AsQuaternion(Vector4)

将 Vector4 重新解释为新的 Quaternion。
AsVector2(Vector4)

将 Vector4 重新解释为新的 Vector2。
AsVector3(Vector4)

将 Vector4 重新解释为新的 Vector3。
AsVector4(Plane)

将 Plane 重新解释为新的 Vector4。
AsVector4(Quaternion)

将 Quaternion 重新解释为新的 Vector4。
AsVector4(Vector2)

使用零零的新元素重新解释对新 Vector4 的 Vector2。
AsVector4(Vector3)

将 Vector3 转换为具有零新元素的新 Vector4。
AsVector4Unsafe(Vector2)

使用未定义的新元素重新解释对新 Vector4 的 Vector2。
AsVector4Unsafe(Vector3)

使用未定义的新元素将 Vector3 转换为新的 Vector4。
AsVectorByte(Vector)

将指定向量的位重新解释为无符号字节矢量的位。
AsVectorDouble(Vector)

将指定向量的位重新解释为双精度浮点向量。
AsVectorInt16(Vector)

将指定向量的位重新解释为 16 位整数的向量。
AsVectorInt32(Vector)

将指定向量的位重新解释为整数向量。
AsVectorInt64(Vector)

将指定向量的位重新解释为长整数向量中的位。
AsVectorNInt(Vector)

将指定向量的位重新解释为本机大小的整数矢量的位。
AsVectorNUInt(Vector)

将指定向量的位重新解释为本机大小的无符号整数矢量的位。
AsVectorSByte(Vector)

将指定向量的位重新解释为带符号字节矢量的位。
AsVectorSingle(Vector)

将指定向量的位重新解释为单精度浮点向量。
AsVectorUInt16(Vector)

将指定向量的位重新解释为无符号 16 位整数的向量。
AsVectorUInt32(Vector)

将指定向量的位重新解释为无符号整数矢量的位。
AsVectorUInt64(Vector)

将指定向量的位重新解释为无符号长整数矢量的位。
BitwiseAnd(Vector, Vector)

通过对两个向量中的每个元素对执行按位 And 运算来返回新向量。
BitwiseOr(Vector, Vector)

通过对两个向量中的每个元素对执行按位 Or 运算来返回新向量。
Ceiling(Vector)

返回一个新向量，其元素是大于或等于给定向量元素的最小整型值。
Ceiling(Vector)

返回一个新向量，其元素是大于或等于给定向量元素的最小整型值。
Clamp(Vector, Vector, Vector)

限制最小值和最大值之间的向量。
ClampNative(Vector, Vector, Vector)

使用 NaN 和 NegativeZero.的平台特定行为限制最小值和最大值之间的向量。
ConditionalSelect(Vector, Vector, Vector)

创建一个新的单精度向量，其中包含基于整型掩码向量在两个指定单精度源向量之间进行选择的元素。
ConditionalSelect(Vector, Vector, Vector)

创建一个新的双精度向量，其中包含基于整型掩码向量在两个指定的双精度源向量之间选择的元素。
ConditionalSelect(Vector, Vector, Vector)

创建指定类型的新向量，其中基于整型掩码向量在相同类型的两个指定源向量之间选择的元素。
ConvertToDouble(Vector)

将 Vector 转换为 Vector。
ConvertToDouble(Vector)

将 Vector 转换为 Vector。
ConvertToInt32(Vector)

将 Vector 转换为 Vector。
ConvertToInt32Native(Vector)

使用特定于平台的行为在溢出时将 Vector 转换为 Vector。
ConvertToInt64(Vector)

将 Vector 转换为 Vector。
ConvertToInt64Native(Vector)

使用特定于平台的行为在溢出时将 System.Numerics.Vector 转换为 System.Numerics.Vector。
ConvertToSingle(Vector)

将 Vector 转换为 Vector。
ConvertToSingle(Vector)

将 Vector 转换为 Vector。
ConvertToUInt32(Vector)

将 Vector 转换为 Vector。
ConvertToUInt32Native(Vector)

使用特定于平台的行为在溢出时将 System.Numerics.Vector 转换为 System.Numerics.Vector。
ConvertToUInt64(Vector)

将 Vector 转换为 Vector。
ConvertToUInt64Native(Vector)

使用特定于平台的行为在溢出时将 System.Numerics.Vector 转换为 System.Numerics.Vector。
CopySign(Vector, Vector)

将向量的 per-element 符号复制到另一个向量的 per-element 符号。
Cos(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Cos(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Create(ReadOnlySpan)

从给定的只读范围创建新的 Vector。
Create(T)

创建一个新的 Vector 实例，其中包含初始化为指定值的所有元素。
CreateSequence(T, T)

创建一个新的 Vector 实例，其中元素从指定值开始，并按另一个指定值分隔。
DegreesToRadians(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
DegreesToRadians(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Divide(Vector, T)

将矢量除以标量以计算每个元素商。
Divide(Vector, Vector)

返回一个新向量，其值是将第一个向量元素除以第二个向量中的相应元素的结果。
Dot(Vector, Vector)

返回两个向量的点积。
Equals(Vector, Vector)

返回一个新的整型向量，其元素指示两个指定双精度向量中的元素是否相等。
Equals(Vector, Vector)

返回一个新的整型向量，其元素指示两个指定整型向量中的元素是否相等。
Equals(Vector, Vector)

返回一个新向量，其元素指示两个指定长整数向量中的元素是否相等。
Equals(Vector, Vector)

返回一个新的整型向量，其元素指示两个指定单精度向量中的元素是否相等。
Equals(Vector, Vector)

返回指定类型的新向量，其元素指示同一类型的两个指定向量中的元素是否相等。
EqualsAll(Vector, Vector)

返回一个值，该值指示给定向量中的每个元素对是否相等。
EqualsAny(Vector, Vector)

返回一个值，该值指示给定向量中的任何一对元素是否相等。
Exp(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Exp(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Floor(Vector)

返回一个新向量，其元素是小于或等于给定向量元素的最大整型值。
Floor(Vector)

返回一个新向量，其元素是小于或等于给定向量元素的最大整型值。
FusedMultiplyAdd(Vector, Vector, Vector)

计算 （left * right） + addend，舍入为一个三元运算。
FusedMultiplyAdd(Vector, Vector, Vector)

计算 （left * right） + addend，舍入为一个三元运算。
GetElement(Vector, Int32)

获取指定索引处的元素。
GreaterThan(Vector, Vector)

返回一个新的整型向量，其元素指示一个双精度浮点向量中的元素是否大于第二个双精度浮点向量中的相应元素。
GreaterThan(Vector, Vector)

返回一个新的整型向量，其元素指示一个整型向量中的元素是否大于第二个整型向量中的相应元素。
GreaterThan(Vector, Vector)

返回一个新的长整数向量，其元素指示一个长整数向量中的元素是否大于第二个长整数向量中的相应元素。
GreaterThan(Vector, Vector)

返回一个新的整型向量，其元素指示一个单精度浮点向量中的元素是否大于第二个单精度浮点向量中的相应元素。
GreaterThan(Vector, Vector)

返回一个新向量，其元素指示指定类型的一个向量中的元素是否大于同一时间第二个向量中的相应元素。
GreaterThanAll(Vector, Vector)

返回一个值，该值指示第一个向量中的所有元素是否大于第二个向量中的相应元素。
GreaterThanAny(Vector, Vector)

返回一个值，该值指示第一个向量中的任何元素是否大于第二个向量中的相应元素。
GreaterThanOrEqual(Vector, Vector)

返回一个新的整型向量，其元素指示一个向量中的元素是否大于或等于第二个双精度浮点向量中的相应元素。
GreaterThanOrEqual(Vector, Vector)

返回一个新的整型向量，其元素指示一个整型向量的元素是否大于或等于第二个整型向量中的相应元素。
GreaterThanOrEqual(Vector, Vector)

返回一个新的长整数向量，其元素指示一个长整数向量中的元素是否大于或等于其第二个长整数向量中的相应元素。
GreaterThanOrEqual(Vector, Vector)

返回一个新的整型向量，其元素指示一个向量中的元素是否大于或等于其单精度浮点第二向量中的相应元素。
GreaterThanOrEqual(Vector, Vector)

返回一个新向量，其元素指示指定类型的一个向量中的元素是否大于或等于同一类型的第二个向量中的相应元素。
GreaterThanOrEqualAll(Vector, Vector)

返回一个值，该值指示第一个向量中的所有元素是否大于或等于第二个向量中的所有相应元素。
GreaterThanOrEqualAny(Vector, Vector)

返回一个值，该值指示第一个向量中的任何元素是否大于或等于第二个向量中的相应元素。
Hypot(Vector, Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Hypot(Vector, Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
IsNaN(Vector)

确定向量中的哪些元素为 NaN。
IsNegative(Vector)

确定向量中的哪些元素表示负实数。
IsPositive(Vector)

确定向量中的哪些元素表示正实数。
IsPositiveInfinity(Vector)

确定向量中的哪些元素是正无穷大。
IsZero(Vector)

确定向量中的哪些元素为零。
Lerp(Vector, Vector, Vector)

根据给定权重在两个向量之间执行线性内插。
Lerp(Vector, Vector, Vector)

根据给定权重在两个向量之间执行线性内插。
LessThan(Vector, Vector)

返回一个新的整型向量，其元素指示一个双精度浮点向量中的元素是否小于第二个双精度浮点向量中的相应元素。
LessThan(Vector, Vector)

返回一个新的整型向量，其元素指示一个整型向量中的元素是否小于第二整型向量中的相应元素。
LessThan(Vector, Vector)

返回一个新的长整数向量，其元素指示一个长整数向量中的元素是否小于第二个长整数向量中的相应元素。
LessThan(Vector, Vector)

返回一个新的整型向量，其元素指示一个单精度向量中的元素是否小于第二个单精度向量中的相应元素。
LessThan(Vector, Vector)

返回指定类型的新向量向量，其元素指示一个向量中的元素是否小于第二个向量中的相应元素。
LessThanAll(Vector, Vector)

返回一个值，该值指示第一个向量中的所有元素是否小于第二个向量中的相应元素。
LessThanAny(Vector, Vector)

返回一个值，该值指示第一个向量中的任何元素是否小于第二个向量中的相应元素。
LessThanOrEqual(Vector, Vector)

返回一个新的整型向量，其元素指示一个双精度浮点向量中的元素是否小于或等于第二个双精度浮点向量中的相应元素。
LessThanOrEqual(Vector, Vector)

返回一个新的整型向量，其元素指示一个整型向量的元素是否小于或等于第二个整型向量中的相应元素。
LessThanOrEqual(Vector, Vector)

返回一个新的长整数向量，其元素指示一个长整数向量中的元素是小于还是等于第二个长整数向量中的相应元素。
LessThanOrEqual(Vector, Vector)

返回一个新的整型向量，其元素指示一个单精度浮点向量中的元素是否小于或等于第二个单精度浮点向量中的相应元素。
LessThanOrEqual(Vector, Vector)

返回一个新向量，其元素指示一个向量中的元素是否小于或等于第二个向量中的相应元素。
LessThanOrEqualAll(Vector, Vector)

返回一个值，该值指示第一个向量中的所有元素是否小于或等于第二个向量中的相应元素。
LessThanOrEqualAny(Vector, Vector)

返回一个值，该值指示第一个向量中的任何元素是否小于或等于第二个向量中的相应元素。
Load(T*)

从给定源加载向量。
LoadAligned(T*)

从给定的对齐源加载向量。
LoadAlignedNonTemporal(T*)

从给定的对齐源加载向量。
LoadUnsafe(T)

从给定源加载向量。
LoadUnsafe(T, UIntPtr)

从给定的源和元素偏移量加载向量。
Log(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Log(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Log2(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Log2(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Max(Vector, Vector)

返回一个新向量，其元素是两个给定向量中每个元素对的最大值。
MaxMagnitude(Vector, Vector)

将两个向量与计算进行比较，每个元素具有更大的数量级。
MaxMagnitudeNumber(Vector, Vector)

将两个向量（基于每个元素）与计算进行比较，如果输入 NaN，则计算其数量级更大并返回另一个值。
MaxNative(Vector, Vector)

比较两个向量，以确定每个元素使用特定于平台的行为 NaN 和 NegativeZero。
MaxNumber(Vector, Vector)

将两个向量（基于每个元素）与计算结果进行比较，如果元素 NaN，则计算该值更大，并返回另一个值。
Min(Vector, Vector)

返回一个新向量，其元素是两个给定向量中每个元素对的最小值。
MinMagnitude(Vector, Vector)

将两个向量与计算进行比较，每个元素的量级较小。
MinMagnitudeNumber(Vector, Vector)

将两个向量（基于每个元素）与计算进行比较，如果输入 NaN，则计算其数量级较小并返回另一个值。
MinNative(Vector, Vector)

比较两个向量，以确定每个元素使用特定于平台的行为 NaN 和 NegativeZero。
MinNumber(Vector, Vector)

比较两个向量（基于每个元素）计算，如果元素 NaN，则计算该向量更小，并返回另一个值。
Multiply(T, Vector)

返回一个新向量，其值是标量值乘以指定向量的每个值。
Multiply(Vector, T)

返回一个新向量，其值是指定向量的值，每个向量乘以标量值。
Multiply(Vector, Vector)

返回一个新向量，其值是两个指定向量中每个元素对的乘积。
MultiplyAddEstimate(Vector, Vector, Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
MultiplyAddEstimate(Vector, Vector, Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Narrow(Vector, Vector)

将两个 Vector 实例缩小为一个 Vector。
Narrow(Vector, Vector)

将两个 Vector 实例缩小为一个 Vector。
Narrow(Vector, Vector)

将两个 Vector 实例缩小为一个 Vector。
Narrow(Vector, Vector)

将两个 Vector 实例缩小为一个 Vector。
Narrow(Vector, Vector)

将两个 Vector 实例缩小为一个 Vector。
Narrow(Vector, Vector)

将两个 Vector 实例缩小为一个 Vector。
Narrow(Vector, Vector)

将两个 Vector 实例缩小为一个 Vector。
Negate(Vector)

返回一个新向量，其元素是指定向量中相应元素的求反。
OnesComplement(Vector)

返回一个新向量，其元素是通过获取指定向量元素的补数获得的。
RadiansToDegrees(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
RadiansToDegrees(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Round(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Round(Vector, MidpointRounding)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Round(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Round(Vector, MidpointRounding)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftLeft(Vector, Int32)

将向量的每个元素左移指定量。
ShiftRightArithmetic(Vector, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightArithmetic(Vector, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightArithmetic(Vector, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightArithmetic(Vector, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightArithmetic(Vector, Int32)

按指定量向量向右移动 （signed） 的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
ShiftRightLogical(Vector, Int32)

按指定量向量向右移动（无符号）的每个元素。
Sin(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Sin(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
SinCos(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
SinCos(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
SquareRoot(Vector)

返回一个新向量，其元素是指定向量元素的平方根。
Store(Vector, T*)

将向量存储在给定的目标处。
StoreAligned(Vector, T*)

将矢量存储在给定的对齐目标处。
StoreAlignedNonTemporal(Vector, T*)

将矢量存储在给定的对齐目标处。
StoreUnsafe(Vector, T)

将向量存储在给定的目标处。
StoreUnsafe(Vector, T, UIntPtr)

将向量存储在给定的目标处。
Subtract(Vector, Vector)

返回一个新向量，其值是第二个向量中的元素与第一个向量中的相应元素之间的差异。
Sum(Vector)

返回指定向量内所有元素的总和。
ToScalar(Vector)

将给定向量转换为包含第一个元素值的标量。
Truncate(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Truncate(Vector)

提供用于创建、操作和其他在泛型向量上运行的静态方法的集合。
Widen(Vector, Vector, Vector)

将 Vector 扩大为两个 Vector 实例。
Widen(Vector, Vector, Vector)

将 Vector 扩大为两个 Vector 实例。
Widen(Vector, Vector, Vector)

将 Vector 扩大为两个 Vector 实例。
Widen(Vector, Vector, Vector)

将 Vector 扩大为两个 Vector 实例。
Widen(Vector, Vector, Vector)

将 Vector 扩大为两个 Vector 实例。
Widen(Vector, Vector, Vector)

将 Vector 扩大为两个 Vector 实例。
Widen(Vector, Vector, Vector)

将 Vector 扩大为两个 Vector 实例。
WidenLower(Vector)

将 Vector 的下半部分扩大为 Vector。
WidenLower(Vector)

将 Vector 的下半部分扩大为 Vector。
WidenLower(Vector)

将 Vector 的下半部分扩大为 Vector。
WidenLower(Vector)

将 Vector 的下半部分扩大为 Vector。
WidenLower(Vector)

将 Vector 的下半部分扩大为 Vector。
WidenLower(Vector)

将 Vector 的下半部分扩大为 Vector。
WidenLower(Vector)

将 Vector 的下半部分扩大为 Vector。
WidenUpper(Vector)

将 Vector 的上半部分扩大为 Vector。
WidenUpper(Vector)

将 Vector 的上半部分扩大为 Vector。
WidenUpper(Vector)

将 Vector 的上半部分扩大为 Vector。
WidenUpper(Vector)

将 Vector 的上半部分扩大为 Vector。
WidenUpper(Vector)

将 Vector 的上半部分扩大为 Vector。
WidenUpper(Vector)

将 Vector 的上半部分扩大为 Vector。
WidenUpper(Vector)

将 Vector 的上半部分扩大为 Vector。
WithElement(Vector, Int32, T)

创建一个新的 Vector，该元素位于指定索引处设置为指定值，其余元素设置为与给定向量中的相同值。
Xor(Vector, Vector)

通过对两个向量中的每个元素对执行按位排他或（XOr）运算来返回一个新向量。

在C#中，Vector并不是一个内置的数据结构

性能：List和Array在内存分配和性能方面通常优于Vector。具体来说，List在添加元素时会自动调整大小，而Array需要手动调整大小。这可能导致Vector在某些情况下性能较差。

功能：List和Array提供了更多的功能，如排序、查找和转换等。而Vector主要用于线性代数计算，因此功能相对有限。

可扩展性：List和Array更容易扩展和修改。例如，你可以使用LINQ查询来筛选、排序和转换List和Array中的元素。而Vector的功能相对有限，可能需要额外的库或工具来实现类似的操作。

兼容性：List和Array是C#的核心数据结构，广泛应用于各种场景。而Vector主要用于线性代数计算，可能不适用于所有场景。

语法：List和Array的语法更简洁，易于理解和使用。而Vector的语法可能相对复杂，特别是在进行线性代数计算时。

总之，Vector主要用于线性代数计算，而List和Array更适用于常规编程任务。在大多数情况下，建议使用List或Array而不是Vector。然而，如果你需要进行复杂的线性代数计算，Vector可能是一个更好的选择。

https://www.yisu.com/ask/84957467.html
 

你可能感兴趣的:(c#,list,开发语言,vector,SIMD)

  • 【ARM】FPU,VFP,ASE,NEON,SVE...是什么意思？ 亿道电子Emdoor ARMarm开发ARM
    1、文档目标对执行浮点和SIMD操作的逻辑的各种名称的缩写词进行简要解释。2、问题场景Arm处理器内核中有用于执行浮点和SIMD操作的逻辑，有各种名称。它们通常是一系列的缩写形式，因此本文旨在对每一个缩写词进行简要解释。3、软硬件环境1、软件版本：不涉及2、电脑环境：不涉及4、相关缩写FPU(Floating-PointUnit)浮点单元浮点单元是处理器核心中的一个模块，用于使用浮点数执行算术运算
  • C++ ：vector的模拟 诚自然成 c++开发语言
    目录一、vector的迭代器二、vector的构造函数默认构造函数参数构造函数迭代器范围构造函数拷贝构造函数swap:交换vector重载赋值符析构函数reserve:扩容vectorresize:调整大小push_back:添加元素empty:判空pop_back:后删获取大小与容量：size(),capacity()重载operator[]：元素访问insert：插入元素erase:删除一个元
  • 手把手教你用C语言实现顺序表
    hello，大家好，本篇文章旨在为大家讲解如何使用C语言实现顺序表，还有就是小编自己复习一下相关知识，OK，那我们现在开始。在通讯录中，有增删查改等功能，那么顺序表我们也会对以上功能进行实现。一、创建并初始化顺序表1.创建typedefintSLDataType;#defineINIT_CAPACITY4//动态顺序表--按需申请typedefstructSeqList{SLDataType*a;
  • Unity学习笔记1 zy_777
    通过一个星期的简单学习，初步了解了下unity，unity的使用，以及场景的布局，UI，以及用C#做一些简单的逻辑。好记性不如烂笔头，一些关键帧还是记起来比较好，哈哈，不然可能转瞬即逝了，（PS:纯小白观点，unity大神可以直接忽略了）一：MonoBehaviour类的初始化1，Instantiate()创建GameObject2，通过Awake()和Start()来做初始化3，Update、L
  • C#中的设计模式：构建更加优雅的代码 Envyᥫᩣᩚ c#开发语言
    C#在面向对象编程（OOP）方面的强大支持，我们可以探讨“C#中的设计模式”。这不仅有助于理解如何更好地组织代码，还能提高代码的可维护性和可扩展性。引言设计模式是软件工程中经过实践验证的解决方案模板，它们提供了一种标准化的方法来解决常见的开发问题。对于使用C#进行开发的程序员来说，理解和应用这些模式可以帮助创建结构良好、易于维护和扩展的应用程序。本文将介绍几种常用的设计模式，并展示如何用C#实现它
  • [Ljava.lang.Object; cannot be cast to [Ljava.lang.String; 这些不会的
    解释：这个错误是很常见的错误，错误的提示已经很清楚了就是java的Object数组不能转换成为String[]数组，这就说明你要转换的数组它本身是Object类型的数组，但是你却非要把它转换为String类的数组，这当然是错误的。示例：[java]viewplaincopypackagecom.dada;importjava.util.ArrayList;importjava.util.List;
  • 探索高效文档转换新路径：Aspose.Words v18.7助力Word无缝变PDF 邴卉露Robust
    探索高效文档转换新路径：Aspose.Wordsv18.7助力Word无缝变PDF【下载地址】Aspose.Wordsv18.7C示例源码Word转PDF无需安装Office本仓库提供了一个使用Aspose.Wordsv18.7将Word文档转换为PDF文档的C#示例源码。Aspose.Words是一个强大的.NET控件，允许开发者在不安装MicrosoftOffice的情况下读写Word文档，并
  • .net平台的跨平台桌面应用开发的技术方案总结对比 yuanpan .net
    目前，.NET平台提供了多种跨平台桌面应用开发的技术方案，主要包括.NETMAUI、AvaloniaUI、UnoPlatform、Eto.Forms等。以下是它们的核心特点及优缺点对比：1..NETMAUI（.NETMulti-platformAppUI）支持平台：Windows、macOS、iOS、Android核心特点：微软官方维护，继承自Xamarin.Forms，支持XAML和C#开发。提
  • C# 探秘：枚举器(IEnumerator)与可枚举类型(IEnumerable) - 揭秘 foreach 的幕后英雄 钢铁男儿 C#图解教程c#java算法
    在C#开发中，foreach循环是我们遍历集合（如数组、列表）的得力助手。它简洁优雅地为我们取出集合中的每一个元素。但你是否思考过，foreach是如何知道如何遍历这些集合的？其背后的核心机制就是枚举器(Enumerator)和可枚举类型(Enumerable)。本文将深入探讨这两个接口(IEnumerator和IEnumerable)，揭开foreach循环的神秘面纱。foreach的魔法背后让
  • 负载均衡-加权随机算法 BP白朴 Nginx负载均衡java算法服务器
    负载均衡-加权随机算法由于访问概率大致相同，所以如果部分服务器性能不一致的话，容易导致性能差的服务器压力过大，所以要根据服务器性能不一致的情况，给性能好的服务器多处理请求，给差的少分配请求（能者多劳）所以就需要在随机算法的基础上给每台服务器设置权重，延伸为加权随机算法1、将应用服务器集群的IP存到Map里,每个IP对应有一个权重2、创建一个List,来将所有权重下的IP存到list里面如：192.
  • 如何在 Ubuntu 24.04 或 22.04 Linux 上安装和运行 Redis 服务器 山岚的运维笔记 Linux运维及使用linux服务器ubunturedis数据库
    Redis（RemoteDictionaryServer，远程字典服务器）是一种内存数据结构存储，通常用作NoSQL数据库、缓存和消息代理。它是开源的，因此用户可以免费安装，无需支付任何费用。Redis旨在为需要快速数据访问和低延迟的应用程序提供速度和效率。Redis支持多种数据类型，包括字符串（Strings）、列表（Lists）、集合（Sets）、哈希（Hashes）、有序集合（SortedS
  • VUE 座位图功能+扩展 NUZGNAW vue.jsjavascript前端
    1、通过循环画出页面座位图0"style="display:table;margin:0auto;min-height:472px;position:relative;">{{i.sign}}2、画出右下角的预览图3、编写对应js方法watch:{seatList:{handler(newVal,oldVal){if(this.seatList&&!stringBlank(this.seatLis
  • c#分层设计介绍 努力吧_少年 C#javac#asp.net
    领域驱动分层介绍UI（表示层）最容易理解，这一层负责显示信息给用户，并解释用户的命令。有时，用户不是人，而是另一个系统。应用层用于协调领域模型对象的动作。不建议这一层包含业务规则或领域知识，即使是维护状态也不行——这是领域模型做的事情。应用层对于协调任务和把动作委托给领域模型非常有用。虽然不用于维护业务实体的状态，单应用层可以维护跟踪用户或者系统所执行的当前任务的状态。应用层不干涉阻碍领域模型，这
  • Ubuntu Docker 安装Redis LLLL96 Ubuntudockerdockerredisubuntu
    目录介绍1.数据结构丰富2.高性能3.持久化1.拉取Redis镜像2.创建挂载目录(可选)3.配置Redis持久化(可选)4.使用配置文件运行容器5.查看redis日志介绍1.数据结构丰富Redis支持多种数据结构，包括：字符串（String）:可以用来存储任何类型的数据，例如文本、数字或二进制数据。哈希（Hash）:存储字段和值的映射，适合用于表示对象。列表（List）:有序的字符串列表，可以用
  • Java：数据结构-ArrayList和顺序表（2） blammmp java数据结构开发语言
    一ArrayList的使用1.ArrayList的构造方法第一种（指定容量的构造方法）创建一个空的ArrayList，指定容量为initialCapacity。publicArrayList(intinitialCapacity){if(initialCapacity>0){this.elementData=newObject[initialCapacity];}elseif(initialCap
  • Gray Code 格雷码 YouQian772 数学递归训练赛算法
    题目描述AGraycodeisalistofall2^nbitstringsoflengthn,whereanytwosuccessivestringsdifferinexactlyonebit(i.e.,theirHammingdistanceisone).YourtaskistocreateaGraycodeforagivenlengthn.输入Theonlyinputlinehasanint
  • iOS开发-一个App唤醒另外一个App 善良的皮蛋
    唤醒App前期准备唤醒App前言：工作中的需求要求在一个App内点击唤醒另外一个App类似很多App可以唤醒淘宝或者京东。1.准备工作1.新建两个App,MyAppOne(触发唤醒的App)、MyAppTow(要唤醒的App)2.iOS9之后要在info.plist中添加白名单，否则无法唤醒。设置白名单LSApplicationQueriesSchemesweixinURLScheme在MyApp
  • 【数据结构】--ArrayList与顺序表 bubu__ 数据结构数据结构
    文章目录1.线性表2.顺序表3.ArrayList简介4.MyArrayList的实现5.ArrayList使用5.1ArrayList的构造5.2ArrayList常见操作5.3ArrayList的遍历5.4ArrayList的扩容机制6.ArrayList的具体使用6.1简单的洗牌算法6.2杨辉三角1.线性表线性表（linearlist）是n个具有相同特性的数据元素的有限序列。线性表是一种在实
  • 过了中年，过低能耗的生活 戴老师成长记录仪
    今天的文章，还是和你分享洞见里面的文章，我发现洞见里的文章，非常好，非常适合，在我们这个时代，我们应该如何思考，应该如何去做，好的，我现在今天就针对这篇问的一些思考，期待能够给你带来一些启发：[if!supportLists]一、[endif]物质低能耗过了中年，对于物质的追求，我们不能够像年轻的时候一样，什么都想要，什么都要的太多，而是要过一个物质低能耗的生活。知足就好，够用就行，这是我们中年人
  • （AC）Playlist
    题目描述Youaregivenaplaylistofaradiostationsinceitsestablishment.Theplaylisthasatotalofnsongs.Whatisthelongestsequenceofsuccessivesongswhereeachsongisunique?输入Thefirstinputlinecontainsanintegern(1≤n≤2*105
  • 数据结构2-集合类ArrayList与洗牌算法
    文章目录★引言：一.MyArrayList模拟实现（一）IList（二）MyArrayList（1）add(Tdata)（2）add(intpos,Tdata)（3）IllgalPosException（4）indexOf(ObjecttoFind)（5）contains(ObjecttoFind)（6）get(intpos)（7）set(intpos,Tvalue)（8）remove(Objec
  • 构建高效的物流车辆定位管理系统 体制教科书
    本文还有配套的精品资源，点击获取简介：物流车辆定位管理系统利用信息技术提高物流效率和安全性。通过集成GPS技术进行实时车辆追踪和监控，它提供及时的货物运送和异常处理。系统的关键技术包括GPS车辆定位、C#编程语言、数据库管理、车辆管理、在途情况监控、预警与通知、数据分析与报告、用户界面设计、安全性与隐私保护以及系统集成。这些要素共同保障物流流程的高效、安全和智能化。1.物流车辆定位管理系统的应用与
  • Python STL概念学习与代码实践 体制教科书
    本文还有配套的精品资源，点击获取简介：通过”py_stl_learning”项目，学习者可以使用Python实现和理解C++STL的概念，包括数据结构、算法、容器适配器、模板和泛型容器等。Python中的列表、集合、字典等数据结构与STL中的vector、set、map等类似，而Python的itertools和functools模块提供了STL风格的算法功能。Python通过其面向对象的特性以及
  • 使用 C# 实现 FTP 上传的方法，包括详细的代码示例和测试代码 zhxup606 李工篇C#实战教程c#开发语言
    以下是使用C#实现FTP上传的方法，包括详细的代码示例和测试代码。以下代码使用System.Net.FtpWebRequest实现文件上传，并附带一个简单的测试用例。C#FTP上传方法csharpusingSystem;usingSystem.IO;usingSystem.Net;publicclassFtpClient{//////上传文件到FTP服务器//////FTP服务器地址，例如ftp:
  • Baumer工业相机堡盟工业相机如何通过YoloV8深度学习模型实现不同水果的检测识别（C#代码，UI界面版）
    Baumer工业相机堡盟工业相机如何通过YoloV8深度学习模型实现不同水果的检测识别（C#代码，UI界面版））工业相机使用YoloV8模型实现不同水果的检测识别工业相机通过YoloV8模型实现不同水果的检测识别的技术背景在相机SDK中获取图像转换图像的代码分析工业相机图像转换Bitmap图像格式和Mat图像重要核心代码本地文件图像转换Bitmap图像格式和Mat图像重要核心代码Mat图像导入Yo
  • 10. addEventListener 参数有哪些 yqcoder 前端面试-CSS前端javascript开发语言
    总结el.addEventListener(type,listener,useCapture)el：事件对象type：事件类型listener：事件处理函数useCapture：布尔或对象，布尔时false为冒泡，true为捕获。对象时，{captrue:false,once:false,passive:false}addEventListener是用于为元素绑定事件监听器的标准方法，支持更灵活的
  • 三种接口实现增删改查 灬爱码士灬 javajava
    目录ArrayListHashSetHashMapArrayListArrayList实现增删改查packagetest;importjava.util.ArrayList;importjava.util.Iterator;/***@Author:Mo*@Date:2020/12/611:11*/publicclasslist{ArrayListlist1=newArrayList();publi
  • 跳表：来自概率的优雅平衡 allenXer 算法与数据结构redis数据结构算法python学习
    跳表：来自概率的优雅平衡从抛硬币到Redis核心，跳表如何用随机性颠覆数据结构设计引言：平衡的艺术在计算机科学的世界里，数据结构的设计者一直在追求一种完美平衡：快速查询的同时保持高效的插入和删除。平衡树（如AVL树、红黑树）曾是这个领域的王者，但它们的复杂性令人望而生畏。直到1989年，计算机科学家WilliamPugh提出了一种革命性的数据结构——跳表（SkipList），它用概率的魔力实现了近
  • vue2中实现leader-line-vue连线文章对应字符 小莉爱编程 vuebug记录vue.js前端javascript
    效果展示通过点击右边的tag，触发连接操作第一步：获取右边tag展示1.右边的tag列表展示，我这边是分为两个list嵌套的数据结构；{"人员":[{
  • 如何在Power Query中对不同行，列名排序一致进行转置？ Data_Skill
    之前的案例都是列数及行数相同，那如果是不同的情况下，该如何处理呢？原表：同行不同列原表目标表：同行不同列目标表此时我们可以通过另外一个分组函数来进行处理。Table.GroupTable.Group(tableastable,keyasany,aggregatedColumnsaslist,optionalgroupKindasnullablenumber,optionalcomparerasnu
  • java数字签名三种方式 知了ing javajdk
    以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
  • Hibernate学习笔记 caoyong Hibernate
    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境      a>、添加jar包:      aa>、hibernatte开发包中/lib/required/所
  • 设计模式之装饰器模式Decorator（结构型） 漂泊一剑客 Decorator
    1. 概述        若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。      
  • 读取磁盘文件txt，并输入String 一炮送你回车库 String
    public static void main(String[] args) throws IOException {    String fileContent = readFileContent("d:/aaa.txt");    System.out.println(fileContent);   
  • js三级联动下拉框 3213213333332132 三级联动
    //三级联动 省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
  • erlang之parse_transform编译选项的应用 616050468 parse_transform游戏服务器属性同步abstract_code
             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
  • JAVA JSON的解析 darkranger java
    // { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
  • POJ-1273-Drainage Ditches aijuans ACM_POJ
    POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
  • 工作流Activiti5表的命名及含义 atongyeye 工作流Activiti
    activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 A
  • android的广播机制和广播的简单使用 百合不是茶 android广播机制广播的注册
          Android广播机制简介 在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
  • Spring事务传播行为详解 bijian1013 javaspring事务传播行为
            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。         Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
  • eidtplus operate 征客丶 eidtplus
    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动 列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
  • 【Kafka一】Kafka入门 bit1129 kafka
    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧   下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
  • Spring 事务实现机制 BlueSkator spring代理事务
    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
  • bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrapdropdown
    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。 一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
  • 常用代码记录 chenjunt3 UIExcelJ#
      1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
  • 搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
          最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想)   -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
  • oracle Health Monitor daizj oracleHealth Monitor
    About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
  • JSON字符串转换为对象 dieslrae javajson
        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.   
  • C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
    实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
  • vagrant学习笔记 dcj3sjt126com vagrant
    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant   1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads   查看安装在命令行输入vagrant     2.
  • 14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
    1.Tomcat线程池 修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
  • 一个不错的shell 脚本教程 入门级 HarborChung linuxshell
    一个不错的shell 脚本教程 入门级 建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
  • Spring4新特性——核心容器的其他改进 jinnianshilongnian spring动态代理spring4依赖注入
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • Linux设置tomcat开机启动 liuxingguome tomcatlinux开机自启动
    执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
  • 第13章 Ajax进阶（下） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • Troubleshooting Crystal Reports off BW blueoxygen BO
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE   Quite useful, especially this part: SAP BW connectivity For t
  • Java开发熟手该当心的11个错误 tomcat_oracle javajvm多线程单元测试
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
  • 正则表达式大全 yang852220741 html编程正则表达式
    今天向大家分享正则表达式大全，它可以大提高你的工作效率 正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。 一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他