ColumnView (cudfjni 25.04.0 API)

java.lang.Object
- ai.rapids.cudf.ColumnView

所有已实现的接口

BinaryOperable, AutoCloseable

直接已知子类

ColumnVector
```
public class ColumnView
extends Object
implements AutoCloseable, BinaryOperable
```
此类表示列的 column_view，类似于其 cudf cpp 对应项。它保存视图信息，例如 native handle 和 column_view 的其他 metadata。它还公开了允许对视图进行操作的 API。

嵌套类摘要

嵌套类
修饰符和类型类和描述

静态类 ColumnView.FindOptions
用于选择 listIndexOf 函数行为的枚举：1.

嵌套类
修饰符和类型	类和描述
`静态类`	`ColumnView.FindOptions` 用于选择 listIndexOf 函数行为的枚举：1.

字段摘要

字段
修饰符和类型	字段和描述
`protected long`	`nullCount`
`protected ColumnVector.OffHeapState`	`offHeap`
`protected long`	`rows`
`protected DType`	`type`
`静态 long`	`UNKNOWN_NULL_COUNT`
`protected long`	`viewHandle`

构造方法摘要

构造方法
修饰符	构造方法和描述
`protected`	`ColumnView(ColumnVector.OffHeapState state)` 旨在从 ColumnVector 构造时调用。
	`ColumnView(DType type, long rows, Optional<Long> nullCount, BaseDeviceMemoryBuffer dataBuffer, BaseDeviceMemoryBuffer validityBuffer)` 根据设备上已有的数据创建新的列视图。
	`ColumnView(DType type, long rows, Optional<Long> nullCount, BaseDeviceMemoryBuffer dataBuffer, BaseDeviceMemoryBuffer validityBuffer, BaseDeviceMemoryBuffer offsetBuffer)` 根据设备上已有的数据创建新的列视图。
	`ColumnView(DType type, long 行数, Optional<Long> null计数, BaseDeviceMemoryBuffer 有效性缓冲区, BaseDeviceMemoryBuffer 偏移量缓冲区, ColumnView[] 子列)` 根据设备上已有的数据创建新的列视图。

方法摘要

所有方法静态方法实例方法具体方法已弃用方法
修饰符和类型	方法和说明
`ColumnVector`	`abs()` 计算绝对值，输出类型与输入类型相同。
`ColumnVector`	`addCalendricalMonths(ColumnView months)` 将指定数量的月添加到时间戳。
`ColumnVector`	`addCalendricalMonths(Scalar months)` 将指定数量的月添加到时间戳。
`Scalar`	`all()` 返回一个布尔标量，如果列中的所有元素都为真或非零则返回 true，否则返回 false。
`Scalar`	`all(DType outType)` 已弃用。唯一支持的输出类型是 BOOL8。
`Scalar`	`any()` 返回一个布尔标量，如果列中的任何元素为真或非零则返回 true，否则返回 false。
`Scalar`	`any(DType outType)` 返回一个标量，取决于指定类型，如果列中的任何元素为真或非零则返回 true 或 1，否则返回 false 或 0。
`ColumnVector`	`applyBooleanMask(ColumnView booleanMaskView)` 使用 `booleanMaskView` 布尔值列表作为掩码，过滤此 LIST 列中每一行的元素。
`ColumnVector`	`approxPercentile(ColumnVector percentiles)` 计算此 ColumnVector 的各种百分位数，该 ColumnVector 必须包含由 t-digest 聚合生成的质心。
`ColumnVector`	`approxPercentile(double[] percentiles)` 计算此 ColumnVector 的各种百分位数，该 ColumnVector 必须包含由 t-digest 聚合生成的质心。
`ColumnVector`	`arccos()` 计算 arccos，输出类型与输入类型相同。
`ColumnVector`	`arccosh()` 计算双曲 arccos，输出类型与输入类型相同。
`ColumnVector`	`arcsin()` 计算 arcsin，输出类型与输入类型相同。
`ColumnVector`	`arcsinh()` 计算双曲 arcsin，输出类型与输入类型相同。
`ColumnVector`	`arctan()` 计算 arctan，输出类型与输入类型相同。
`ColumnVector`	`arctanh()` 计算双曲 arctan，输出类型与输入类型相同。
`ColumnVector`	`asByteList()` 转换为字节列表此方法转换 ColumnVector 提供的行，并将每行转换为字节列表，字节序反转。
`ColumnVector`	`asByteList(boolean config)` 转换为字节列表此方法转换 ColumnVector 提供的行，并将每行转换为字节列表。
`ColumnVector`	`asBytes()` 转换为字节 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为字节。从 Date、Timestamp 或 Boolean 转换为字节类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`asDoubles()` 转换为双精度浮点数 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为双精度浮点数。从 Date、Timestamp 或 Boolean 转换为双精度浮点数类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`asFloats()` 转换为单精度浮点数 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为单精度浮点数。从 Date、Timestamp 或 Boolean 转换为单精度浮点数类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`asInts()` 转换为整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为整型。从 Date、Timestamp 或 Boolean 转换为整型类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`asLongs()` 转换为长整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为长整型。从 Date、Timestamp 或 Boolean 转换为长整型类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`asShorts()` 转换为短整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为短整型。从 Date、Timestamp 或 Boolean 转换为短整型类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`asStrings()` 转换为字符串。
`ColumnVector`	`asStrings(String format)` 解析时间戳列向量并转换为字符串列向量的方法。
`ColumnVector`	`asTimestamp(DType timestampType, String format)` 将字符串解析为时间戳。
`ColumnVector`	`asTimestampDays()` 转换为 TIMESTAMP_DAYS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_DAYS
`ColumnVector`	`asTimestampDays(String format)` 转换为 TIMESTAMP_DAYS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_DAYS
`ColumnVector`	`asTimestampMicroseconds()` 转换为 TIMESTAMP_MICROSECONDS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_MICROSECONDS
`ColumnVector`	`asTimestampMicroseconds(String format)` 转换为 TIMESTAMP_MICROSECONDS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_MICROSECONDS
`ColumnVector`	`asTimestampMilliseconds()` 转换为 TIMESTAMP_MILLISECONDS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_MILLISECONDS。
`ColumnVector`	`asTimestampMilliseconds(String format)` 转换为 TIMESTAMP_MILLISECONDS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_MILLISECONDS。
`ColumnVector`	`asTimestampNanoseconds()` 转换为 TIMESTAMP_NANOSECONDS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_NANOSECONDS。
`ColumnVector`	`asTimestampNanoseconds(String format)` 转换为 TIMESTAMP_NANOSECONDS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_NANOSECONDS。
`ColumnVector`	`asTimestampSeconds()` 转换为 TIMESTAMP_SECONDS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_SECONDS
`ColumnVector`	`asTimestampSeconds(String format)` 转换为 TIMESTAMP_SECONDS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_SECONDS
`ColumnVector`	`asUnsignedBytes()` 转换为无符号字节 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为字节。从 Date、Timestamp 或 Boolean 转换为字节类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`asUnsignedInts()` 转换为无符号整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为整型。从 Date、Timestamp 或 Boolean 转换为整型类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`asUnsignedLongs()` 转换为无符号长整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为长整型。从 Date、Timestamp 或 Boolean 转换为长整型类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`asUnsignedShorts()` 转换为无符号短整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为短整型。从 Date、Timestamp 或 Boolean 转换为短整型类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`binaryOp(BinaryOp op, BinaryOperable rhs, DType outType)` 多种不同的二进制运算。
`ColumnView`	`bitCastTo(DType type)` 在底层长度相同的类型之间进行零拷贝转换。
`ColumnVector`	`bitInvert()` 按位取反，输出类型与输入类型相同。
`ColumnVector`	`capitalize(Scalar delimiters)` 返回一个字符串列，其中字符串已被首字母大写。
`ColumnVector`	`castTo(DType type)` 将 ColumnVector 进行类型转换的通用方法。从 Date、Timestamp 或 Boolean 转换为数值类型时，将使用数据的底层数值表示进行转换。
`ColumnVector`	`cbrt()` 计算立方根，输出类型与输入类型相同。
`ColumnVector`	`ceil()` 计算向上取整，输出类型与输入类型相同。
`ColumnVector`	`clamp(Scalar lo, Scalar hi)` 将 `input` 中小于 `lo` 的值替换为 `lo`，将大于 `hi` 的值替换为 `hi`。
`ColumnVector`	`clamp(Scalar lo, Scalar loReplace, Scalar hi, Scalar hiReplace)` 将 `input` 中小于 `lo` 的值替换为 `lo_replace`，将大于 `hi` 的值替换为 `hi_replace`。
`void`	`close()`
`ColumnVector`	`codePoints()` 获取每个字符串中每个字符的代码点值（整数）。
`ColumnVector`	`contains(ColumnView searchSpace)` 返回一个 `DType.BOOL8` 类型的新列，其大小与此列相同，如果此列中的对应条目包含在给定的 searchSpace 列中，则每行的值为 true，否则为 false。
`boolean`	`contains(Scalar needle)` 查找 `needle` 是否在此列中存在。示例：单列：idx 0 1 2 3 4 col = { 10, 20, 20, 30, 50 } 标量：value = { 20 } 结果 = true
`ColumnVector`	`containsRe(RegexProgram regexProg)` 返回一个布尔 ColumnVector，识别匹配给定 RegexProgram 模式（从任意位置开始）的行。
`ColumnVector`	`containsRe(String pattern)` 已弃用。
`ColumnVector`	`copyToColumnVector()` 从列视图句柄创建一个 ColumnVector
`HostColumnVector`	`copyToHost()` 同步将数据复制到主机内存
`HostColumnVector`	`copyToHost(HostMemoryAllocator hostMemoryAllocator)` 同步将数据复制到主机。
`HostColumnVector`	`copyToHostAsync(Cuda.Stream stream)` 异步将数据复制到主机。
`HostColumnVector`	`copyToHostAsync(Cuda.Stream stream, HostMemoryAllocator hostMemoryAllocator)` 异步将数据复制到主机。
`ColumnVector`	`cos()` 计算 cos，输出类型与输入类型相同。
`ColumnVector`	`cosh()` 计算双曲 cos，输出类型与输入类型相同。
`ColumnVector`	`countElements()` 获取每个列表中元素的数量。
`ColumnVector`	`dateTimeCeil(DateTimeRoundingFrequency freq)` 将时间戳向上舍入到给定频率，保持类型不变。
`ColumnVector`	`dateTimeFloor(DateTimeRoundingFrequency freq)` 将时间戳向下舍入到给定频率，保持类型不变。
`ColumnVector`	`dateTimeRound(DateTimeRoundingFrequency freq)` 将时间戳（四舍五入）舍入到给定频率，保持类型不变。
`ColumnVector`	`day()` 从时间戳中获取日期。
`ColumnVector`	`dayOfYear()` 从时间戳中获取一年中的第几天。
`ColumnVector`	`daysInMonth()` 提取月份中的天数
`int`	`distinctCount()` 计算列中有多少行互不相同（去重计数）。
`int`	`distinctCount(NullPolicy nullPolicy)` 计算列中有多少行互不相同（去重计数）。
`ColumnVector`	`dropListDuplicates()` 通过从当前 LIST 列复制元素并忽略重复项来创建新的 LIST 列，生成的 LIST 列中的每个列表只包含唯一元素。
`ColumnVector`	`dropListDuplicatesWithKeysValues()` 给定一个 LIST 列，其中每个元素都是一个包含以下内容的结构体：对。
`ColumnVector`	`endsWith(Scalar pattern)` 检查列中的每个字符串是否以指定的比较字符串结尾，结果是一个并行的布尔结果列。
`ColumnVector`	`exp()` 计算 exp (指数函数)，输出类型与输入类型相同。
`ColumnVector`	`extractAllRecord(RegexProgram regexProg, int idx)` 提取所有匹配给定正则表达式程序模式并对应于正则表达式组索引的字符串。
`ColumnVector`	`extractAllRecord(String pattern, int idx)` 已弃用。
`ColumnVector`	`extractDateTimeComponent(DateTimeComponent component)` 从时间戳中提取特定的日期时间组件。
`ColumnVector`	`extractListElement(ColumnView indices)` 对于此列中的每个列表，提取索引列中指定的对应索引处的条目。
`ColumnVector`	`extractListElement(int index)` 对于此列中的每个列表，提取给定索引处的条目。
`Table`	`extractRe(RegexProgram regexProg)` 对于给定正则表达式程序中指定的每个捕获组，在表中返回一个列。
`Table`	`extractRe(String pattern)` 已弃用。
`ColumnVector`	`findAndReplaceAll(ColumnView oldValues, ColumnView newValues)` 返回一个向量，其中所有值 "oldValues[i]" 被替换为 "newValues[i]"。
`ColumnVector`	`flattenLists()` 将列表的列表展平为一个单独的列表。
`ColumnVector`	`flattenLists(boolean ignoreNull)` 将列表的列表展平为一个单独的列表。
`ColumnVector`	`floor()` 计算向下取整，输出类型与输入类型相同。
`static ColumnView`	`fromDeviceBuffer(BaseDeviceMemoryBuffer buffer, long startOffset, DType type, int rows)` 从原始设备缓冲区创建一个新的列视图。
`ColumnVector`	`generateListOffsets()` 根据每个列表的大小生成列表偏移量。
`ColumnVector`	`getByteCount()` 检索每个字符串的字节数。
`ColumnVector`	`getCharLengths()` 检索每个字符串中的字符数。
`ColumnView`	`getChildColumnView(int childIndex)` 返回给定索引处的子列视图。
`ColumnView[]`	`getChildColumnViews()` 返回此视图的子列视图。请注意，调用者有责任关闭这些视图。
`BaseDeviceMemoryBuffer`	`getData()` 获取当前列视图 (viewHandle) 的数据缓冲区。
`long`	`getDeviceMemorySize()` 返回使用的设备内存量。
`long`	`getHostBytesRequired()` 计算将数据复制到主机所需的总空间。
`ColumnVector`	`getJSONObject(Scalar path)` 将 JSONPath 字符串应用于输入字符串列中的所有行。
`ColumnVector`	`getJSONObject(Scalar path, GetJsonObjectOptions options)` 将 JSONPath 字符串应用于输入字符串列中的所有行。
`ColumnView`	`getListOffsetsView()` 获取此列表的偏移量的 ColumnView。
`ColumnVector`	`getMapKeyExistence(ColumnView keys)` 对于 List 类型的列> 和传入的键列，返回映射中所有键的布尔列。
`ColumnVector`	`getMapKeyExistence(Scalar key)` 对于 List 类型的列> 和传入的 String 键，返回结构体中所有键的布尔列，如果键存在于该行的相应映射中则为 true，否则为 false。
`ColumnVector`	`getMapValue(ColumnView keys)` 给定一个 List 类型的列> 和 X 类型的键列，返回 Y 类型的列，其中输出列中的每行是与 X 键对应的 Y 值。
`ColumnVector`	`getMapValue(Scalar key)` 给定一个 List 类型的列> 和 X 类型的键，返回 Y 类型的列，其中输出列中的每行是与 X 键对应的 Y 值。
`long`	`getNativeView()` 谨慎使用：此方法暴露了原生 cudf::column_view 的地址。
`long`	`getNullCount()` 返回数据中的空值数量。
`int`	`getNumChildren()`
`BaseDeviceMemoryBuffer`	`getOffsets()`
`long`	`getRowCount()` 返回此向量中的行数。
`Scalar`	`getScalarElement(int index)` 将指定索引处列中的单个项作为 Scalar 获取。
`DType`	`getType()` 获取此数据的类型。
`BaseDeviceMemoryBuffer`	`getValid()`
`boolean`	`hasNonEmptyNulls()` 精确检查列或其后代是否包含非空 null 行
`静态 long`	`hostPaddingSizeInBytes()` 获取主机用于对齐内存分配的大小（字节）。
`ColumnVector`	`hour()` 从具有时间分辨率的时间戳中获取小时。
`ColumnVector`	`ifElse(ColumnView trueValues, ColumnView falseValues)` 对于 BOOL8 向量，基于此向量在相应行中的布尔值，计算一个其行从其他两个向量中选择的向量。
`ColumnVector`	`ifElse(ColumnView trueValues, Scalar falseValue)` 对于 BOOL8 向量，基于此向量在相应行中的布尔值，计算一个其行从其他两个输入中选择的向量。
`ColumnVector`	`ifElse(Scalar trueValue, ColumnView falseValues)` 对于 BOOL8 向量，基于此向量在相应行中的布尔值，计算一个其行从其他两个输入中选择的向量。
`ColumnVector`	`ifElse(Scalar trueValue, Scalar falseValue)` 对于 BOOL8 向量，基于此向量在相应行中的布尔值，计算一个其行从其他两个输入中选择的向量。
`ColumnVector`	`isFixedPoint(DType decimalType)` 返回一个与此实例行数相同的布尔向量，对于定点数条目为 TRUE，否则为 FALSE。
`ColumnVector`	`isFloat()` 返回一个与此实例行数相同的布尔向量，对于浮点数条目为 TRUE，否则为 FALSE。
`ColumnVector`	`isInteger()` 返回一个与此实例行数相同的布尔向量，对于整数条目为 TRUE，否则为 FALSE。
`ColumnVector`	`isInteger(DType intType)` 返回一个与此实例行数相同的布尔向量，对于整数条目为 TRUE，否则为 FALSE。
`ColumnVector`	`isLeapYear()` 检查此时间戳的年份是否为闰年。
`ColumnVector`	`isNan()` 返回一个与此实例行数相同的布尔向量，对于 NaN 条目为 TRUE，如果为 null 或有效浮点值为 FALSE。
`ColumnVector`	`isNotNan()` 返回一个与此实例行数相同的布尔向量，对于 null 或有效浮点数值为 TRUE，否则为 FALSE。
`ColumnVector`	`isNotNull()` 返回一个与此实例行数相同的布尔向量，对于非 null 条目为 TRUE，对于 null 条目为 FALSE（根据有效性掩码）。
`ColumnVector`	`isNull()` 返回一个与此实例行数相同的布尔向量，对于非 null 条目为 FALSE，对于 null 条目为 TRUE（根据有效性掩码）。
`ColumnVector`	`isTimestamp(String format)` 验证字符串列是否可以使用提供的格式模式解析为时间戳。
`ColumnVector`	`joinStrings(Scalar separator, Scalar narep)` 将列中的所有字符串连接成一个新字符串，可选地由分隔符字符串分隔。
`ColumnVector`	`lastDayOfMonth()` 获取此时间戳所在月份的最后一天日期。
`ColumnVector`	`like(Scalar pattern, Scalar escapeChar)` 返回一个布尔 ColumnVector，用于标识与给定 like 模式匹配的行。
`ColumnVector`	`listContains(Scalar key)` 创建一个布尔值列，指示指定的标量是否是列表列每行的元素。
`ColumnVector`	`listContainsColumn(ColumnView key)` 创建一个布尔值列，指示第一列的列表行是否包含第二列中的相应值。
`ColumnVector`	`listContainsNulls()` 创建一个布尔值列，指示指定列的列表行是否包含 null 元素。
`ColumnVector`	`listIndexOf(ColumnView keys, ColumnView.FindOptions findOption)` 创建一个 int32 索引列，指示搜索键列中每行在列表列相应行中的位置。
`ColumnVector`	`listIndexOf(Scalar key, ColumnView.FindOptions findOption)` 创建一个 int32 索引列，指示标量搜索键在每个列表行中的位置。
`ColumnVector`	`listReduce(SegmentedReductionAggregation aggregation)` 对列表中的值执行归约。
`ColumnVector`	`listReduce(SegmentedReductionAggregation aggregation, DType outType)` 对列表中的值执行归约。
`ColumnVector`	`listReduce(SegmentedReductionAggregation aggregation, NullPolicy nullPolicy, DType outType)` 对列表中的值执行归约。
`static ColumnVector`	`listsDifferenceDistinct(ColumnView lhs, ColumnView rhs)` 查找左列列表与右列列表的差集。
`static ColumnVector`	`listsHaveOverlap(ColumnView lhs, ColumnView rhs)` 对于输入列表列中的每对列表，检查它们是否有任何共同的非空元素。
`static ColumnVector`	`listsIntersectDistinct(ColumnView lhs, ColumnView rhs)` 查找给定列表列每行列表中不含重复项的交集。
`ColumnVector`	`listSortRows(boolean isDescending, boolean isNullSmallest)` 对列表列中每行列表内的元素进行分段排序。
`static ColumnVector`	`listsUnionDistinct(ColumnView lhs, ColumnView rhs)` 查找给定列表列每行列表中不含重复项的并集。
`ColumnVector`	`log()` 计算对数，输出类型与输入类型相同。
`ColumnVector`	`log10()` 计算以 10 为底的对数，输出类型与输入类型相同。
`ColumnVector`	`log2()` 计算以 2 为底的对数，输出类型与输入类型相同。
`ColumnView`	`logicalCastTo(DType type)` 已弃用。在 C++ 中这已改为 bit_cast，因此请改用该名称。
`ColumnVector`	`lower()` 将字符串转换为小写。
`ColumnVector`	`lstrip()` 移除字符串开头的空白字符。
`ColumnVector`	`lstrip(Scalar toStrip)` 移除每个字符串开头指定的字符。
`static ColumnView`	`makeStructView(ColumnView... columns)` 创建现有列视图的新结构体列视图。
`static ColumnView`	`makeStructView(long rows, ColumnView... columns)` 创建现有列视图的新结构体列视图。
`ColumnVector`	`matchesRe(RegexProgram regexProg)` 返回一个布尔 ColumnVector，用于标识与给定 regex program 模式匹配但仅在字符串开头的行。
`ColumnVector`	`matchesRe(String pattern)` 已弃用。
`Scalar`	`max()` 返回列中所有值的最大值，返回与此列相同类型的标量。
`Scalar`	`max(DType outType)` 已弃用。 max 归约不再内部允许设置输出类型，作为替代，此 API 会为您将输入类型转换为输出类型，但这可能并非适用于所有情况。
`Scalar`	`mean()` 返回列中所有值的算术平均值，返回 FLOAT64 标量，除非列类型为 FLOAT32，此时返回 FLOAT32 标量。
`Scalar`	`mean(DType outType)` 返回列中所有值的算术平均值，返回指定类型的标量。
`ColumnVector`	`mergeAndSetValidity(BinaryOp mergeOp, ColumnView... columns)` 创建列的深拷贝，同时替换 null 掩码。
`Scalar`	`min()` 返回列中所有值的最小值，返回与此列相同类型的标量。
`Scalar`	`min(DType outType)` 已弃用。 min 归约不再内部允许设置输出类型，作为替代，此 API 会为您将输入类型转换为输出类型，但这可能并非适用于所有情况。
`ColumnVector`	`minute()` 从具有时间分辨率的时间戳中获取分钟。
`ColumnVector`	`month()` 从时间戳中获取月份。
`ColumnVector`	`nansToNulls()` 返回一个新 ColumnVector，其中 NaN 已转换为 null，并保留现有 null 值。
`ColumnVector`	`normalizeNANsAndZeros()` 创建“标准化”值的新向量，其中：1.
`ColumnVector`	`not()` 返回输入列（this）中每个值的逻辑 `not` 向量。
`ColumnVector`	`pad(int width)` 在右侧使用空格“ ”填充字符串列，直到达到所需长度。
`ColumnVector`	`pad(int width, PadSide side)` 使用空格“ ”填充字符串列，直到达到所需长度。
`ColumnVector`	`pad(int width, PadSide side, String fillChar)` 填充字符串列，直到达到所需长度。
`ColumnVector`	`prefixSum()` 计算此列中值的累加和（也称为前缀和）。
`Scalar`	`product()` 返回列中所有值的乘积，返回与此列相同类型的标量。
`Scalar`	`product(DType outType)` 返回列中所有值的乘积，返回指定类型的标量。
`ColumnVector`	`purgeNonEmptyNulls()` 将此列复制到输出列，同时清除列或其后代中的任何非空 null 行。
`ColumnVector`	`quantile(QuantileMethod method, double[] quantiles)` 计算此 ColumnVector 的各种分位数。
`ColumnVector`	`quarterOfYear()` 从时间戳中获取季度。
`Scalar`	`reduce(ReductionAggregation aggregation)` 计算列中所有行值的归约。
`Scalar`	`reduce(ReductionAggregation aggregation, DType outType)` 计算列中所有行值的归约。
`ColumnVector`	`repeatStrings(ColumnView repeatTimes)` 给定一个字符串列，通过将输入字符串重复由 `repeatTimes` 数字列中相应行给定的次数来生成输出字符串列。
`ColumnVector`	`repeatStrings(int repeatTimes)` 给定一个字符串列，其中的每个字符串都会被重复由 `repeatTimes` 参数指定的次数。
`ColumnView`	`replaceChildrenWithViews(int[] indices, ColumnView[] views)` 此方法接受嵌套类型并将其子项替换为给定的视图。注意：确保叶节点中的行数与替换它的子项相同，否则列表可能指向列值之外的元素。
`ColumnView`	`replaceListChild(ColumnView child)` 此方法接受一个列表并返回一个新列表，其中叶节点已被给定的视图替换。
`ColumnVector`	`replaceMultiRegex(String[] patterns, ColumnView repls)` 对于每个字符串，将匹配任何正则表达式模式的任何字符序列替换为相应的替换字符串。
`ColumnVector`	`replaceNulls(ColumnView replacements)` 返回一个 ColumnVector，其中所有 null 值都被指定替换列中的相应行替换。
`ColumnVector`	`replaceNulls(ReplacePolicy policy)`
`ColumnVector`	`replaceNulls(Scalar scalar)` 返回一个 ColumnVector，其中所有 null 值都替换为标量。
`ColumnVector`	`replaceRegex(RegexProgram regexProg, Scalar repl)` 对于每个字符串，使用替换字符串标量替换匹配给定 regex program 模式的任何字符序列。
`ColumnVector`	`replaceRegex(RegexProgram regexProg, Scalar repl, int maxRepl)` 对于每个字符串，使用替换字符串标量替换匹配给定 regex program 模式的任何字符序列。
`ColumnVector`	`replaceRegex(String pattern, Scalar repl)` 已弃用。
`ColumnVector`	`replaceRegex(String pattern, Scalar repl, int maxRepl)` 已弃用。
`ColumnVector`	`reverseStringsOrLists()` 将当前列复制到新列，输出列中的每个字符串或列表将具有反向字符或元素顺序。
`ColumnVector`	`rint()` 将浮点参数四舍五入到最接近的整数值，但以浮点数形式返回。
`ColumnVector`	`rollingWindow(RollingAggregation op, WindowOptions options)` 此函数聚合输入列中每个元素 i 周围窗口中的值。
`ColumnVector`	`round()` 使用这些默认值四舍五入列中的所有值： decimalPlaces = 0 Rounding method = RoundMode.HALF_UP
`ColumnVector`	`round(int decimalPlaces)` 使用 HALF_UP（默认）作为四舍五入方法，将列中的所有值四舍五入到指定的小数位数。
`ColumnVector`	`round(int decimalPlaces, RoundMode mode)` 将列中的所有值四舍五入到指定的小数位数。
`ColumnVector`	`round(RoundMode round)` 将列中的所有值四舍五入到小数点后 0 位。
`ColumnVector`	`rstrip()` 移除字符串末尾的空白字符。
`ColumnVector`	`rstrip(Scalar toStrip)` 移除每个字符串末尾指定的字符。
`ColumnVector`	`scan(ScanAggregation aggregation)` 计算排除 null 的列的包含扫描。
`ColumnVector`	`scan(ScanAggregation aggregation, ScanType scanType)` 计算排除 null 的列的扫描。
`ColumnVector`	`scan(ScanAggregation aggregation, ScanType scanType, NullPolicy nullPolicy)` 计算列的扫描。
`ColumnVector`	`second()` 从具有时间分辨率的时间戳中获取秒。
`ColumnVector`	`segmentedGather(ColumnView gatherMap)` 分段收集列表列中每行列表元素内的元素。
`ColumnVector`	`segmentedGather(ColumnView gatherMap, OutOfBoundsPolicy policy)` 分段收集列表列中每行列表元素内的元素。
`ColumnVector`	`segmentedReduce(ColumnView offsets, SegmentedReductionAggregation aggregation)` 执行分段归约，其中 offsets 列指示要合并的 this 中的组。
`ColumnVector`	`segmentedReduce(ColumnView offsets, SegmentedReductionAggregation aggregation, DType outType)` 执行分段归约，其中 offsets 列指示要合并的 this 中的组。
`ColumnVector`	`segmentedReduce(ColumnView offsets, SegmentedReductionAggregation aggregation, NullPolicy nullPolicy, DType outType)` 执行分段归约，其中 offsets 列指示要合并的 this 中的组。
`ColumnVector`	`sin()` 计算 sin，输出类型与输入类型相同。
`ColumnVector`	`sinh()` 计算双曲 sin，输出类型与输入类型相同。
`ColumnVector[]`	`slice(int... indices)` 根据一组索引将列（包括 null 值）切片为一组列。
`ColumnVector[]`	`split(int... indices)` 根据一组索引将列（包括 null 值）分割为一组列。
`ColumnView[]`	`splitAsViews(int... indices)` 根据一组索引将 ColumnView（包括 null 值）分割为一组 ColumnViews。
`ColumnVector`	`sqrt()` 计算平方根，输出类型与输入类型相同。
`Scalar`	`standardDeviation()` 返回列中所有值的样本标准差，返回 FLOAT64 标量，除非列类型为 FLOAT32，此时返回 FLOAT32 标量。
`Scalar`	`standardDeviation(DType outType)` 返回列中所有值的样本标准差，返回指定类型的标量。
`ColumnVector`	`startsWith(Scalar pattern)` 检查列中的每个字符串是否以指定的比较字符串开头，生成一个布尔结果的并行列。
`ColumnVector`	`stringConcatenateListElements(ColumnView sepCol)` 给定一个字符串列表列（每行是一个字符串列表），连接每行内的字符串并返回一个字符串列结果。
`ColumnVector`	`stringConcatenateListElements(ColumnView sepCol, Scalar separatorNarep, Scalar stringNarep, boolean separateNulls, boolean emptyStringOutputIfEmptyList)` 给定一个字符串列表列（每行是一个字符串列表），连接每行内的字符串并返回一个字符串列结果。
`ColumnVector`	`stringConcatenateListElements(Scalar separator, Scalar narep, boolean separateNulls, boolean emptyStringOutputIfEmptyList)` 给定一个字符串列表列（每行是一个字符串列表），连接每行内的字符串并返回一个字符串列结果。
`ColumnVector[]`	`stringContains(ColumnView targets)`
`ColumnVector`	`stringContains(Scalar compString)` 检查列中的每个字符串是否包含指定的比较字符串，生成一个布尔结果的并行列。
`ColumnVector`	`stringLocate(Scalar substring)` 定位给定字符串在列中每行第一个实例的起始索引。
`ColumnVector`	`stringLocate(Scalar substring, int start)` 定位给定字符串在列中每行第一个实例的起始索引。
`ColumnVector`	`stringLocate(Scalar substring, int start, int end)` 定位给定字符串在列中每行第一个实例的起始索引。
`ColumnVector`	`stringReplace(ColumnView targets, ColumnView repls)` 返回一个新的字符串列，其中每个字符串中的目标字符串都被相应的替换字符串替换。
`ColumnVector`	`stringReplace(Scalar target, Scalar replace)` 返回一个新的字符串列，其中每个字符串中的目标字符串都被指定的替换字符串替换。
`ColumnVector`	`stringReplaceWithBackrefs(RegexProgram regexProg, String replace)` 对于每个字符串，使用反向引用替换模板替换匹配给定 regex program 模式的任何字符序列。
`ColumnVector`	`stringReplaceWithBackrefs(String pattern, String replace)` 已弃用。
`Table`	`stringSplit(RegexProgram regexProg)` 通过使用指定的 regex program 模式分割每个字符串来返回列的列表。
`Table`	`stringSplit(RegexProgram regexProg, int limit)` 通过使用指定的 regex program 模式分割每个字符串来返回列的列表。
`Table`	`stringSplit(String delimiter)` 通过使用指定的字符串字面量分隔符分割每个字符串来返回列的列表。
`Table`	`stringSplit(String pattern, boolean splitByRegex)` 已弃用。
`Table`	`stringSplit(String delimiter, int limit)` 通过使用指定的字符串字面量分隔符分割每个字符串来返回列的列表。
`Table`	`stringSplit(String pattern, int limit, boolean splitByRegex)` 已弃用。
`ColumnVector`	`stringSplitRecord(RegexProgram regexProg)` 返回一个列，其中每个列表都是通过使用指定的 regex program 模式分割相应输入字符串而生成的字符串列表。
`ColumnVector`	`stringSplitRecord(RegexProgram regexProg, int limit)` 返回一个列，其中每个列表都是通过使用指定的 regex program 模式分割相应输入字符串而生成的字符串列表。
`ColumnVector`	`stringSplitRecord(String delimiter)` 返回一个列，其中每个列表都是通过使用指定的字符串字面量分隔符分割相应输入字符串而生成的字符串列表。
`ColumnVector`	`stringSplitRecord(String pattern, boolean splitByRegex)` 已弃用。
`ColumnVector`	`stringSplitRecord(String delimiter, int limit)` 返回一个列，其中每个列表都是通过使用指定的字符串字面量分隔符分割相应输入字符串而生成的字符串列表。
`ColumnVector`	`stringSplitRecord(String pattern, int limit, boolean splitByRegex)` 已弃用。
`ColumnVector`	`strip()` 移除字符串开头和末尾的空白字符。
`ColumnVector`	`strip(Scalar toStrip)` 移除每个字符串开头和末尾指定的字符。
`ColumnVector`	`substring(ColumnView start, ColumnView end)` 返回一个新的字符串列，其中包含给定列中字符串的子字符串，对每个字符串使用唯一的范围。
`ColumnVector`	`substring(int start)` 返回一个新的字符串列，其中包含给定列中字符串的子字符串。
`ColumnVector`	`substring(int start, int end)` 返回一个新的字符串列，其中包含给定列中字符串的子字符串。
`ColumnVector`	`subVector(int start)` 返回从 start（包含）到向量末尾的子向量。
`ColumnVector`	`subVector(int start, int end)` 返回子向量。
`Scalar`	`sum()` 计算列中所有值的总和，返回与此列相同类型的标量。
`Scalar`	`sum(DType outType)` 计算列中所有值的总和，返回指定类型的标量。
`Scalar`	`sumOfSquares()` 返回列中所有值的平方和，返回与此列相同类型的标量。
`Scalar`	`sumOfSquares(DType outType)` 返回列中所有值的平方和，返回指定类型的标量。
`ColumnVector`	`tan()` 计算 tan，输出类型与输入类型相同。
`ColumnVector`	`tanh()` 计算双曲 tan，输出类型与输入类型相同。
`protected static long`	`title(long handle)`
`ColumnVector`	`toHex()` 将此整数列转换为十六进制列并返回一个新的字符串列。任何 null 条目都将在输出列中生成相应的 null 条目。
`String`	`toString()`
`ColumnVector`	`toTitle()` 返回一个字符串列，其中对于输入的每个字符串行，空格后的第一个字符被转换为大写，而单词中所有剩余字符被转换为小写。
`ColumnVector`	`transform(String udf, boolean isPtx)` 使用自定义函数转换向量。
`ColumnVector`	`unaryOp(UnaryOp op)` 多种不同的一元操作。输出类型与输入类型相同。
`ColumnVector`	`upper()` 将字符串转换为大写。
`ColumnVector`	`urlDecode()` 将所有以 '%' 开头的字符序列转换为字符代码点，将后面的两个字符解释为十六进制值以创建代码点。
`ColumnVector`	`urlEncode()` 将大多数非 ASCII 字符和控制字符转换为以 '%' 为前缀的 UTF-8 十六进制代码点。
`Scalar`	`variance()` 返回列中所有值的方差，返回 FLOAT64 标量，除非列类型为 FLOAT32，此时返回 FLOAT32 标量。
`Scalar`	`variance(DType outType)` 返回列中所有值的方差，返回指定类型的标量。
`ColumnVector`	`weekDay()` 从时间戳中获取星期几。
`ColumnVector`	`year()` 从时间戳中获取年份。
`ColumnVector`	`zfill(int width)` 在每个字符串左侧添加 '0' 作为填充。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface ai.rapids.cudf.BinaryOperable
add, add, and, and, arctan2, arctan2, bitAnd, bitAnd, bitOr, bitOr, bitXor, bitXor, div, div, equalTo, equalTo, equalToNullAware, equalToNullAware, floorDiv, floorDiv, greaterOrEqualTo, greaterOrEqualTo, greaterThan, greaterThan, implicitConversion, lessOrEqualTo, lessOrEqualTo, lessThan, lessThan, log, log, maxNullAware, maxNullAware, minNullAware, minNullAware, mod, mod, mul, mul, notEqualTo, notEqualTo, notEqualToNullAware, notEqualToNullAware, or, or, pmod, pmod, pow, pow, shiftLeft, shiftLeft, shiftRight, shiftRight, shiftRightUnsigned, shiftRightUnsigned, sub, sub, trueDiv, trueDiv

- Field Detail
  - UNKNOWN_NULL_COUNT
```
public static final long UNKNOWN_NULL_COUNT
```
    See Also
    
    Constant Field Values
  - viewHandle
```
protected long viewHandle
```
  - type
```
protected final DType type
```
  - rows
```
protected final long rows
```
  - nullCount
```
protected final long nullCount
```
  - offHeap
```
protected final ColumnVector.OffHeapState offHeap
```
- Constructor Detail
  - ColumnView
```
protected ColumnView(ColumnVector.OffHeapState state)
```
    旨在从 ColumnVector 构建时调用。因为状态会创建一个 cudf::column_view 实例并在所有情况下都会关闭它，所以我们不想重复关闭它。这断言如果 offHeapState 是嵌套类型，则它不包含非空 null
    
    Parameters
    
    state - 此视图基于的状态。
    
    Throws
    
    AssertionError - 如果 offHeapState 指向包含非空 null 的嵌套类型视图
  - ColumnView
```
public ColumnView(DType type,
                  long rows,
                  Optional<Long> nullCount,
                  BaseDeviceMemoryBuffer validityBuffer,
                  BaseDeviceMemoryBuffer offsetBuffer,
                  ColumnView[] children)
```
    基于设备上已有的数据创建一个新列视图。缓冲区上的引用计数未增加，并且此视图不拥有任何底层缓冲区。返回的 ColumnView 仅在底层缓冲区有效时有效。如果缓冲区在此 ColumnView 关闭之前关闭，将导致未定义行为。如果需要所有权，请调用 copyToColumnVector()
    
    Parameters
    
    type - 向量的类型
    
    rows - 此向量中的行数。
    
    nullCount - 数据集中的 null 数。
    
    validityBuffer - 可选的有效性缓冲区。如果 nullCount != 0，则必须提供。此缓冲区的所有权不会更改。
    
    offsetBuffer - 嵌套类型（包括字符串和字符串类别）所需的主机缓冲区。此缓冲区的所有权不会更改。
    
    children - ColumnView 子项数组
  - ColumnView
```
public ColumnView(DType type,
                  long rows,
                  Optional<Long> nullCount,
                  BaseDeviceMemoryBuffer dataBuffer,
                  BaseDeviceMemoryBuffer validityBuffer)
```
    基于设备上已有的数据创建一个新列视图。缓冲区上的引用计数未增加，并且此视图不拥有任何底层缓冲区。返回的 ColumnView 仅在底层缓冲区有效时有效。如果缓冲区在此 ColumnView 关闭之前关闭，将导致未定义行为。如果需要所有权，请调用 copyToColumnVector()
    
    Parameters
    
    type - 向量的类型
    
    rows - 此向量中的行数。
    
    nullCount - 数据集中的 null 数。
    
    dataBuffer - 嵌套类型（包括字符串和字符串类别）所需的主机缓冲区。此缓冲区的所有权不会更改。
    
    validityBuffer - 可选的有效性缓冲区。如果 nullCount != 0，则必须提供。此缓冲区的所有权不会更改。
  - ColumnView
```
public ColumnView(DType type,
                  long rows,
                  Optional<Long> nullCount,
                  BaseDeviceMemoryBuffer dataBuffer,
                  BaseDeviceMemoryBuffer validityBuffer,
                  BaseDeviceMemoryBuffer offsetBuffer)
```
    基于设备上已有的数据创建一个新列视图。缓冲区上的引用计数未增加，并且此视图不拥有任何底层缓冲区。返回的 ColumnView 仅在底层缓冲区有效时有效。如果缓冲区在此 ColumnView 关闭之前关闭，将导致未定义行为。如果需要所有权，请调用 copyToColumnVector()
    
    Parameters
    
    type - 向量的类型
    
    rows - 此向量中的行数。
    
    nullCount - 数据集中的 null 数。
    
    dataBuffer - 嵌套类型（包括字符串和字符串类别）所需的主机缓冲区。此缓冲区的所有权不会更改。
    
    validityBuffer - 可选的有效性缓冲区。如果 nullCount != 0，则必须提供。此缓冲区的所有权不会更改。
    
    offsetBuffer - 需要偏移缓冲区的列的偏移缓冲区。
- Method Detail
  - copyToColumnVector
```
public ColumnVector copyToColumnVector()
```
    从列视图句柄创建一个 ColumnVector
    
    Returns
    
    新的 ColumnVector
  - getNativeView
```
public final long getNativeView()
```
    谨慎使用：此方法公开本机 cudf::column_view 的地址。这允许对数据编写自定义内核或其他 cuda 操作。在完全使用完本机 column_view 之前，请勿关闭此 column vector。请勿以任何方式修改该列。应将其视为只读数据结构。此 API 不稳定，因为底层的 C/C++ API 尚未稳定。如果底层数据结构重命名，此 API 可能会被替换。底层数据结构在不同版本之间可能会发生变化（尚未稳定），因此请确保您的本机代码与发布此版本所使用的 libcudf 版本完全相同。
  - getType
```
public final DType getType()
```
    Description copied from interface: BinaryOperable
    
    获取此数据的类型。
    
    Specified by
    
    getType in interface BinaryOperable
  - getChildColumnViews
```
public final ColumnView[] getChildColumnViews()
```
    返回此视图的子列视图。请注意，调用者有责任关闭这些视图。
    
    Returns
    
    子列视图数组
  - getChildColumnView
```
public final ColumnView getChildColumnView(int childIndex)
```
    返回给定索引处的子列视图。请注意，调用者负责关闭此视图。
    
    Parameters
    
    childIndex - 子索引
    
    Returns
    
    列视图
  - getListOffsetsView
```
public ColumnView getListOffsetsView()
```
    获取作为此列表偏移量的 ColumnView。请注意，调用者负责关闭此视图，并且父列必须比此视图存在时间更长。
  - getData
```
public final BaseDeviceMemoryBuffer getData()
```
    获取当前列视图（viewHandle）的数据缓冲区。如果类型为 LIST、STRUCT，则返回 null。
    
    Returns
    
    如果类型为 LIST、STRUCT 或数据缓冲区为空，则返回 null，否则返回数据设备缓冲区。
  - getOffsets
```
public final BaseDeviceMemoryBuffer getOffsets()
```
  - getValid
```
public final BaseDeviceMemoryBuffer getValid()
```
  - getNullCount
```
public long getNullCount()
```
    返回数据中的 null 数。请注意，这最终可能成为一个非常耗时的操作，因为如果 null 数未知，则会进行计算。
  - getRowCount
```
public final long getRowCount()
```
    返回此向量中的行数。
  - getNumChildren
```
public final int getNumChildren()
```
  - getDeviceMemorySize
```
public long getDeviceMemorySize()
```
    返回使用的设备内存量。
  - close
```
public void close()
```
    Specified by
    
    close in interface AutoCloseable
  - toString
```
public String toString()
```
    Overrides
    
    toString in class Object
  - nansToNulls
```
public final ColumnVector nansToNulls()
```
    返回一个新 ColumnVector，其中 NaN 已转换为 null，并保留现有 null 值。
  - getCharLengths
```
public final ColumnVector getCharLengths()
```
    检索每个字符串中的字符数。Null 字符串的值将为 null。
    
    Returns
    
    ColumnVector 包含原始向量中索引 'i' 处字符串的长度。
  - getByteCount
```
public final ColumnVector getByteCount()
```
    检索每个字符串的字节数。Null 字符串的值将为 null。
    
    Returns
    
    ColumnVector，其中索引 'i' 处的每个元素 = 原始向量中索引 'i' 处字符串的字节数。
  - codePoints
```
public final ColumnVector codePoints()
```
    获取每个字符串中每个字符的代码点值（整数）。
    
    Returns
    
    ColumnVector，包含每个字符的代码点整数值（作为 INT32）。
  - countElements
```
public final ColumnVector countElements()
```
    获取每个列表的元素数。Null 列表的值将为 null。
    
    Returns
    
    每个列表中的元素数（作为 INT32 值）。
  - isNotNull
```
public final ColumnVector isNotNull()
```
    返回一个与此实例行数相同的布尔向量，对于非 null 条目为 TRUE，对于 null 条目为 FALSE（根据有效性掩码）。
    
    Returns
    
    - 布尔向量
  - isNull
```
public final ColumnVector isNull()
```
    返回一个与此实例行数相同的布尔向量，对于非 null 条目为 FALSE，对于 null 条目为 TRUE（根据有效性掩码）。
    
    Returns
    
    - 布尔向量
  - isFixedPoint
```
public final ColumnVector isFixedPoint(DType decimalType)
```
    返回一个与此实例行数相同的布尔向量，对于定点数条目为 TRUE，否则为 FALSE。对于 null 条目将返回 null。符号和指数是可选的。小数点只能出现一次。整数部分必须符合底层定点存储类型的大小限制。整数部分的值基于目标 decimalType 的 scale。示例：vec = ["A", "nan", "Inf", "-Inf", "Infinity", "infinity", "2.1474", "112.383", "-2.14748", "NULL", "null", null, "1.2", "1.2e-4", "0.00012"] vec.isFixedPoint() = [false, false, false, false, false, false, true, true, true, false, false, null, true, true, true]
    
    Parameters
    
    decimalType - 用于边界检查的数据类型。请注意，只允许使用 Decimal 类型（定点）。
    
    Returns
    
    布尔向量
  - isInteger
```
public final ColumnVector isInteger()
```
    返回一个与此实例行数相同的布尔向量，对于整数条目为 TRUE，否则为 FALSE。对于 null 条目将返回 null。注意：整数不意味着 32 位整数。它意味着一个不是分数的数字。即，如果此方法对于某个值返回 true，则将其转换为 Java 整数类型时仍可能导致溢出或下溢。
    
    Returns
    
    布尔向量
  - isInteger
```
public final ColumnVector isInteger(DType intType)
```
    返回一个与此实例行数相同的布尔向量，对于整数条目为 TRUE，否则为 FALSE。对于 null 条目将返回 null。
    
    Parameters
    
    intType - 用于边界检查的数据类型。请注意，只允许使用 cudf 整数类型，包括有符号/无符号 int8 到 int64。
    
    Returns
    
    布尔向量
  - isFloat
```
public final ColumnVector isFloat()
```
    返回一个与此实例行数相同的布尔向量，对于浮点数条目为 TRUE，否则为 FALSE。对于 null 条目将返回 null。注意：浮点数不意味着 32 位浮点数。它意味着一个分数或可以写成分数的数字。即，此方法对于整数和浮点数都将返回 true。另请注意，如果此方法对于某个值返回 true，则将其转换为 Java float 或 double 时仍可能导致溢出或下溢。
    
    Returns
    
    - 布尔向量
  - isNan
```
public final ColumnVector isNan()
```
    返回一个与此实例行数相同的布尔向量，对于 NaN 条目为 TRUE，如果为 null 或有效浮点值为 FALSE。
    
    Returns
    
    - 布尔向量
  - isNotNan
```
public final ColumnVector isNotNan()
```
    返回一个与此实例行数相同的布尔向量，对于 null 或有效浮点数值为 TRUE，否则为 FALSE。
    
    Returns
    
    - 布尔向量
  - findAndReplaceAll
```
public final ColumnVector findAndReplaceAll(ColumnView oldValues,
                                            ColumnView newValues)
```
    返回一个向量，其中所有值 "oldValues[i]" 都替换为 "newValues[i]"。警告：目前此函数不适用于 Strings 或 StringCategories。NaN 不能在原始向量中替换，但可以将常规值替换为 NaN。Null 不能在原始向量中替换，但可以将常规值替换为 Null。不允许混合类型，结果向量将与原始向量类型相同。例如：不能用来自 long 向量的值替换 integer 向量。用法：this = {1, 4, 5, 1, 5} oldValues = {1, 5, 7} newValues = {2, 6, 9} result = this.findAndReplaceAll(oldValues, newValues); result = {2, 4, 6, 2, 6} (1 和 5 替换为 2 和 6，但未找到 7，因此没有变化)
    
    Parameters
    
    oldValues - - 包含应替换的值的向量
    
    newValues - - 包含新值的向量
    
    Returns
    
    - 一个新的向量，其中旧值已替换为新值。
  - replaceNulls
```
public final ColumnVector replaceNulls(Scalar scalar)
```
    返回一个 ColumnVector，其中所有 null 值都替换为标量。输入 ColumnVector 和标量的类型必须匹配，否则会抛出错误。
    
    Parameters
    
    scalar - - 用作替换的标量值。
    
    Returns
    
    - 已将 null 替换为标量的 ColumnVector。
  - replaceNulls
```
public final ColumnVector replaceNulls(ColumnView replacements)
```
    返回一个 ColumnVector，其中所有 null 值都替换为指定替换列中的相应行。此列和替换列必须具有相同的类型和行数。
    
    Parameters
    
    replacements - 替换值列
    
    Returns
    
    已将 null 替换为 replacements 列相应行的列
  - replaceNulls
```
public final ColumnVector replaceNulls(ReplacePolicy policy)
```
  - ifElse
```
public final ColumnVector ifElse(ColumnView trueValues,
                                 ColumnView falseValues)
```
    对于 BOOL8 向量，根据此向量在相应行中的布尔值，计算一个其行从其他两个向量中选择的向量。如果行中的布尔值为 true，则从 trueValues 中选择相应行，否则从 falseValues 中选择相应行。请注意，trueValues 和 falseValues 向量必须与此向量长度相同，并且 trueValues 和 falseValues 必须具有相同的数据类型。
    
    Parameters
    
    trueValues - 如果此列中的行为 true，则选择的值
    
    falseValues - 如果此列中的行为不 true，则选择的值
    
    Returns
    
    计算出的向量
  - ifElse
```
public final ColumnVector ifElse(ColumnView trueValues,
                                 Scalar falseValue)
```
    对于 BOOL8 向量，根据此向量在相应行中的布尔值，计算一个其行从其他两个输入中选择的向量。如果行中的布尔值为 true，则从 trueValues 中选择相应行，否则选择 falseValue 的值。请注意，trueValues 必须与此向量长度相同，并且 trueValues 和 falseValue 必须具有相同的数据类型。请注意，trueValues 向量和 falseValue 标量必须具有相同的数据类型。
    
    Parameters
    
    trueValues - 如果此列中的行为 true，则选择的值
    
    falseValue - 如果此列中的行为不 true，则选择的值
    
    Returns
    
    计算出的向量
  - ifElse
```
public final ColumnVector ifElse(Scalar trueValue,
                                 ColumnView falseValues)
```
    对于 BOOL8 向量，根据此向量在相应行中的布尔值，计算一个其行从其他两个输入中选择的向量。如果行中的布尔值为 true，则选择 trueValue 的值，否则从 falseValues 中选择相应行。请注意，falseValues 必须与此向量长度相同，并且 trueValue 和 falseValues 必须具有相同的数据类型。请注意，trueValue 标量和 falseValues 向量必须具有相同的数据类型。
    
    Parameters
    
    trueValue - 如果此列中的行为 true，则选择的值
    
    falseValues - 如果此列中的行为不 true，则选择的值
    
    Returns
    
    计算出的向量
  - ifElse
```
public final ColumnVector ifElse(Scalar trueValue,
                                 Scalar falseValue)
```
    对于 BOOL8 向量，根据此向量在相应行中的布尔值，计算一个其行从其他两个输入中选择的向量。如果行中的布尔值为 true，则选择 trueValue 的值，否则选择 falseValue 的值。请注意，trueValue 和 falseValue 标量必须具有相同的数据类型。
    
    Parameters
    
    trueValue - 如果此列中的行为 true，则选择的值
    
    falseValue - 如果此列中的行为不 true，则选择的值
    
    Returns
    
    计算出的向量
  - slice
```
public final ColumnVector[] slice(int... indices)
```
    根据一组索引将列（包括 null 值）切片为一组列。调用者拥有 ColumnVectors 并负责关闭它们。"slice" 函数使用索引值将输入列的一部分划分为多个行间隔，并将这些间隔存储到输出列中。关于索引间隔，从 indices 数组中连续取出一对值。这对索引是左闭右开的。数组中的索引对需要满足以下条件：a, b 属于 Range[0, input column size] a <= b，其中 a 的位置小于或等于 b 的位置。索引数组的特殊情况是：当对中的值相等时，函数返回空列。当对中的值“严格递减”时，结果未定义。当对中的任何值不属于范围[0, input column size) 时，结果未定义。当 indices 数组为空时，返回一个空的列向量。调用者拥有输出 ColumnVectors 并负责关闭它们。
    
    Parameters
    
    indices -
    
    Returns
    
    一个包含原始 ColumnVector 切片的新 ColumnVector 数组。
  - subVector
```
public final ColumnVector subVector(int start)
```
    返回从 start（包含）到向量末尾的子向量。
    
    Parameters
    
    start - 起始索引（包含）。
  - subVector
```
public final ColumnVector subVector(int start,
                                    int end)
```
    返回子向量。
    
    Parameters
    
    start - 起始索引（包含）。
    
    end - 结束索引（不包含）。
  - split
```
public final ColumnVector[] split(int... indices)
```
    根据一组索引将列（包括 null 值）分割为一组列。调用者拥有 ColumnVectors 并负责关闭它们。"split" 函数使用分割索引值将输入列分割为多个行间隔，并将这些间隔存储到输出列中。关于索引间隔，从 indices 数组中连续取出一对值。这对索引是左闭右开的。索引数组（'splits'）需要是单调非递减的集合。数组中的索引需要满足以下条件：a, b 属于 Range[0, input column size] a <= b，其中 a 的位置小于或等于 b 的位置。split 函数将从 indices 数组（'splits'）中连续取出一对索引。对于第一对，函数将取值 0 和 indices 数组的第一个元素。对于最后一对，函数将取 indices 数组的最后一个元素和输入列的大小。索引数组的特殊情况是：当对中的值相等时，函数返回空列。当对中的值“严格递减”时，结果未定义。当对中的任何值不属于范围[0, input column size) 时，结果未定义。当 indices 数组为空时，返回一个空的列向量。输入列的大小可能不同。列的数量必须等于数组中的索引数量加一。示例：input: {10, 12, 14, 16, 18, 20, 22, 24, 26, 28} splits: {2, 5, 9} output: {{10, 12}, {14, 16, 18}, {20, 22, 24, 26}, {28}} 注意，这与 PartitionedTable 的输出非常相似。
    
    Parameters
    
    indices - 用于分割的索引。
    
    Returns
    
    一个包含原始 ColumnVector 切片的新 ColumnVector 数组。
  - splitAsViews
```
public ColumnView[] splitAsViews(int... indices)
```
    根据一组索引将 ColumnView（包括 null 值）分割为一组 ColumnViews。不移动或复制数据。重要说明：不会从向量中复制任何内容，并且切片仅在底层 ColumnVector 的生命周期内有效。"split" 函数使用分割索引值将输入列分割为多个行间隔，并将这些间隔存储到输出列中。关于索引间隔，从 indices 数组中连续取出一对值。这对索引是左闭右开的。索引数组（'splits'）需要是单调非递减的集合。数组中的索引需要满足以下条件：a, b 属于 Range[0, input column size] a <= b，其中 'a' 的位置小于或等于 'b' 的位置。split 函数将从 indices 数组（'splits'）中连续取出一对索引。对于第一对，函数将取值 0 和 indices 数组的第一个元素。对于最后一对，函数将取 indices 数组的最后一个元素和输入列的大小。索引数组的特殊情况是：当对中的值相等时，函数返回空列。当对中的值“严格递减”时，结果未定义。当对中的任何值不属于范围[0, input column size) 时，结果未定义。当 indices 数组为空时，返回一个空的 ColumnViews 数组。输出列的大小可能不同。列的数量必须等于数组中的索引数量加一。示例：input: {10, 12, 14, 16, 18, 20, 22, 24, 26, 28} splits: {2, 5, 9} output: {{10, 12}, {14, 16, 18}, {20, 22, 24, 26}, {28}} 注意，这与 PartitionedTable 的输出非常相似。
    
    Parameters
    
    indices - 用于分割的索引。
    
    Returns
    
    一个包含原始 ColumnView 切片的新 ColumnView 数组。
  - normalizeNANsAndZeros
```
public final ColumnVector normalizeNANsAndZeros()
```
    创建一个“标准化”值的新向量，其中：1. NaN（和 -NaN）的所有表示都替换为标准化的 NaN 值 2. 所有等于 0.0 的元素（包括 +0.0 和 -0.0）都替换为 +0.0。3. 所有不等于 NaN 或 0.0 的元素保持不变。Double.longBitsToDouble(long) 的文档描述了 NaN/-NaN 的等效值可能有不同的位表示。此方法可用于将 0.0 或 NaN 的不同位值比较为逻辑等效。例如，如果这些值出现在 groupby 键列中，如果没有标准化，0.0 和 -0.0 将被错误地视为不同的组，每个 NaN 的表示也是如此。
    
    Returns
    
    一个新的 ColumnVector，其中所有等于 NaN/0.0 的元素都被替换为标准化的等效值。
  - mergeAndSetValidity
```
public final ColumnVector mergeAndSetValidity(BinaryOp mergeOp,
                                              ColumnView... columns)
```
    创建一个列的深拷贝，同时替换 null 掩码。结果 null 掩码是作为参数给定的列中 null 掩码的按位合并。对于嵌套类型，结果将被清除，不包含任何非空 null。
    
    Parameters
    
    mergeOp - 二元运算符（仅限 BITWISE_AND 和 BITWISE_OR）
    
    columns - 其 null 掩码被合并的列数组，必须具有相同的行数。
    
    Returns
    
    具有合并 null 掩码的新 ColumnVector。
  - extractDateTimeComponent
```
public final ColumnVector extractDateTimeComponent(DateTimeComponent component)
```
    从时间戳中提取特定的日期时间组件。
    
    Parameters
    
    component - 应提取的内容。
    
    Returns
    
    一个包含提取信息的列。
  - year
```
public final ColumnVector year()
```
    从时间戳中获取年份。
    后置条件 - 分配了一个包含结果的新向量。调用者拥有该向量并负责其生命周期。
    
    Returns
    
    - 在 GPU 上分配的一个新的 INT16 向量。
  - month
```
public final ColumnVector month()
```
    从时间戳中获取月份。
    后置条件 - 分配了一个包含结果的新向量。调用者拥有该向量并负责其生命周期。
    
    Returns
    
    - 在 GPU 上分配的一个新的 INT16 向量。
  - day
```
public final ColumnVector day()
```
    从时间戳中获取日期。
    后置条件 - 分配了一个包含结果的新向量。调用者拥有该向量并负责其生命周期。
    
    Returns
    
    - 在 GPU 上分配的一个新的 INT16 向量。
  - hour
```
public final ColumnVector hour()
```
    从具有时间分辨率的时间戳中获取小时。
    后置条件 - 分配了一个包含结果的新向量。调用者拥有该向量并负责其生命周期。
    
    Returns
    
    - 在 GPU 上分配的一个新的 INT16 向量。
  - minute
```
public final ColumnVector minute()
```
    从具有时间分辨率的时间戳中获取分钟。
    后置条件 - 分配了一个包含结果的新向量。调用者拥有该向量并负责其生命周期。
    
    Returns
    
    - 在 GPU 上分配的一个新的 INT16 向量。
  - second
```
public final ColumnVector second()
```
    从具有时间分辨率的时间戳中获取秒。
    后置条件 - 分配了一个包含结果的新向量。调用者拥有该向量并负责其生命周期。
    
    Returns
    
    在 GPU 上分配的一个新的 INT16 向量。
  - weekDay
```
public final ColumnVector weekDay()
```
    从时间戳中获取星期几。
    后置条件 - 分配了一个包含结果的新向量。调用者拥有该向量并负责其生命周期。
    
    Returns
    
    在 GPU 上分配的一个新的 INT16 向量。Monday=1, ..., Sunday=7
  - lastDayOfMonth
```
public final ColumnVector lastDayOfMonth()
```
    获取此时间戳所在月份的最后一天日期。
    后置条件 - 分配了一个包含结果的新向量。调用者拥有该向量并负责其生命周期。
    
    Returns
    
    在 GPU 上分配的一个新的 TIMESTAMP_DAYS 向量。
  - dayOfYear
```
public final ColumnVector dayOfYear()
```
    从时间戳中获取一年中的第几天。
    后置条件 - 分配了一个包含结果的新向量。调用者拥有该向量并负责其生命周期。
    
    Returns
    
    在 GPU 上分配的一个新的 INT16 向量。其值在 [1, {365-366}] 之间。
  - quarterOfYear
```
public final ColumnVector quarterOfYear()
```
    从时间戳中获取季度。
    
    Returns
    
    在 GPU 上分配的一个新的 INT16 向量。它将是对应于该年季度的 {1, 2, 3, 4} 中的一个值。
  - addCalendricalMonths
```
public final ColumnVector addCalendricalMonths(ColumnView months)
```
    将指定数量的月添加到时间戳。
    
    Parameters
    
    months - 必须是一个 INT16 列，表示要添加的月数。负数月也有效。
    
    Returns
    
    更新后的时间戳。
  - addCalendricalMonths
```
public final ColumnVector addCalendricalMonths(Scalar months)
```
    将指定数量的月添加到时间戳。
    
    Parameters
    
    months - 必须是一个 INT16 标量，表示要添加的月数。负数月也有效。
    
    Returns
    
    更新后的时间戳。
  - isLeapYear
```
public final ColumnVector isLeapYear()
```
    检查此时间戳的年份是否为闰年。
    
    Returns
    
    结果的 BOOL8 向量
  - daysInMonth
```
public final ColumnVector daysInMonth()
```
    提取月份中的天数
    
    Returns
    
    相应月份天数的 INT16 列。
  - dateTimeCeil
```
public final ColumnVector dateTimeCeil(DateTimeRoundingFrequency freq)
```
    将时间戳向上舍入到给定频率，保持类型不变。
    
    Parameters
    
    freq - 要舍入的时间戳部分。
    
    Returns
    
    类型相同但向上舍入的时间戳。
  - dateTimeFloor
```
public final ColumnVector dateTimeFloor(DateTimeRoundingFrequency freq)
```
    将时间戳向下舍入到给定频率，保持类型不变。
    
    Parameters
    
    freq - 要舍入的时间戳部分。
    
    Returns
    
    类型相同但向下舍入的时间戳。
  - dateTimeRound
```
public final ColumnVector dateTimeRound(DateTimeRoundingFrequency freq)
```
    将时间戳（四舍五入）舍入到给定频率，保持类型不变。
    
    Parameters
    
    freq - 要舍入的时间戳部分。
    
    Returns
    
    类型相同但四舍五入（四舍五入到最接近的偶数）的时间戳。
  - round
```
public ColumnVector round(int decimalPlaces,
                          RoundMode mode)
```
    将列中的所有值四舍五入到指定的小数位数。
    
    Parameters
    
    decimalPlaces - 舍入到的小数位数。如果为负数，则指定小数点左侧的位数。
    
    mode - 舍入方法（HALF_UP 或 HALF_EVEN）
    
    Returns
    
    一个包含四舍五入值的新 ColumnVector。
  - round
```
public ColumnVector round(RoundMode round)
```
    将列中的所有值四舍五入，小数位数为 0。默认的小数位数为 0。
    
    Parameters
    
    round - 舍入方法（HALF_UP 或 HALF_EVEN）
    
    Returns
    
    一个包含四舍五入值的新 ColumnVector。
  - round
```
public ColumnVector round(int decimalPlaces)
```
    使用 HALF_UP（默认）作为四舍五入方法，将列中的所有值四舍五入到指定的小数位数。
    
    Parameters
    
    decimalPlaces - 舍入到的小数位数。如果为负数，则指定小数点左侧的位数。
    
    Returns
    
    一个包含四舍五入值的新 ColumnVector。
  - round
```
public ColumnVector round()
```
    使用这些默认值四舍五入列中的所有值： decimalPlaces = 0 Rounding method = RoundMode.HALF_UP
    
    Returns
    
    一个包含四舍五入值的新 ColumnVector。
  - transform
```
public final ColumnVector transform(String udf,
                                    boolean isPtx)
```
    使用自定义函数转换向量。请小心，这并非易事。您需要确定您正在处理的数据类型以及数据的布局方式。这也仅适用于固定长度类型。
    
    Parameters
    
    udf - 此函数将应用于向量中的每个元素。
    
    isPtx - 函数代码是否为 ptx？true 表示 ptx，false 表示 C/C++。
  - unaryOp
```
public final ColumnVector unaryOp(UnaryOp op)
```
    多种不同的一元操作。输出类型与输入类型相同。
    
    Parameters
    
    op - 要执行的操作。
    
    Returns
    
    结果
  - sin
```
public final ColumnVector sin()
```
    计算 sin，输出类型与输入类型相同。
  - cos
```
public final ColumnVector cos()
```
    计算 cos，输出类型与输入类型相同。
  - tan
```
public final ColumnVector tan()
```
    计算 tan，输出类型与输入类型相同。
  - arcsin
```
public final ColumnVector arcsin()
```
    计算 arcsin，输出类型与输入类型相同。
  - arccos
```
public final ColumnVector arccos()
```
    计算 arccos，输出类型与输入类型相同。
  - arctan
```
public final ColumnVector arctan()
```
    计算 arctan，输出类型与输入类型相同。
  - sinh
```
public final ColumnVector sinh()
```
    计算双曲 sin，输出类型与输入类型相同。
  - cosh
```
public final ColumnVector cosh()
```
    计算双曲 cos，输出类型与输入类型相同。
  - tanh
```
public final ColumnVector tanh()
```
    计算双曲 tan，输出类型与输入类型相同。
  - arcsinh
```
public final ColumnVector arcsinh()
```
    计算双曲 arcsin，输出类型与输入类型相同。
  - arccosh
```
public final ColumnVector arccosh()
```
    计算双曲 arccos，输出类型与输入类型相同。
  - arctanh
```
public final ColumnVector arctanh()
```
    计算双曲 arctan，输出类型与输入类型相同。
  - exp
```
public final ColumnVector exp()
```
    计算 exp (指数函数)，输出类型与输入类型相同。
  - log
```
public final ColumnVector log()
```
    计算对数，输出类型与输入类型相同。
  - log2
```
public final ColumnVector log2()
```
    计算以 2 为底的对数，输出类型与输入类型相同。
  - log10
```
public final ColumnVector log10()
```
    计算以 10 为底的对数，输出类型与输入类型相同。
  - sqrt
```
public final ColumnVector sqrt()
```
    计算平方根，输出类型与输入类型相同。
  - cbrt
```
public final ColumnVector cbrt()
```
    计算立方根，输出类型与输入类型相同。
  - ceil
```
public final ColumnVector ceil()
```
    计算向上取整，输出类型与输入类型相同。
  - floor
```
public final ColumnVector floor()
```
    计算向下取整，输出类型与输入类型相同。
  - abs
```
public final ColumnVector abs()
```
    计算绝对值，输出类型与输入类型相同。
  - rint
```
public final ColumnVector rint()
```
    将浮点参数四舍五入到最接近的整数值，但以浮点数形式返回。
  - bitInvert
```
public final ColumnVector bitInvert()
```
    按位取反，输出类型与输入类型相同。
  - binaryOp
```
public final ColumnVector binaryOp(BinaryOp op,
                                   BinaryOperable rhs,
                                   DType outType)
```
    多种不同的二进制运算。
    
    Specified by
    
    binaryOp in interface BinaryOperable
    
    Parameters
    
    op - 要执行的操作。
    
    rhs - 操作的右侧。
    
    outType - 您想要的输出类型。
    
    Returns
    
    结果
  - sum
```
public Scalar sum()
```
    计算列中所有值的总和，返回与此列相同类型的标量。
  - sum
```
public Scalar sum(DType outType)
```
    计算列中所有值的总和，返回指定类型的标量。
  - min
```
public Scalar min()
```
    返回列中所有值的最小值，返回与此列相同类型的标量。
  - min
```
@Deprecated
public Scalar min(DType outType)
```
    已过时。 min 归约不再内部允许设置输出类型，作为替代，此 API 会为您将输入类型转换为输出类型，但这可能并非适用于所有情况。
    
    返回列中所有值的最小值，返回指定类型的标量。
  - max
```
public Scalar max()
```
    返回列中所有值的最大值，返回与此列相同类型的标量。
  - max
```
@Deprecated
public Scalar max(DType outType)
```
    已过时。 max 归约不再内部允许设置输出类型，作为替代，此 API 会为您将输入类型转换为输出类型，但这可能并非适用于所有情况。
    
    返回列中所有值的最大值，返回指定类型的标量。
  - product
```
public Scalar product()
```
    返回列中所有值的乘积，返回与此列相同类型的标量。
  - product
```
public Scalar product(DType outType)
```
    返回列中所有值的乘积，返回指定类型的标量。
  - sumOfSquares
```
public Scalar sumOfSquares()
```
    返回列中所有值的平方和，返回与此列相同类型的标量。
  - sumOfSquares
```
public Scalar sumOfSquares(DType outType)
```
    返回列中所有值的平方和，返回指定类型的标量。
  - mean
```
public Scalar mean()
```
    返回列中所有值的算术平均值，返回 FLOAT64 标量，除非列类型为 FLOAT32，此时返回 FLOAT32 标量。null 值被跳过。
  - mean
```
public Scalar mean(DType outType)
```
    返回列中所有值的算术平均值，返回指定类型的标量。null 值被跳过。
    
    Parameters
    
    outType - 要返回的输出类型。请注意，目前仅支持浮点类型。
  - variance
```
public Scalar variance()
```
    返回列中所有值的方差，返回 FLOAT64 标量，除非列类型为 FLOAT32，此时返回 FLOAT32 标量。null 值被跳过。
  - variance
```
public Scalar variance(DType outType)
```
    返回列中所有值的方差，返回指定类型的标量。null 值被跳过。
    
    Parameters
    
    outType - 要返回的输出类型。请注意，目前仅支持浮点类型。
  - standardDeviation
```
public Scalar standardDeviation()
```
    返回列中所有值的样本标准差，返回 FLOAT64 标量，除非列类型为 FLOAT32，此时返回 FLOAT32 标量。计算标准差时不将 null 计为列的元素。
  - standardDeviation
```
public Scalar standardDeviation(DType outType)
```
    返回列中所有值的样本标准差，返回指定类型的标量。计算标准差时不将 null 计为列的元素。
    
    Parameters
    
    outType - 要返回的输出类型。请注意，目前仅支持浮点类型。
  - any
```
public Scalar any()
```
    返回一个布尔标量，如果列中任何元素为 true 或非零则为 true，否则为 false。null 值被跳过。
  - any
```
public Scalar any(DType outType)
```
    根据指定的类型，返回一个标量，如果列中任何元素为 true 或非零则为 true 或 1，否则为 false 或 0。null 值被跳过。
  - all
```
public Scalar all()
```
    返回一个布尔标量，如果列中所有元素为 true 或非零则为 true，否则为 false。null 值被跳过。
  - all
```
@Deprecated
public Scalar all(DType outType)
```
    已废弃。仅支持的输出类型是 BOOL8。
    
    如果列中的所有元素都为 true 或非零，则返回一个标量值（根据指定类型为 true 或 1），否则返回 false 或 0。空值会被跳过。
  - reduce
```
public Scalar reduce(ReductionAggregation aggregation)
```
    计算列中所有行的值的归约。归约中的溢出不会被检测到。指定更高精度的输出类型可能会防止溢出。MIN 和 MAX 操作仅在非算术类型（TIMESTAMP 等）上受支持。操作会跳过空值。
    
    Parameters
    
    aggregation - 要执行的归约聚合操作。
    
    Returns
    
    归约操作的标量结果。如果列为空或归约操作失败，则结果的 Scalar.isValid() 方法将返回 false。
  - reduce
```
public Scalar reduce(ReductionAggregation aggregation,
                     DType outType)
```
    计算列中所有行的值的归约。归约中的溢出不会被检测到。指定更高精度的输出类型可能会防止溢出。仅 MIN 和 MAX 操作支持非算术类型（TIMESTAMP 等）的归约。操作会跳过空值。
    
    Parameters
    
    aggregation - 要执行的归约聚合操作。
    
    outType - 要返回的标量值类型。并非所有聚合操作都支持所有输出类型。
    
    Returns
    
    归约操作的标量结果。如果列为空或归约操作失败，则结果的 Scalar.isValid() 方法将返回 false。
  - segmentedReduce
```
public ColumnVector segmentedReduce(ColumnView offsets,
                                    SegmentedReductionAggregation aggregation)
```
    执行分段归约，其中偏移量列指示要合并的组。输出类型与输入类型相同。
    
    Parameters
    
    offsets - 一个不含空值的 INT32 列。
    
    aggregation - 要执行的聚合操作。
    
    Returns
    
    结果。
  - segmentedReduce
```
public ColumnVector segmentedReduce(ColumnView offsets,
                                    SegmentedReductionAggregation aggregation,
                                    DType outType)
```
    执行分段归约，其中 offsets 列指示要合并的 this 中的组。
    
    Parameters
    
    offsets - 一个不含空值的 INT32 列。
    
    aggregation - 要执行的聚合操作。
    
    outType - 输出数据类型。
    
    Returns
    
    结果。
  - segmentedReduce
```
public ColumnVector segmentedReduce(ColumnView offsets,
                                    SegmentedReductionAggregation aggregation,
                                    NullPolicy nullPolicy,
                                    DType outType)
```
    执行分段归约，其中 offsets 列指示要合并的 this 中的组。
    
    Parameters
    
    offsets - 一个不含空值的 INT32 列。
    
    aggregation - 要执行的聚合操作。
    
    nullPolicy - 空值策略。
    
    outType - 输出数据类型。
    
    Returns
    
    结果。
  - segmentedGather
```
public ColumnVector segmentedGather(ColumnView gatherMap)
```
    对列表列中每行列表元素进行分段收集。对于每个列表，假设大小为 N，有效的收集映射索引范围在 [-N, N) 内。越界索引引用空值。
    
    Parameters
    
    gatherMap - ListColumnView，包含整数索引列表，用于将源列中每行列表中的元素映射到结果列中的列表行。
    
    Returns
    
    结果。
  - segmentedGather
```
public ColumnVector segmentedGather(ColumnView gatherMap,
                                    OutOfBoundsPolicy policy)
```
    分段收集列表列中每行列表元素内的元素。
    
    Parameters
    
    gatherMap - ListColumnView，包含整数索引列表，用于将源列中每行列表中的元素映射到结果列中的列表行。
    
    policy - OutOfBoundsPolicy，`DONT_CHECK` 会导致未定义行为；`NULLIFY` 会将越界替换为空值。
    
    Returns
    
    结果。
  - listReduce
```
public ColumnVector listReduce(SegmentedReductionAggregation aggregation)
```
    对列表中的值执行归约。输出类型将是此列表数据列的类型。
    
    Parameters
    
    aggregation - 要执行的聚合操作。
  - listReduce
```
public ColumnVector listReduce(SegmentedReductionAggregation aggregation,
                               DType outType)
```
    对列表中的值执行归约。
    
    Parameters
    
    aggregation - 要执行的聚合操作。
    
    outType - 输出类型。通常，这应该与列表的子类型匹配。
  - listReduce
```
public ColumnVector listReduce(SegmentedReductionAggregation aggregation,
                               NullPolicy nullPolicy,
                               DType outType)
```
    对列表中的值执行归约。
    
    Parameters
    
    aggregation - 要执行的聚合操作。
    
    nullPolicy - 聚合是否应包含空值。
    
    outType - 输出类型。通常，这应该与列表的子类型匹配。
  - approxPercentile
```
public final ColumnVector approxPercentile(double[] percentiles)
```
    计算此 ColumnVector 的各种百分位数，该 ColumnVector 必须包含由 t-digest 聚合生成的质心。
    
    Parameters
    
    percentiles - 必需的百分位数 [0,1]
    
    Returns
    
    包含近似百分位数作为双精度浮点数列表的列，顺序与输入百分位数相同。
  - approxPercentile
```
public final ColumnVector approxPercentile(ColumnVector percentiles)
```
    计算此 ColumnVector 的各种百分位数，该 ColumnVector 必须包含由 t-digest 聚合生成的质心。
    
    Parameters
    
    percentiles - 包含百分位数 [0,1] 的列。
    
    Returns
    
    包含近似百分位数作为双精度浮点数列表的列，顺序与输入百分位数相同。
  - quantile
```
public final ColumnVector quantile(QuantileMethod method,
                                   double[] quantiles)
```
    计算此 ColumnVector 的各种分位数。假定此向量已按所需顺序排序。
    
    Parameters
    
    method - 用于计算分位数的方法。
    
    quantiles - 分位数 [0,1] 的值。
    
    Returns
    
    包含近似百分位数作为双精度浮点数列表的列，顺序与输入百分位数相同。
  - rollingWindow
```
public final ColumnVector rollingWindow(RollingAggregation op,
                                        WindowOptions options)
```
    此函数聚合输入列中每个元素 i 周围窗口内的值。有关可传递的各种选项，请参阅 WindowsOptions。注意：仅支持基于行的窗口。
    
    Parameters
    
    op - 要执行的操作。
    
    options - 各种窗口函数参数。
    
    Returns
    
    包含聚合函数结果的列。
    
    Throws
    
    IllegalArgumentException - 如果使用了不支持的窗口规范（即 WindowOptions.FrameType.ROWS 之外的规范）。
  - prefixSum
```
public final ColumnVector prefixSum()
```
    计算此列中值的累积和（又称前缀和）。这只是对 SUM 聚合执行包含式扫描的便捷方法。
  - scan
```
public final ColumnVector scan(ScanAggregation aggregation,
                               ScanType scanType,
                               NullPolicy nullPolicy)
```
    计算列的扫描。这与在列上运行的窗口非常相似。
    
    Parameters
    
    aggregation - 要执行的聚合操作。
    
    scanType - 扫描应为包含式（包含当前行）还是排除式。
    
    nullPolicy - 如何处理空值。请注意，一些聚合操作也包含空值策略。目前不支持这些聚合操作，因此它们如何相互作用是未定义的。
  - scan
```
public final ColumnVector scan(ScanAggregation aggregation,
                               ScanType scanType)
```
    计算排除 null 的列的扫描。
    
    Parameters
    
    aggregation - 要执行的聚合操作。
    
    scanType - 扫描应为包含式（包含当前行）还是排除式。
  - scan
```
public final ColumnVector scan(ScanAggregation aggregation)
```
    计算排除 null 的列的包含扫描。
    
    Parameters
    
    aggregation - 要执行的聚合操作。
  - not
```
public final ColumnVector not()
```
    返回输入列（this）中每个值的逻辑 `not` 向量。
  - contains
```
public boolean contains(Scalar needle)
```
    查找 `needle` 是否在此列中存在。示例：单列：idx 0 1 2 3 4 col = { 10, 20, 20, 30, 50 } 标量：value = { 20 } 结果 = true
    
    Parameters
    
    needle -
    
    Returns
    
    如果存在 needle 则为 true，否则为 false。
  - contains
```
public final ColumnVector contains(ColumnView searchSpace)
```
    返回一个 DType.BOOL8 元素的新列，其大小与此列相同，如果此列中的对应条目包含在给定的 searchSpace 列中，则每行值为 true，否则为 false。调用者将负责新向量的生命周期。示例：col = { 10, 20, 30, 40, 50 } searchSpace = { 20, 40, 60, 80 } result = { false, true, false, true, false }
    
    Parameters
    
    searchSpace -
    
    Returns
    
    类型为 DType.BOOL8 的新 ColumnVector。
  - toTitle
```
public final ColumnVector toTitle()
```
    返回一个字符串列，其中对于输入的每行字符串，空格后的第一个字符被修改为大写，而单词中的所有剩余字符被修改为小写。任何空字符串条目返回对应的空输出列条目。
  - capitalize
```
public final ColumnVector capitalize(Scalar delimiters)
```
    返回一个大写字符串列。如果 `delimiters` 是空字符串，则仅每行的第一个字符大写。否则，在找到任何分隔符字符后，非分隔符字符将被大写。示例：input = ["tesT1", "a Test", "Another Test", "a\tb"]; delimiters = "" output is ["Test1", "A test", "Another test", "A\tb"] delimiters = " " output is ["Test1", "A Test", "Another Test", "A\tb"] 任何空字符串条目返回对应的空输出列条目。
    
    Parameters
    
    delimiters - 用于标识要大写的单词。不应为空。
    
    Returns
    
    一个大写字符串列。用户应关闭返回的列。
  - joinStrings
```
public final ColumnVector joinStrings(Scalar separator,
                                      Scalar narep)
```
    将列中的所有字符串连接成一个新字符串，由可选的分隔符字符串分隔。这返回一个包含单个字符串的列。除非 narep 参数指定了替换字符串（非空值），否则任何空条目都将被忽略。
    
    Parameters
    
    separator - 要插入以分隔每一行的内容。
    
    narep - 用于替换空值的内容。
    
    Returns
    
    一个包含单个字符串的 ColumnVector。
  - castTo
```
public ColumnVector castTo(DType type)
```
    用于转换 ColumnVector 的通用方法。将 Date、Timestamp 或 Boolean 转换为数值类型时，将使用数据的底层数值表示进行转换。对于 Strings：目前不支持字符串与时间戳之间的转换。请查看 asTimestamp(DType, String) 和 asStrings(String)，了解在格式已知的情况下如何将字符串转换为时间戳。浮点值转换为字符串后可能与 Java 中预期的默认行为不同，例如 12.3 => "12.30000019" 而不是 "12.3"，Double.POSITIVE_INFINITY => "Inf" 而不是 "INFINITY"，Double.NEGATIVE_INFINITY => "-Inf" 而不是 "-INFINITY"。
    
    Parameters
    
    type - 结果 ColumnVector 的类型。
    
    Returns
    
    在 GPU 上分配的新向量。
  - replaceChildrenWithViews
```
public ColumnView replaceChildrenWithViews(int[] indices,
                                           ColumnView[] views)
```
    此方法接受一个嵌套类型，并将其子项替换为给定的视图。注意：确保叶节点中的行数与替换它的子项相同，否则列表可能指向列值之外的元素。注意：此方法返回一个 ColumnView，其生命周期不会超过它指向的 ColumnVector。示例：Listlist = col{{1,3}, {9,3,5}} validNewChild = col{8, 3, 9, 2, 0} list.replaceChildrenWithViews(1, validNewChild) => col{{8, 3}, {9, 2, 0}} invalidNewChild = col{3, 2} list.replaceChildrenWithViews(1, invalidNewChild) => col{{3, 2}, {invalid, invalid, invalid}} invalidNewChild = col{8, 3, 9, 2, 0, 0, 7} list.replaceChildrenWithViews(1, invalidNewChild) => col{{8, 3}, {9, 2, 0}} // 未定义的结果
  - replaceListChild
```
public ColumnView replaceListChild(ColumnView child)
```
    此方法接受一个列表，并返回一个新列表，其中叶节点已替换为给定的视图。确保叶节点中的行数与替换它的子项相同，否则列表可能指向列值之外的元素。注意：此方法返回一个 ColumnView，其生命周期不会超过它指向的 ColumnVector。示例：Listlist = col{{1,3}, {9,3,5}} validNewChild = col{8, 3, 9, 2, 0} list.replaceChildrenWithViews(1, validNewChild) => col{{8, 3}, {9, 2, 0}} invalidNewChild = col{3, 2} list.replaceChildrenWithViews(1, invalidNewChild) => col{{3, 2}, {invalid, invalid, invalid}} 抛出异常 invalidNewChild = col{8, 3, 9, 2, 0, 0, 7} list.replaceChildrenWithViews(1, invalidNewChild) => col{{8, 3}, {9, 2, 0}} 抛出异常
  - logicalCastTo
```
@Deprecated
public ColumnView logicalCastTo(DType type)
```
    已废弃。在 C++ 中已更改为 bit_cast，请改用该名称。
    
    在具有相同底层表示的类型之间进行零复制转换。类似于 C++ 中的 reinterpret_cast 或 bit_cast。这将基本上采用底层数据并更新元数据以反映新类型。并非所有类型都受支持，类型的宽度必须匹配。
    
    Parameters
    
    type - 要转换到的类型。
    
    Returns
    
    一个 ColumnView，其生命周期不能超过拥有它指向的实际数据的 Column。
  - bitCastTo
```
public ColumnView bitCastTo(DType type)
```
    在具有相同底层长度的类型之间进行零复制转换。类似于 C++ 中的 bit_cast。这将采用底层数据并创建新的元数据，以便将其解释为新类型。并非所有类型都受支持，类型的宽度必须匹配。
    
    Parameters
    
    type - 要转换到的类型。
    
    Returns
    
    一个 ColumnView，其生命周期不能超过拥有它指向的实际数据的 Column。
  - asBytes
```
public final ColumnVector asBytes()
```
    转换为字节 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为字节。从 Date、Timestamp 或 Boolean 转换为字节类型时，将使用数据的底层数值表示进行转换。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asByteList
```
public final ColumnVector asByteList()
```
    转换为字节列表。此方法将 ColumnVector 提供的行转换为字节列表，并反转其字节序。支持数值和字符串类型，但不支持时间戳。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asByteList
```
public final ColumnVector asByteList(boolean config)
```
    转换为字节列表。此方法将 ColumnVector 提供的行转换为字节列表。支持数值和字符串类型，但不支持时间戳。
    
    Parameters
    
    config - 如果为 true，则翻转字节序；否则保留字节序。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asUnsignedBytes
```
public final ColumnVector asUnsignedBytes()
```
    转换为无符号字节 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为字节。从 Date、Timestamp 或 Boolean 转换为字节类型时，将使用数据的底层数值表示进行转换。
    Java 没有无符号字节类型，因此正确解码这些值需要应用程序进行额外步骤。请参阅 Byte.toUnsignedInt(byte)。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asShorts
```
public final ColumnVector asShorts()
```
    转换为短整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为短整型。从 Date、Timestamp 或 Boolean 转换为短整型类型时，将使用数据的底层数值表示进行转换。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asUnsignedShorts
```
public final ColumnVector asUnsignedShorts()
```
    转换为无符号短整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为短整型。从 Date、Timestamp 或 Boolean 转换为短整型类型时，将使用数据的底层数值表示进行转换。
    Java 没有无符号短整型，因此正确解码这些值需要应用程序进行额外步骤。请参阅 Short.toUnsignedInt(short)。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asInts
```
public final ColumnVector asInts()
```
    转换为整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为整型。从 Date、Timestamp 或 Boolean 转换为整型类型时，将使用数据的底层数值表示进行转换。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asUnsignedInts
```
public final ColumnVector asUnsignedInts()
```
    转换为无符号整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为整型。从 Date、Timestamp 或 Boolean 转换为整型类型时，将使用数据的底层数值表示进行转换。
    Java 没有无符号整型，因此正确解码这些值需要应用程序进行额外步骤。请参阅 Integer.toUnsignedLong(int)。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asLongs
```
public final ColumnVector asLongs()
```
    转换为长整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为长整型。从 Date、Timestamp 或 Boolean 转换为长整型类型时，将使用数据的底层数值表示进行转换。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asUnsignedLongs
```
public final ColumnVector asUnsignedLongs()
```
    转换为无符号长整型 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为长整型。从 Date、Timestamp 或 Boolean 转换为长整型类型时，将使用数据的底层数值表示进行转换。
    Java 没有无符号长整型，因此正确解码这些值需要应用程序进行额外步骤。请参阅 Long.toUnsignedString(long)。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asFloats
```
public final ColumnVector asFloats()
```
    转换为单精度浮点数 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为单精度浮点数。从 Date、Timestamp 或 Boolean 转换为单精度浮点数类型时，将使用数据的底层数值表示进行转换。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asDoubles
```
public final ColumnVector asDoubles()
```
    转换为双精度浮点数 - ColumnVector 此方法获取 ColumnVector 提供的值并转换为双精度浮点数。从 Date、Timestamp 或 Boolean 转换为双精度浮点数类型时，将使用数据的底层数值表示进行转换。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampDays
```
public final ColumnVector asTimestampDays()
```
    转换为 TIMESTAMP_DAYS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_DAYS
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampDays
```
public final ColumnVector asTimestampDays(String format)
```
    转换为 TIMESTAMP_DAYS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_DAYS
    
    Parameters
    
    format - 时间戳字符串格式说明符，如果列类型不是字符串，则忽略。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampSeconds
```
public final ColumnVector asTimestampSeconds()
```
    转换为 TIMESTAMP_SECONDS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_SECONDS
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampSeconds
```
public final ColumnVector asTimestampSeconds(String format)
```
    转换为 TIMESTAMP_SECONDS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_SECONDS
    
    Parameters
    
    format - 时间戳字符串格式说明符，如果列类型不是字符串，则忽略。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampMicroseconds
```
public final ColumnVector asTimestampMicroseconds()
```
    转换为 TIMESTAMP_MICROSECONDS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_MICROSECONDS
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampMicroseconds
```
public final ColumnVector asTimestampMicroseconds(String format)
```
    转换为 TIMESTAMP_MICROSECONDS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_MICROSECONDS
    
    Parameters
    
    format - 时间戳字符串格式说明符，如果列类型不是字符串，则忽略。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampMilliseconds
```
public final ColumnVector asTimestampMilliseconds()
```
    转换为 TIMESTAMP_MILLISECONDS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_MILLISECONDS。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampMilliseconds
```
public final ColumnVector asTimestampMilliseconds(String format)
```
    转换为 TIMESTAMP_MILLISECONDS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_MILLISECONDS。
    
    Parameters
    
    format - 时间戳字符串格式说明符，如果列类型不是字符串，则忽略。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampNanoseconds
```
public final ColumnVector asTimestampNanoseconds()
```
    转换为 TIMESTAMP_NANOSECONDS - ColumnVector 此方法获取 ColumnVector 提供的值并转换为 TIMESTAMP_NANOSECONDS。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestampNanoseconds
```
public final ColumnVector asTimestampNanoseconds(String format)
```
    转换为 TIMESTAMP_NANOSECONDS - ColumnVector 此方法获取 ColumnVector 提供的字符串值并转换为 TIMESTAMP_NANOSECONDS。
    
    Parameters
    
    format - 时间戳字符串格式说明符，如果列类型不是字符串，则忽略。
    
    Returns
    
    在 GPU 上分配的新向量。
  - asTimestamp
```
public final ColumnVector asTimestamp(DType timestampType,
                                      String format)
```
    将字符串解析为时间戳。解析失败的字符串将默认为 0，对应于 1970-01-01 00:00:00.000。
    
    Parameters
    
    timestampType - 包含时间单位的时间戳 DType，用于将时间戳解析到其中。
    
    format - 时间戳的 strptime 格式说明符字符串。用于解析和转换时间戳。支持 %Y,%y,%m,%d,%H,%I,%p,%M,%S,%f,%z 格式说明符。有关完整的解析格式规范和文档，请参阅 https://github.com/rapidsai/custrings/blob/branch-0.10/docs/source/datetime.md。
    
    Returns
    
    包含原始列向量中时间戳的长整型表示的新 ColumnVector。
  - asStrings
```
public final ColumnVector asStrings()
```
    转换为字符串。目前不支持负时间戳值，并将产生 undesired 的结果。详细信息请参阅 github issue https://github.com/rapidsai/cudf/issues/3116。对于时间戳，它遵循以下格式：DType.TIMESTAMP_DAYS - "%Y-%m-%d" DType.TIMESTAMP_SECONDS - "%Y-%m-%d %H:%M:%S" DType.TIMESTAMP_MICROSECONDS - "%Y-%m-%d %H:%M:%S.%f" DType.TIMESTAMP_MILLISECONDS - "%Y-%m-%d %H:%M:%S.%f" DType.TIMESTAMP_NANOSECONDS - "%Y-%m-%d %H:%M:%S.%f"
    
    Returns
    
    在 GPU 上分配的新向量。
  - asStrings
```
public final ColumnVector asStrings(String format)
```
    将时间戳列向量解析并转换为字符串列向量的方法。Unix 时间戳是一个长整型值，表示自 1970-01-01 00:00:00:000 以来的单位数（正向或负向）。不对无效格式或无效时间戳单位进行检查。目前不支持负时间戳值，并将产生 undesired 的结果。详细信息请参阅 github issue https://github.com/rapidsai/cudf/issues/3116。
    
    Parameters
    
    format - - 时间戳的 strftime 格式说明符字符串。用于解析和转换时间戳。支持 %m,%j,%d,%H,%M,%S,%y,%Y,%f 格式说明符。%d 月中的日期：01-31 %m 年中的月份：01-12 %y 不含世纪的年份：00-99 %Y 含世纪的年份：0001-9999 %H 一天中的 24 小时制：00-23 %M 小时中的分钟：00-59 %S 分钟中的秒：00-59 %f 6 位微秒：000000-999999。有关文档，请参阅 https://github.com/rapidsai/custrings/blob/branch-0.10/docs/source/datetime.md。报告的错误 https://github.com/rapidsai/cudf/issues/4160 修复后，此方法也应支持 %I 一天中的 12 小时制：01-12 %p 仅 'AM', 'PM' %j 年中的日期。
    
    Returns
    
    在 GPU 上分配的新向量。
  - isTimestamp
```
public final ColumnVector isTimestamp(String format)
```
    验证字符串列是否可以使用提供的格式模式解析为时间戳。格式模式可以包含以下说明符："%Y,%y,%m,%d,%H,%I,%p,%M,%S,%f,%z" | 说明符 | 描述 | | :-------: | ----------- | | \%d | 月中的日期：01-31 | | \%m | 年中的月份：01-12 | | \%y | 不含世纪的年份：00-99 | | \%Y | 含世纪的年份：0001-9999 | | \%H | 一天中的 24 小时制：00-23 | | \%I | 一天中的 12 小时制：01-12 | | \%M | 小时中的分钟：00-59| | \%S | 分钟中的秒：00-59 | | \%f | 6 位微秒：000000-999999 | | \%z | UTC 偏移量，格式为 ±HHMM 示例 +0500 | | \%j | 年中的日期：001-366 | | \%p | 仅识别 'AM', 'PM' 或 'am', 'pm' | 目前不支持其他说明符。"%f" 支持精度值以读取数字位数。使用单个整数值 (1-9) 指定精度，如下所示：使用 "%3f" 表示毫秒，"%6f" 表示微秒，"%9f" 表示纳秒。任何空字符串条目都会导致输出列中出现相应的空行。这将返回一个布尔类型列，其中 `true` 行表示对应的输入字符串可以使用给定格式正确解析。
    
    Parameters
    
    format - 指定字符串中时间戳格式的字符串。
    
    Returns
    
    新的布尔 ColumnVector。
  - extractListElement
```
public final ColumnVector extractListElement(int index)
```
    对于此列中的每个列表，提取给定索引处的条目。如果条目超出列表末尾，则返回 NULL。
    
    Parameters
    
    index - 列表中基于 0 的偏移量。负值从列表末尾向后计算。
    
    Returns
    
    包含那些索引处值的新列。
  - extractListElement
```
public final ColumnVector extractListElement(ColumnView indices)
```
    对于此列中的每个列表，提取索引列中指定的相应索引处的条目。如果条目超出列表末尾，则返回 NULL。索引列应与列表列具有相同的行数。
    
    Parameters
    
    indices - 列表中基于 0 的偏移量列。负值从列表末尾向后计算。
    
    Returns
    
    包含那些索引处值的新列。
  - dropListDuplicates
```
public final ColumnVector dropListDuplicates()
```
    通过复制当前 LIST 列中的元素来创建新的 LIST 列，忽略重复项，生成一个 LIST 列，其中每个列表仅包含唯一元素。不保证输出元素在每个列表中的顺序与输入中的顺序保持一致。
    
    Returns
    
    具有唯一列表元素的新 LIST 列。
  - dropListDuplicatesWithKeysValues
```
public final ColumnVector dropListDuplicatesWithKeysValues()
```
    给定一个 LIST 列，其中每个元素都是一个包含以下内容的结构体：对。通过复制当前列中的元素生成一个输出 LIST 列，方式是如果一个列表包含多个具有相同键的元素，则仅复制最后一个元素。
    
    Returns
    
    具有唯一键的列表元素的新 LIST 列。
  - flattenLists
```
public ColumnVector flattenLists()
```
    将每个列表的列表展平为一个列表。列必须包含列表的列表。任何包含空列表元素的行都会导致输出行为空。
    
    Returns
    
    包含展平结果的新列向量。
  - flattenLists
```
public ColumnVector flattenLists(boolean ignoreNull)
```
    将每个列表的列表展平为一个列表。列必须包含列表的列表。
    
    Parameters
    
    ignoreNull - 是否在操作中忽略输入列中的空列表元素，或者任何包含空列表元素的行都会导致输出行为空。
    
    Returns
    
    包含展平结果的新列向量。
  - reverseStringsOrLists
```
public final ColumnVector reverseStringsOrLists()
```
    将当前列复制到新列，输出列中的每个字符串或列表将具有反向字符或元素顺序。
    
    Returns
    
    具有反向顺序列表或字符串的新列。
  - upper
```
public final ColumnVector upper()
```
    将字符串转换为大写。
  - lower
```
public final ColumnVector lower()
```
    将字符串转换为小写。
  - stringLocate
```
public final ColumnVector stringLocate(Scalar substring)
```
    查找给定字符串在列中每行第一次出现的起始索引。0 索引，如果未找到子字符串则返回 -1。重载 stringLocate 以支持 start (0) 和 end index 的默认值。
    
    Parameters
    
    substring - 包含要在每行中定位的字符串的标量。
  - stringLocate
```
public final ColumnVector stringLocate(Scalar substring,
                                       int start)
```
    查找给定字符串在列中每行第一次出现的起始索引。0 索引，如果未找到子字符串则返回 -1。重载 stringLocate 以支持 end index 的默认值 (-1，即每个字符串的末尾)。
    
    Parameters
    
    substring - 包含要在每行中定位的字符串的标量。
    
    start - 开始搜索的字符索引（包含）。
  - stringLocate
```
public final ColumnVector stringLocate(Scalar substring,
                                       int start,
                                       int end)
```
    查找给定字符串在列中每行第一次出现的起始索引。0 索引，如果未找到子字符串则返回 -1。可以配置为从字符串中间开始或结束搜索。
    
    Parameters
    
    substring - 包含要在每行中定位的字符串标量。
    
    start - 开始搜索的字符索引（包含）。
    
    end - 结束搜索的字符索引（不包含）。
  - stringSplit
```
@Deprecated
public final Table stringSplit(String pattern,
                                           int limit,
                                           boolean splitByRegex)
```
    已弃用。
    
    通过使用指定模式分割每个字符串来返回列列表。输出列中的行数将与输入列相同。对于分割结果已耗尽的行，会添加空条目。空输入条目会导致输出列中相应行为空。
    
    Parameters
    
    pattern - UTF-8 编码的字符串，标识每个输入字符串的分割模式。
    
    limit - 分割每个输入字符串产生的列表的最大大小，或 -1 表示所有可能的分割。请注意，不支持 limit = 0（所有可能的分割但不包含尾随的空字符串）和 limit = 1（完全不分割）。
    
    splitByRegex - 一个布尔标志，指示输入字符串是按正则表达式模式分割还是仅按字符串字面量分隔符分割。
    
    Returns
    
    作为表的字符串列列表。
  - stringSplit
```
public final Table stringSplit(RegexProgram regexProg,
                               int limit)
```
    通过使用指定的 regex program 模式分割每个字符串来返回列列表。输出列中的行数将与输入列相同。对于分割结果已耗尽的行，会添加空条目。空输入条目会导致输出列中相应行为空。
    
    Parameters
    
    regexProg - 包含 UTF-8 编码字符串的 regex program，标识每个输入字符串的分割模式。
    
    limit - 分割每个输入字符串产生的列表的最大大小，或 -1 表示所有可能的分割。请注意，不支持 limit = 0（所有可能的分割但不包含尾随的空字符串）和 limit = 1（完全不分割）。
    
    Returns
    
    作为表的字符串列列表。
  - stringSplit
```
@Deprecated
public final Table stringSplit(String pattern,
                                           boolean splitByRegex)
```
    已弃用。
    
    通过使用指定模式分割每个字符串来返回列列表。输出列中的行数将与输入列相同。对于分割结果已耗尽的行，会添加空条目。空输入条目会导致输出列中相应行为空。
    
    Parameters
    
    pattern - UTF-8 编码的字符串，标识每个输入字符串的分割模式。
    
    splitByRegex - 一个布尔标志，指示输入字符串是按正则表达式模式分割还是仅按字符串字面量分隔符分割。
    
    Returns
    
    作为表的字符串列列表。
  - stringSplit
```
public final Table stringSplit(String delimiter,
                               int limit)
```
    通过使用指定的字符串字面量分隔符分割每个字符串来返回列列表。输出列中的行数将与输入列相同。对于分割结果已耗尽的行，会添加空条目。空输入条目会导致输出列中相应行为空。
    
    Parameters
    
    delimiter - UTF-8 编码的字符串，标识每个输入字符串的分割分隔符。
    
    limit - 分割每个输入字符串产生的列表的最大大小，或 -1 表示所有可能的分割。请注意，不支持 limit = 0（所有可能的分割但不包含尾随的空字符串）和 limit = 1（完全不分割）。
    
    Returns
    
    作为表的字符串列列表。
  - stringSplit
```
public final Table stringSplit(String delimiter)
```
    通过使用指定的字符串字面量分隔符分割每个字符串来返回列列表。输出列中的行数将与输入列相同。对于分割结果已耗尽的行，会添加空条目。空输入条目会导致输出列中相应行为空。
    
    Parameters
    
    delimiter - UTF-8 编码的字符串，标识每个输入字符串的分割分隔符。
    
    Returns
    
    作为表的字符串列列表。
  - stringSplit
```
public final Table stringSplit(RegexProgram regexProg)
```
    通过使用指定的 regex program 模式分割每个字符串来返回列列表。输出列中的行数将与输入列相同。对于分割结果已耗尽的行，会添加空条目。空输入条目会导致输出列中相应行为空。
    
    Parameters
    
    regexProg - 包含 UTF-8 编码字符串的 regex program，标识每个输入字符串的分割模式。
    
    Returns
    
    作为表的字符串列列表。
  - stringSplitRecord
```
@Deprecated
public final ColumnVector stringSplitRecord(String pattern,
                                                        int limit,
                                                        boolean splitByRegex)
```
    已弃用。
    
    返回一个列，该列是字符串列表，其中每个列表是通过使用指定模式分割相应的输入字符串而创建的。
    
    Parameters
    
    pattern - UTF-8 编码的字符串，标识每个输入字符串的分割模式。
    
    limit - 分割每个输入字符串产生的列表的最大大小，或 -1 表示所有可能的分割。请注意，不支持 limit = 0（所有可能的分割但不包含尾随的空字符串）和 limit = 1（完全不分割）。
    
    splitByRegex - 一个布尔标志，指示输入字符串是按正则表达式模式分割还是仅按字符串字面量分隔符分割。
    
    Returns
    
    一个包含字符串元素的 LIST 列。
  - stringSplitRecord
```
public final ColumnVector stringSplitRecord(RegexProgram regexProg,
                                            int limit)
```
    返回一个列，其中每个列表都是通过使用指定的 regex program 模式分割相应输入字符串而生成的字符串列表。
    
    Parameters
    
    regexProg - 包含 UTF-8 编码字符串的 regex program，标识每个输入字符串的分割模式。
    
    limit - 分割每个输入字符串产生的列表的最大大小，或 -1 表示所有可能的分割。请注意，不支持 limit = 0（所有可能的分割但不包含尾随的空字符串）和 limit = 1（完全不分割）。
    
    Returns
    
    一个包含字符串元素的 LIST 列。
  - stringSplitRecord
```
@Deprecated
public final ColumnVector stringSplitRecord(String pattern,
                                                        boolean splitByRegex)
```
    已弃用。
    
    返回一个列，该列是字符串列表，其中每个列表是通过使用指定模式分割相应的输入字符串而创建的。
    
    Parameters
    
    pattern - UTF-8 编码的字符串，标识每个输入字符串的分割模式。
    
    splitByRegex - 一个布尔标志，指示输入字符串是按正则表达式模式分割还是仅按字符串字面量分隔符分割。
    
    Returns
    
    一个包含字符串元素的 LIST 列。
  - stringSplitRecord
```
public final ColumnVector stringSplitRecord(String delimiter,
                                            int limit)
```
    返回一个列，其中每个列表都是通过使用指定的字符串字面量分隔符分割相应输入字符串而生成的字符串列表。
    
    Parameters
    
    delimiter - UTF-8 编码的字符串，标识每个输入字符串的分割分隔符。
    
    limit - 分割每个输入字符串产生的列表的最大大小，或 -1 表示所有可能的分割。请注意，不支持 limit = 0（所有可能的分割但不包含尾随的空字符串）和 limit = 1（完全不分割）。
    
    Returns
    
    一个包含字符串元素的 LIST 列。
  - stringSplitRecord
```
public final ColumnVector stringSplitRecord(String delimiter)
```
    返回一个列，其中每个列表都是通过使用指定的字符串字面量分隔符分割相应输入字符串而生成的字符串列表。
    
    Parameters
    
    delimiter - UTF-8 编码的字符串，标识每个输入字符串的分割分隔符。
    
    Returns
    
    一个包含字符串元素的 LIST 列。
  - stringSplitRecord
```
public final ColumnVector stringSplitRecord(RegexProgram regexProg)
```
    返回一个列，其中每个列表都是通过使用指定的 regex program 模式分割相应输入字符串而生成的字符串列表。
    
    Parameters
    
    regexProg - 包含 UTF-8 编码字符串的 regex program，标识每个输入字符串的分割模式。
    
    Returns
    
    一个包含字符串元素的 LIST 列。
  - substring
```
public final ColumnVector substring(int start)
```
    返回一个新的字符串列，其中包含提供的列中字符串的子字符串。要检索的每个字符串中的字符位置为 `[start,)`..
    
    Parameters
    
    start - 子字符串的起始字符索引（包含）。
  - substring
```
public final ColumnVector substring(int start,
                                    int end)
```
    返回一个新的字符串列，其中包含提供的列中字符串的子字符串。0 索引，如果停止位置超出字符串长度，则将字符串末尾用作该字符串的停止位置。
    
    Parameters
    
    start - 子字符串的起始字符索引（包含）。
    
    end - 子字符串的结束字符索引（不包含）。
    
    Returns
    
    包含子字符串的新 Java 列向量。
  - substring
```
public final ColumnVector substring(ColumnView start,
                                    ColumnView end)
```
    返回一个新的字符串列，其中包含给定列中字符串的子字符串，对每个字符串使用唯一的范围。
    
    Parameters
    
    start - 包含每个字符串起始索引的向量。
    
    end - 包含每个字符串结束索引的向量。-1 表示读取到字符串末尾。
    
    Returns
    
    包含子字符串的新 Java 列向量。
  - stringConcatenateListElements
```
public final ColumnVector stringConcatenateListElements(ColumnView sepCol)
```
    给定一个字符串列表列（每行为一个字符串列表），连接每行中的字符串并返回单个字符串列结果。每个新字符串是通过连接同一行（同一列表元素）中的字符串并由提供的分隔符分隔而创建的。此版本的函数将 null 替换为空字符串，并对空列表返回 null。
    
    Parameters
    
    sepCol - 提供连接分隔符的字符串列。
    
    Returns
    
    包含连接字符串（含分隔符）的新 Java 列向量。
  - stringConcatenateListElements
```
public final ColumnVector stringConcatenateListElements(ColumnView sepCol,
                                                        Scalar separatorNarep,
                                                        Scalar stringNarep,
                                                        boolean separateNulls,
                                                        boolean emptyStringOutputIfEmptyList)
```
    给定一个字符串列表列（每行为一个字符串列表），连接每行中的字符串并返回单个字符串列结果。每个新字符串是通过连接同一行（同一列表元素）中的字符串并由 sepCol 字符串列中提供的行分隔符分隔而创建的。
    
    Parameters
    
    sepCol - 提供连接分隔符的字符串列。
    
    separatorNarep - 字符串标量，指示分隔符为 null 时的 null 行为。如果设置为 null 且分隔符为 null，则结果字符串将为 null。如果非 null，则此字符串将用于代替 null 分隔符。
    
    stringNarep - 应用于替换任何非 null 列表行中的 null 字符串的字符串。如果设置为 null 且字符串为 null，则结果字符串将为 null。如果非 null，则此字符串将用于代替 null 值。
    
    separateNulls - 如果为 true，则在 `stringNarep` 有效时，null 行也会包含分隔符。
    
    emptyStringOutputIfEmptyList - 如果设置为 true，则任何空列表的输入行将导致空字符串。否则，将导致 null。
    
    Returns
    
    包含连接字符串（含分隔符）的新 Java 列向量。
  - stringConcatenateListElements
```
public final ColumnVector stringConcatenateListElements(Scalar separator,
                                                        Scalar narep,
                                                        boolean separateNulls,
                                                        boolean emptyStringOutputIfEmptyList)
```
    给定一个字符串列表列（每行为一个字符串列表），连接每行中的字符串并返回单个字符串列结果。每个新字符串是通过连接同一行（同一列表元素）中的字符串并由提供的分隔符分隔而创建的。
    
    Parameters
    
    separator - 插入到每个合并字符串之间的字符串标量。
    
    narep - 字符串标量，指示 null 行为。如果设置为 null 且行中的任何字符串为 null，则结果字符串将为 null。如果非 null，则任何列中的 null 值将由指定的字符串替换。字符串标量中的底层值可能为 null，但传入的对象不能为 null。
    
    separateNulls - 如果为 true，则在 `narep` 有效时，null 行也会包含分隔符。
    
    emptyStringOutputIfEmptyList - 如果设置为 true，则任何空列表的输入行将导致空字符串。否则，将导致 null。
    
    Returns
    
    包含连接字符串（含分隔符）的新 Java 列向量。
  - repeatStrings
```
public final ColumnVector repeatStrings(int repeatTimes)
```
    给定一个字符串列，其中的每个字符串都会重复由 repeatTimes 参数指定的次数。特殊情况：- 如果 repeatTimes 不是正数，非 null 输入字符串将始终导致空输出字符串。- 无论 repeatTimes 参数的值如何，空输入字符串将始终导致空输出字符串。
    
    Parameters
    
    repeatTimes - 每个输入字符串重复的次数。
    
    Returns
    
    包含重复字符串的新 Java 列向量。
  - repeatStrings
```
public final ColumnVector repeatStrings(ColumnView repeatTimes)
```
    给定一个字符串列，通过将每个输入字符串重复由 repeatTimes 数值列中相应行给定的次数来生成输出字符串列。特殊情况：- 任何空行（无论是输入字符串列还是 repeatTimes 列）都将始终导致空输出字符串。- 如果 repeatTimes 列中的任何值不是正数且其对应的输入字符串不为 null，则输出字符串将为空字符串。
    
    Parameters
    
    repeatTimes - 包含每个输入字符串重复次数的列。
    
    Returns
    
    包含重复字符串的新 Java 列向量。
  - getJSONObject
```
public final ColumnVector getJSONObject(Scalar path,
                                        GetJsonObjectOptions options)
```
    将 JSONPath 字符串应用于输入字符串列中的所有行。将 JSONPath 字符串应用于传入的字符串列，其中列中的每行都是有效的 json 字符串。输出按行以字符串列返回。参考：https://tools.ietf.org/id/draft-goessner-dispatch-jsonpath-00.html 注意：仅实现了运算符：$ . [] *
    
    Parameters
    
    path - 要应用于每行的 JSONPath 字符串。
    
    path - 控制 get_json_object 行为的 GetJsonObjectOptions。
    
    Returns
    
    包含检索到的 json 对象字符串的新字符串 ColumnVector。
  - getJSONObject
```
public final ColumnVector getJSONObject(Scalar path)
```
    将 JSONPath 字符串应用于输入字符串列中的所有行。将 JSONPath 字符串应用于传入的字符串列，其中列中的每行都是有效的 json 字符串。输出按行以字符串列返回。参考：https://tools.ietf.org/id/draft-goessner-dispatch-jsonpath-00.html 注意：仅实现了运算符：$ . [] *
    
    Parameters
    
    path - 要应用于每行的 JSONPath 字符串。
    
    Returns
    
    包含检索到的 json 对象字符串的新字符串 ColumnVector。
  - stringReplace
```
public final ColumnVector stringReplace(Scalar target,
                                        Scalar replace)
```
    返回一个新的字符串列，其中每个字符串中的目标字符串被指定的替换字符串替换。替换从字符串的开头到结尾进行，例如，在字符串 "aaa" 中将 "aa" 替换为 "b" 将导致 "ba" 而不是 "ab"。为 replace 指定空字符串将基本删除在每个字符串中找到的目标字符串（如果找到）。空字符串条目将返回空输出字符串条目。目标标量应为字符串，不应为空或 null。
    
    Parameters
    
    target - 要在每个字符串中搜索的字符串。
    
    replace - 如果找到目标字符串，则用于替换的字符串。
    
    Returns
    
    包含替换字符串的新 Java 列向量。
  - stringReplace
```
public final ColumnVector stringReplace(ColumnView targets,
                                        ColumnView repls)
```
    返回一个新的字符串列，其中每个字符串中的目标字符串被相应的替换字符串替换。对于列中的每个字符串，在该字符串中搜索目标列表。如果找到目标字符串，则由 repls 列中的相应条目替换。替换在每个字符串中找到的所有匹配项。repls 参数可以选择包含一个字符串。在这种情况下，所有匹配的目标子字符串都将由该单个字符串替换。示例：cv = ["hello", "goodbye"] targets = ["e","o"] repls = ["EE","OO"] r1 = cv.stringReplace(targets, repls) r1 is now ["hEEllO", "gOOOOdbyEE"] targets = ["e", "o"] repls = ["_"] r2 = cv.stringReplace(targets, repls) r2 is now ["h_ll_", "g__dby_"]
    
    Parameters
    
    targets - 要在每个字符串中搜索的字符串。
    
    repls - 目标字符串对应的替换字符串。
    
    Returns
    
    包含替换字符串的新 Java 列向量。
  - replaceRegex
```
@Deprecated
public final ColumnVector replaceRegex(String pattern,
                                                   Scalar repl)
```
    已弃用。
    
    对于每个字符串，使用替换字符串标量替换匹配给定模式的任何字符序列。
    
    Parameters
    
    pattern - 要在每个字符串中搜索的正则表达式模式。
    
    repl - 用于替换每个模式匹配的字符串标量。
    
    Returns
    
    包含字符串结果的新列向量。
  - replaceRegex
```
public final ColumnVector replaceRegex(RegexProgram regexProg,
                                       Scalar repl)
```
    对于每个字符串，使用替换字符串标量替换匹配给定 regex program 模式的任何字符序列。
    
    Parameters
    
    regexProg - 包含要在每个字符串中搜索的模式的 regex program。
    
    repl - 用于替换每个模式匹配的字符串标量。
    
    Returns
    
    包含字符串结果的新列向量。
  - replaceRegex
```
@Deprecated
public final ColumnVector replaceRegex(String pattern,
                                                   Scalar repl,
                                                   int maxRepl)
```
    已弃用。
    
    对于每个字符串，使用替换字符串标量替换匹配给定模式的任何字符序列。
    
    Parameters
    
    pattern - 要在每个字符串中搜索的正则表达式模式。
    
    repl - 用于替换每个模式匹配的字符串标量。
    
    maxRepl - 在每个字符串中替换的最大次数。
    
    Returns
    
    包含字符串结果的新列向量。
  - replaceRegex
```
public final ColumnVector replaceRegex(RegexProgram regexProg,
                                       Scalar repl,
                                       int maxRepl)
```
    对于每个字符串，使用替换字符串标量替换匹配给定 regex program 模式的任何字符序列。
    
    Parameters
    
    regexProg - 包含要在每个字符串中搜索的模式的 regex program。
    
    repl - 用于替换每个模式匹配的字符串标量。
    
    maxRepl - 在每个字符串中替换的最大次数。
    
    Returns
    
    包含字符串结果的新列向量。
  - replaceMultiRegex
```
public final ColumnVector replaceMultiRegex(String[] patterns,
                                            ColumnView repls)
```
    对于每个字符串，将匹配任何正则表达式模式的任何字符序列替换为相应的替换字符串。
    
    Parameters
    
    patterns - 要在每个字符串中搜索的正则表达式模式。
    
    repls - 用于替换每个相应模式匹配的字符串标量。
    
    Returns
    
    包含字符串结果的新列向量。
  - stringReplaceWithBackrefs
```
@Deprecated
public final ColumnVector stringReplaceWithBackrefs(String pattern,
                                                                String replace)
```
    已弃用。
    
    对于每个字符串，使用反向引用替换模板替换匹配给定模式的任何字符序列。任何空字符串条目返回对应的空输出列条目。
    
    Parameters
    
    pattern - 要在每个字符串中搜索的正则表达式模式。
    
    replace - 用于创建输出字符串的替换模板。
    
    Returns
    
    包含字符串结果的新 Java 列向量。
  - stringReplaceWithBackrefs
```
public final ColumnVector stringReplaceWithBackrefs(RegexProgram regexProg,
                                                    String replace)
```
    对于每个字符串，使用反向引用替换模板替换匹配给定 regex program 模式的任何字符序列。任何空字符串条目返回对应的空输出列条目。
    
    Parameters
    
    regexProg - 包含要在每个字符串中搜索的模式的 regex program。
    
    replace - 用于创建输出字符串的替换模板。
    
    Returns
    
    包含字符串结果的新 Java 列向量。
  - zfill
```
public final ColumnVector zfill(int width)
```
    在每个字符串的左侧添加 '0' 作为填充。如果字符串已有 width 或更多字符，则不执行填充。不截断字符串。空字符串条目导致输出列中出现空条目。
    
    Parameters
    
    width - 每个字符串的最小字符数。
    
    Returns
    
    新的字符串列。
  - pad
```
public final ColumnVector pad(int width)
```
    在右侧用空格 " " 填充字符串列，直到达到所需长度。如果字符串已有 width 或更多字符，则不执行填充。不截断字符串。空字符串条目导致输出列中出现空条目。
    
    Parameters
    
    width - 每个字符串的最小字符数。
    
    Returns
    
    新的字符串列。
  - pad
```
public final ColumnVector pad(int width,
                              PadSide side)
```
    用空格 " " 填充字符串列，直到达到所需长度。如果字符串已有 width 或更多字符，则不执行填充。不截断字符串。空字符串条目导致输出列中出现空条目。
    
    Parameters
    
    width - 每个字符串的最小字符数。
    
    side - 在何处添加新字符。
    
    Returns
    
    新的字符串列。
  - pad
```
public final ColumnVector pad(int width,
                              PadSide side,
                              String fillChar)
```
    填充字符串列，直到达到所需长度。如果字符串已有 width 或更多字符，则不执行填充。不截断字符串。空字符串条目导致输出列中出现空条目。
    
    Parameters
    
    width - 每个字符串的最小字符数。
    
    side - 在何处添加新字符。
    
    fillChar - 包含要添加内容的单个字符字符串。
    
    Returns
    
    新的字符串列。
  - startsWith
```
public final ColumnVector startsWith(Scalar pattern)
```
    检查列中的每个字符串是否以指定的比较字符串开头，生成一个布尔结果的并行列。
    
    Parameters
    
    pattern - 包含要在列字符串开头搜索的字符串的标量。
    
    Returns
    
    包含布尔结果的新 Java 列向量。
  - endsWith
```
public final ColumnVector endsWith(Scalar pattern)
```
    检查列中的每个字符串是否以指定的比较字符串结尾，结果是一个并行的布尔结果列。
    
    Parameters
    
    pattern - 包含要在列字符串末尾搜索的字符串的标量。
    
    Returns
    
    包含布尔结果的新 Java 列向量。
  - strip
```
public final ColumnVector strip()
```
    移除字符串开头和末尾的空白字符。
    
    Returns
    
    包含剥离字符串的新 Java 列向量。
  - strip
```
public final ColumnVector strip(Scalar toStrip)
```
    移除每个字符串开头和末尾指定的字符。
    
    Parameters
    
    toStrip - UTF-8 编码的要从每个字符串中剥离的字符。
    
    Returns
    
    包含剥离字符串的新 Java 列向量。
  - lstrip
```
public final ColumnVector lstrip()
```
    移除字符串开头的空白字符。
    
    Returns
    
    包含剥离字符串的新 Java 列向量。
  - lstrip
```
public final ColumnVector lstrip(Scalar toStrip)
```
    移除每个字符串开头指定的字符。
    
    Parameters
    
    toStrip - UTF-8 编码的要从每个字符串中剥离的字符。
    
    Returns
    
    包含剥离字符串的新 Java 列向量。
  - rstrip
```
public final ColumnVector rstrip()
```
    移除字符串末尾的空白字符。
    
    Returns
    
    包含剥离字符串的新 Java 列向量。
  - rstrip
```
public final ColumnVector rstrip(Scalar toStrip)
```
    移除每个字符串末尾指定的字符。
    
    Parameters
    
    toStrip - UTF-8 编码的要从每个字符串中剥离的字符。
    
    Returns
    
    包含剥离字符串的新 Java 列向量。
  - stringContains
```
public final ColumnVector stringContains(Scalar compString)
```
    检查列中的每个字符串是否包含指定的比较字符串，生成一个布尔结果的并行列。
    
    Parameters
    
    compString - 包含要搜索的字符串的标量。
    
    Returns
    
    包含布尔结果的新 Java 列向量。
  - stringContains
```
public final ColumnVector[] stringContains(ColumnView targets)
```
    Parameters
    
    targets - UTF-8 编码的要在 `input` 中每个字符串中搜索的字符串。
    
    Returns
    
    BOOL8 列
  - clamp
```
public final ColumnVector clamp(Scalar lo,
                                Scalar hi)
```
    将 `input` 中小于 `lo` 的值替换为 `lo`，将大于 `hi` 的值替换为 `hi`。如果 `lo` 无效，则在评估输入时不会考虑 lo（本质上被视为该类型的最小值）。如果 `hi` 无效，则在评估输入时不会考虑 hi（本质上被视为该类型的最大值）。``` 示例：input: {1, 2, 3, NULL, 5, 6, 7} 有效的 lo 和 hi lo: 3, hi: 5, lo_replace : 0, hi_replace : 16 output:{0, 0, 3, NULL, 5, 16, 16} 无效的 lo lo: NULL, hi: 5, lo_replace : 0, hi_replace : 16 output:{1, 2, 3, NULL, 5, 16, 16} 无效的 hi lo: 3, hi: NULL, lo_replace : 0, hi_replace : 16 output:{0, 0, 3, NULL, 5, 6, 7} ```
    
    Parameters
    
    lo - 最小 clamp 值。所有小于 `lo` 的元素将替换为 `lo`。如果为 null，则忽略。
    
    hi - 最大 clamp 值。所有大于 `hi` 的元素将替换为 `hi`。如果为 null，则忽略。
    
    Returns
    
    根据 `lo` 和 `hi` 边界返回新的 clamp 列。
  - clamp
```
public final ColumnVector clamp(Scalar lo,
                                Scalar loReplace,
                                Scalar hi,
                                Scalar hiReplace)
```
    将 `input` 中小于 `lo` 的值替换为 `lo_replace`，将大于 `hi` 的值替换为 `hi_replace`。如果 `lo` 无效，则在评估输入时不会考虑 lo（本质上被视为该类型的最小值）。如果 `hi` 无效，则在评估输入时不会考虑 hi（本质上被视为该类型的最大值）。
    
    Parameters
    
    lo - 最小 clamp 值。所有小于 `lo` 的元素将替换为 `loReplace`。如果为 null，则忽略。
    
    loReplace - 所有小于 `lo` 的元素将替换为 `loReplace`。
    
    hi - 最大 clamp 值。所有大于 `hi` 的元素将替换为 `hiReplace`。如果为 null，则忽略。
    
    hiReplace - 所有大于 `hi` 的元素将替换为 `hiReplace`。
    
    Returns
    
    - 根据 `lo` 和 `hi` 边界返回新的 clamp 列。
  - matchesRe
```
@Deprecated
public final ColumnVector matchesRe(String pattern)
```
    已弃用。
    
    返回一个布尔 ColumnVector，标识匹配给定 regex 模式但仅在字符串开头的行。``` cv = ["abc", "123", "def456"] result = cv.matchesRe("\\d+") r is now [false, true, false] ``` 任何空字符串条目返回对应的空输出列条目。有关支持的 regex 模式，请参阅
    
    Parameters
    
    pattern - 要与每个字符串匹配的 Regex 模式。
    
    Returns
    
    包含每个字符串布尔结果的新 ColumnVector。
  - matchesRe
```
public final ColumnVector matchesRe(RegexProgram regexProg)
```
    返回一个布尔 ColumnVector，标识匹配给定 regex program 模式但仅在字符串开头的行。``` cv = ["abc", "123", "def456"] p = new RegexProgram("\\d+", CaptureGroups.NON_CAPTURE) r = cv.matchesRe(p) r is now [false, true, false] ``` 任何空字符串条目返回对应的空输出列条目。有关支持的 regex 模式，请参阅
    
    Parameters
    
    regexProg - 要与每个字符串匹配的 Regex program。
    
    Returns
    
    包含每个字符串布尔结果的新 ColumnVector。
  - containsRe
```
@Deprecated
public final ColumnVector containsRe(String pattern)
```
    已弃用。
    
    返回一个布尔 ColumnVector，标识匹配给定 regex 模式（从任意位置开始）的行。``` cv = ["abc", "123", "def456"] r = cv.containsRe("\\d+") r is now [false, true, true] ``` 任何空字符串条目返回对应的空输出列条目。有关支持的 regex 模式，请参阅
    
    Parameters
    
    pattern - 要与每个字符串匹配的 Regex 模式。
    
    Returns
    
    包含每个字符串布尔结果的新 ColumnVector。
  - containsRe
```
public final ColumnVector containsRe(RegexProgram regexProg)
```
    返回一个布尔 ColumnVector，标识匹配给定 RegexProgram 模式（从任意位置开始）的行。``` cv = ["abc", "123", "def456"] p = new RegexProgram("\\d+", CaptureGroups.NON_CAPTURE) r = cv.containsRe(p) r is now [false, true, true] ``` 任何空字符串条目返回对应的空输出列条目。有关支持的 regex 模式，请参阅
    
    Parameters
    
    regexProg - 要与每个字符串匹配的 Regex program。
    
    Returns
    
    包含每个字符串布尔结果的新 ColumnVector。
  - extractRe
```
@Deprecated
public final Table extractRe(String pattern)
                                  throws CudfException
```
    已弃用。
    
    对于给定正则表达式中指定的每个捕获组，在表中返回一个列。如果字符串不匹配，则添加空条目。任何空输入也会导致空输出条目。有关支持的 regex 模式，请参阅
    
    Parameters
    
    pattern - 要使用的模式。
    
    Returns
    
    提取的匹配项表。
    
    Throws
    
    CudfException - 如果发生任何错误，包括 RE 不包含任何捕获组。
  - extractRe
```
public final Table extractRe(RegexProgram regexProg)
                      throws CudfException
```
    对于给定 regex program 中指定的每个捕获组，在表中返回一个列。如果字符串不匹配，则添加空条目。任何空输入也会导致空输出条目。有关支持的 regex 模式，请参阅
    
    Parameters
    
    regexProg - 要使用的 regex program。
    
    Returns
    
    提取的匹配项表。
    
    Throws
    
    CudfException - 如果发生任何错误，包括 regex program 不包含任何捕获组。
  - extractAllRecord
```
@Deprecated
public final ColumnVector extractAllRecord(String pattern,
                                                       int idx)
```
    已弃用。
    
    提取所有匹配给定正则表达式并对应于正则表达式组索引的字符串。任何空输入也会导致空输出条目。有关支持的 regex 模式，请参阅
    
    Parameters
    
    pattern - Regex 模式。
    
    idx - Regex 组索引。
    
    Returns
    
    提取匹配项的新列向量。
  - extractAllRecord
```
public final ColumnVector extractAllRecord(RegexProgram regexProg,
                                           int idx)
```
    提取所有匹配给定 regex program 模式并对应于正则表达式组索引的字符串。任何空输入也会导致空输出条目。有关支持的 regex 模式，请参阅
    
    Parameters
    
    regexProg - Regex program。
    
    idx - Regex 组索引。
    
    Returns
    
    提取匹配项的新列向量。
  - like
```
public final ColumnVector like(Scalar pattern,
                               Scalar escapeChar)
```
    返回一个布尔 ColumnVector，标识匹配给定 like 模式的行。like 模式仅支持 2 个通配符特殊字符：`%` 任意数量的任意字符（包括零字符）- `_` 任意单个字符 ``` cv = ["azaa", "ababaabba", "aaxa"] r = cv.like("%a_aa%", "\\") r is now [true, true, false] r = cv.like("a__a", "\\") r is now [true, false, true] ``` 转义字符用于在搜索中包含 `%` 或 `_`，预期转义字符为 0 或 1 个字符。如果指定多个字符，则仅使用第一个字符。``` cv = ["abc_def", "abc1def", "abc_"] r = cv.like("abc/_d%", "/") r is now [true, false, false] ``` 任何空字符串条目返回对应的空输出列条目。
    
    Parameters
    
    pattern - 用于与每个字符串匹配的 Like 模式。
    
    escapeChar - 指定转义前缀的字符；默认为 "\\"。
    
    Returns
    
    包含每个字符串布尔结果的新 ColumnVector。
  - urlDecode
```
public final ColumnVector urlDecode()
                             throws CudfException
```
    将所有以 '%' 开头的字符序列转换为字符码点，将紧随其后的 2 个字符解释为十六进制值以创建码点。例如，序列 '%20' 被转换为字节 (0x20)，它是一个空格字符。另一个例子将 '%C3%A9' 转换为两个连续字节 (0xc3 和 0xa9)，它们是字符 é。总之，当在字符串中遇到 '%%'（单个百分号）字符时，会将 3 个字符转换为一个字符字节。
    任何空条目将导致输出列中出现相应的空条目。
    
    Returns
    
    包含解码字符串的新列实例。
    
    Throws
    
    CudfException
  - urlEncode
```
public final ColumnVector urlEncode()
                             throws CudfException
```
    将大部分非 ASCII 字符和控制字符转换为 UTF-8 十六进制码点，并以 '%' 为前缀。例如，空格字符必须转换为字符 '%20'，其中 '20' 表示 UTF-8 中空格的十六进制值。同样，多字节字符被转换为多个十六进制字符。例如，字符 é 被转换为字符 '%C3%A9'，其中 'C3A9' 是此字符的 UTF-8 字节 0xC3A9。
    任何空条目将导致输出列中出现相应的空条目。
    
    Returns
    
    包含编码字符串的新列实例。
    
    Throws
    
    CudfException
  - getMapValue
```
public final ColumnVector getMapValue(ColumnView keys)
```
    给定一个 List 类型的列> 和类型为 X 的键列，返回类型为 Y 的列，其中输出列中的每行是对应于 X 键的 Y 值。如果未找到键，则对应的输出值为 null。
    
    Parameters
    
    keys - 用于在列中查找的键列视图。
    
    Returns
    
    根据查找结果返回的值或 null 列。
  - getMapValue
```
public final ColumnVector getMapValue(Scalar key)
```
    给定一个 List 类型的列> 和类型为 X 的键，返回类型为 Y 的列，其中输出列中的每行是对应于 X 键的 Y 值。如果未找到键，则对应的输出值为 null。
    
    Parameters
    
    key - 用于在列中查找的标量键。
    
    Returns
    
    根据查找结果返回的值或 null 列。
  - getMapKeyExistence
```
public final ColumnVector getMapKeyExistence(Scalar key)
```
    对于 List 类型的列> 并传入 String 键，返回 struct 中所有键的布尔列，如果键存在于该行的对应 map 中，则为 true，否则为 false。它永远不会为某行返回 null。
    
    Parameters
    
    key - 用于在列中查找的 String 标量。
    
    Returns
    
    根据查找结果返回的布尔列。
  - getMapKeyExistence
```
public final ColumnVector getMapKeyExistence(ColumnView keys)
```
    对于 List 类型的列> 并传入键列，返回 map 中所有键的布尔列。如果键存在于该行的对应 map 中，则每行输出为 true，否则为 false。它永远不会为某行返回 null。
    
    Parameters
    
    keys - 用于在列中查找的键。
    
    Returns
    
    根据查找结果返回的布尔列。
  - makeStructView
```
public static ColumnView makeStructView(long rows,
                                        ColumnView... columns)
```
    创建现有列视图的新 struct 列视图。请注意，这不会复制输入列的内容来制作新向量，而是创建一个视图，该视图的生命周期不得超过其引用的子视图。结果列不能为 null。
    
    Parameters
    
    rows - struct 列中的行数。如果未提供列，则需要此参数。
    
    columns - 要按顺序添加到 struct 中的列。
    
    Returns
    
    新的列视图。调用者负责关闭它。
  - makeStructView
```
public static ColumnView makeStructView(ColumnView... columns)
```
    创建现有列视图的新 struct 列视图。请注意，这不会复制输入列的内容来制作新向量，而是创建一个视图，该视图的生命周期不得超过其引用的子视图。结果列不能为 null。
    
    Parameters
    
    columns - 要按顺序添加到 struct 中的列。
    
    Returns
    
    新的列视图。调用者负责关闭它。
  - fromDeviceBuffer
```
public static ColumnView fromDeviceBuffer(BaseDeviceMemoryBuffer buffer,
                                          long startOffset,
                                          DType type,
                                          int rows)
```
    从原始设备缓冲区创建新的列视图。请注意，这不会复制缓冲区的内容，仅创建视图。该视图的生命周期不得超过底层设备缓冲区。创建的列视图将没有有效性向量，因此无法创建包含 null 元素的视图。此外，仅支持固定宽度的原始类型。
    
    Parameters
    
    buffer - 支持列视图的设备内存。
    
    startOffset - 列数据在设备缓冲区中的字节偏移量。
    
    type - 列视图中的数据类型。
    
    rows - 列视图中的数据元素数量。
    
    Returns
    
    新的列视图实例，其生命周期不得超过支持它的设备缓冲区。
  - listContains
```
public final ColumnVector listContains(Scalar key)
```
    创建布尔值列，指示指定的标量是否是列表列中每行的元素。如果以下一个或多个条件为 true，则输出 `column[i]` 设置为 null：1. 键为 null 2. 列向量列表值为 null。
    
    Parameters
    
    key - 要查找的标量。
    
    Returns
    
    包含查找结果的布尔 ColumnVector。
  - listContainsColumn
```
public final ColumnVector listContainsColumn(ColumnView key)
```
    创建布尔值列，指示第一列的列表行是否包含第二列中的相应值。如果以下一个或多个条件为 true，则输出 `column[i]` 设置为 null：1. 键值为 null 2. 列向量列表值为 null。
    
    Parameters
    
    key - 包含查找值的 ColumnVector。
    
    Returns
    
    包含查找结果的布尔 ColumnVector。
  - listContainsNulls
```
public final ColumnVector listContainsNulls()
```
    创建布尔值列，指示指定列的列表行是否包含 null 元素。仅当输入列表行为 null 时，输出 `column[i]` 才设置为 null。
    
    Returns
    
    包含查找结果的布尔 ColumnVector。
  - listIndexOf
```
public final ColumnVector listIndexOf(Scalar key,
                                      ColumnView.FindOptions findOption)
```
    创建 int32 索引列，指示标量搜索键在每个列表行中的位置。所有索引都基于 0。如果未找到搜索键，则索引设置为 -1。如果以下一个或多个条件为 true，则索引设置为 null：1. 搜索键为 null。2. 列表行为 null。
    
    Parameters
    
    key - 标量搜索键。
    
    findOption - 是查找键的第一个索引还是最后一个索引。
    
    Returns
    
    结果 int32 索引列。
  - listIndexOf
```
public final ColumnVector listIndexOf(ColumnView keys,
                                      ColumnView.FindOptions findOption)
```
    创建 int32 索引列，指示搜索键列中每行在列表列相应行中的位置。所有索引都基于 0。如果未找到搜索键，则索引设置为 -1。如果以下一个或多个条件为 true，则索引设置为 null：1. 搜索键行为 null。2. 列表行为 null。
    
    Parameters
    
    keys - 搜索键的 ColumnView。
    
    findOption - 是查找键的第一个索引还是最后一个索引。
    
    Returns
    
    结果 int32 索引列。
  - listSortRows
```
public final ColumnVector listSortRows(boolean isDescending,
                                       boolean isNullSmallest)
```
    对列表列中每行列表中的元素进行分段排序。注意：尚不支持嵌套子项的列表列。
    
    Parameters
    
    isDescending - 是否按降序（或升序）对每行排序。
    
    isNullSmallest - 是否将 null 值视为最小值（或最大值）。
    
    Returns
    
    列表中的元素已排序的列表 ColumnVector。
  - listsHaveOverlap
```
public static ColumnVector listsHaveOverlap(ColumnView lhs,
                                            ColumnView rhs)
```
    对于输入列表列中的每对列表，检查它们是否具有任何共同的非 null 元素。任何输入列中的 null 输入行将导致 null 输出行。在检查共同元素时，每个列表中的 null 被视为不同的值，而浮点 NaN 值被视为相等。输入列表列必须具有相同的大小和相同的数据类型。
    
    Parameters
    
    lhs - 一侧的输入列表列。
    
    rhs - 另一侧的输入列表列。
    
    Returns
    
    类型为 BOOL8 的列，包含检查结果。
  - listsIntersectDistinct
```
public static ColumnVector listsIntersectDistinct(ColumnView lhs,
                                                  ColumnView rhs)
```
    查找给定列表列每行列表之间的交集，不包含重复项。任何输入列表列中的 null 输入行将导致 null 输出行。在查找列表交集时，每个列表中的 null 和浮点 NaN 值被视为相等值。输入列表列必须具有相同的大小和相同的数据类型。
    
    Parameters
    
    lhs - 一侧的输入列表列。
    
    rhs - 另一侧的输入列表列。
    
    Returns
    
    包含交集结果的列表列。
  - listsUnionDistinct
```
public static ColumnVector listsUnionDistinct(ColumnView lhs,
                                              ColumnView rhs)
```
    查找给定列表列每行列表之间的并集，不包含重复项。任何输入列表列中的 null 输入行将导致 null 输出行。在查找列表并集时，每个列表中的 null 和浮点 NaN 值被视为相等值。输入列表列必须具有相同的大小和相同的数据类型。
    
    Parameters
    
    lhs - 一侧的输入列表列。
    
    rhs - 另一侧的输入列表列。
    
    Returns
    
    包含并集结果的列表列。
  - listsDifferenceDistinct
```
public static ColumnVector listsDifferenceDistinct(ColumnView lhs,
                                                   ColumnView rhs)
```
    查找左列列表与右列列表之间的差集。具体来说，查找左列每个列表中不存在于右列相应列表中的元素（不包含重复项）。任何输入列表列中的 null 输入行将导致 null 输出行。在查找时，每个列表中的 null 和浮点 NaN 值被视为相等值。输入列表列必须具有相同的大小和相同的数据类型。
    
    Parameters
    
    lhs - 一侧的输入列表列。
    
    rhs - 另一侧的输入列表列。
    
    Returns
    
    包含差集结果的列表列。
  - generateListOffsets
```
public final ColumnVector generateListOffsets()
```
    根据每个列表的大小生成列表偏移量。注意：此 API 仅适用于 INT32。否则，行为未定义。并且不允许空值和负值。
    
    Returns
    
    一个大小为 N + 1 的列表偏移量列。
  - getScalarElement
```
public final Scalar getScalarElement(int index)
```
    将指定索引处的列中的单个项作为 Scalar 获取。请注意，这开销很大，可能涉及运行内核来复制数据。
    
    Parameters
    
    index - 要查看的索引。
    
    Returns
    
    该索引处的值作为标量。
    
    Throws
    
    CudfException - 如果索引越界。
  - applyBooleanMask
```
public final ColumnVector applyBooleanMask(ColumnView booleanMaskView)
```
    使用 `booleanMaskView` 布尔值列表作为掩码，过滤此 LIST 列中每一行的元素。
    给定一个布尔值列表列，该函数生成一个与此列类型相同的新 `LIST` 列，其中仅当对应的 `boolean_mask` 非 null 且为 `true` 时，才从该行复制每个元素。
    例如：column = { {0,1,2}, {3,4}, {5,6,7}, {8,9} }; boolean_mask = { {0,1,1}, {1,0}, {1,1,1}, {0,0} }; results = { {1,2}, {3}, {5,6,7}, {} };
    此列和 `boolean_mask` 必须具有相同的行数。输出列与此列具有相同的行数。仅当对应的 boolean_mask 元素为 `true` 时，才将元素复制到输出行。仅当行为无效时，输出行才无效。
    
    Parameters
    
    booleanMaskView - 一个可为 null 的布尔值列表列，用于过滤此列中的元素。
    
    Returns
    
    与此列类型相同的列表列，包含过滤后的列表行。
    
    Throws
    
    CudfException - 如果 `boolean_mask` 不是“布尔值列表”列。
    
    CudfException - 如果此列和 `boolean_mask` 的行数不同。
  - distinctCount
```
public int distinctCount(NullPolicy nullPolicy)
```
    计算列中有多少行互不相同（去重计数）。
    
    Parameters
    
    nullPolicy - 是否应包含 null。
  - distinctCount
```
public int distinctCount()
```
    计算列中有多少行彼此不同。包含 null。
  - title
```
protected static long title(long handle)
```
  - copyToHost
```
public HostColumnVector copyToHost(HostMemoryAllocator hostMemoryAllocator)
```
    同步将数据复制到主机。
  - copyToHostAsync
```
public HostColumnVector copyToHostAsync(Cuda.Stream stream,
                                        HostMemoryAllocator hostMemoryAllocator)
```
    将数据异步复制到主机。调用者在检查结果之前必须在流上同步。
  - copyToHost
```
public HostColumnVector copyToHost()
```
    同步将数据复制到主机内存
  - copyToHostAsync
```
public HostColumnVector copyToHostAsync(Cuda.Stream stream)
```
    将数据异步复制到主机。调用者在检查结果之前必须在流上同步。
  - getHostBytesRequired
```
public long getHostBytesRequired()
```
    计算将数据复制到主机所需的总空间。此空间应填充到 CPU 所需的对齐方式。
  - hostPaddingSizeInBytes
```
public static long hostPaddingSizeInBytes()
```
    获取主机用于对齐内存分配的大小（字节）。
  - hasNonEmptyNulls
```
public boolean hasNonEmptyNulls()
```
    精确检查列或其后代是否包含非空 null 行
    
    Returns
    
    列或其后代是否包含非空 null 行。
  - purgeNonEmptyNulls
```
public ColumnVector purgeNonEmptyNulls()
```
    将此列复制到输出中，同时清除列或其后代中的任何非空 null 行。如果此列不是复合类型（LIST/STRING/STRUCT/DICTIONARY），则输出将与输入相同。清除操作仅直接应用于 LIST 和 STRING 列，但它也间接应用于 STRUCT/DICTIONARY 列，因为这些列可能具有 LIST 或 STRING 的子列。示例：lists = data: [{{0,1}, {2,3}, {4,5}} validity: {true, false, true}] lists[1] 为 null，但列表的子列仍存储 `{2,3}`。清除列表的 null 行内容后，列内容将为：lists = [data: {{0,1}, {4,5}} validity: {true, false, true}]
    
    Returns
    
    内容等同于 `input` 的新列，但已清除 null 行。
  - toHex
```
public ColumnVector toHex()
```
    将此整数列转换为十六进制列并返回新的字符串列。任何空条目将导致输出列中出现相应的空条目。输出字符集为 '0'-'9' 和 'A'-'F'。输出字符串宽度将是 2 的倍数，具体取决于整数类型的大小。如果第一个非零输出字节小于 0x10，则会应用一个前导零。示例：input = [123, -1, 0, 27, 342718233] s = input.toHex() s is [ '04D2', 'FFFFFFFF', '00', '1B', '146D7719'] 上面的示例显示了一个 `INT32` 类型的列，其中每个整数是 4 个字节。前导零被抑制，除非填满完整的字节，例如 `123 -> '04D2'` 而不是 `000004D2` 或 `4D2`。
    
    Returns
    
    新的字符串 ColumnVector。

类 ColumnView

嵌套类摘要

字段摘要

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Methods inherited from interface ai.rapids.cudf.BinaryOperable

Field Detail

UNKNOWN_NULL_COUNT

viewHandle

type

rows

nullCount

offHeap

Constructor Detail

ColumnView

ColumnView

ColumnView

ColumnView

Method Detail

copyToColumnVector

getNativeView

getType

getChildColumnViews

getChildColumnView

getListOffsetsView

getData

getOffsets

getValid

getNullCount

getRowCount

getNumChildren

getDeviceMemorySize

close

toString

nansToNulls

getCharLengths

getByteCount

codePoints

countElements

isNotNull

isNull

isFixedPoint

isInteger

isInteger

isFloat

isNan

isNotNan

findAndReplaceAll

replaceNulls

replaceNulls

replaceNulls

ifElse

ifElse

ifElse

ifElse

slice

subVector

subVector

split

splitAsViews

normalizeNANsAndZeros

mergeAndSetValidity

extractDateTimeComponent

year

month

day

hour

minute

second

weekDay

lastDayOfMonth

dayOfYear

quarterOfYear

addCalendricalMonths

addCalendricalMonths

isLeapYear

daysInMonth

dateTimeCeil

dateTimeFloor