ArrayWrapper (ujava-common 7.0.0 API)

java.lang.Object
- cn.ujava.common.array.ArrayWrapper<A,E>

类型参数:

A - 数组类型

E - 数组元素类型

所有已实现的接口:

Wrapper<A>, Iterable<E>
```
public class ArrayWrapper<A,E>
extends Object
implements Wrapper<A>, Iterable<E>
```
数组包装，提供一系列数组方法

作者:

ujava

从以下版本开始:

6.0.0

构造器概要

构造器
构造器和说明

ArrayWrapper(A array)
构造

构造器
构造器和说明
`ArrayWrapper(A array)` 构造

方法概要

所有方法静态方法实例方法具体方法
限定符和类型	方法和说明
`ArrayWrapper<A,E>`	`append(E element)` 将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
`ArrayWrapper<A,E>`	`appendArray(A array)` 将新数组追加到已有数组中追加新数组会生成一个新的数组，不影响原数组
`ArrayWrapper<A,E>`	`edit(UnaryOperator<E> editor)` 对每个数组元素执行指定操作，替换元素为修改后的元素
`E`	`firstMatch(Predicate<E> matcher)` 返回数组中第一个匹配规则的值
`E`	`firstNonNull()` 返回数组中第一个非空元素
`E`	`get(int index)` 获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值如果数组下标越界，返回null
`Class<?>`	`getArrayType()` 获得数组类型
`Class<?>`	`getComponentType()` 获取数组对象的元素类型，方法调用参数与返回结果举例： Object[] =》 Object.class String[] =》 String.class int[] =》 int.class Integer[] =》 Integer.class null =》 null String =》 null
`A`	`getRaw()` 获取原始对象
`A`	`getSub(int beginInclude, int endExclude)` 获取子数组
`A`	`getSub(int beginInclude, int endExclude, int step)` 获取子数组
`int`	`indexOf(Object value)` 返回数组中指定元素所在位置，未找到返回`PrimitiveArrayUtil.INDEX_NOT_FOUND`
`int`	`indexOf(Object value, int offset)` 返回数组中指定元素所在位置，未找到返回`PrimitiveArrayUtil.INDEX_NOT_FOUND`
`ArrayWrapper<A,E>`	`insert(int index, E element)` 将新元素插入到已有数组中的某个位置如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充
`ArrayWrapper<A,E>`	`insertArray(int index, A arrayToInsert)` 将新元素插入到已有数组中的某个位置如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充
`boolean`	`isEmpty()` 数组是否为空
`boolean`	`isPrimitive()` 是否原始类型数组
`boolean`	`isSorted(Comparator<E> comparator)` 检查数组是否有序，升序或者降序若传入空数组，则返回`false`；元素全部相等，返回 `true`
`boolean`	`isSorted(Comparator<E> comparator, boolean isDESC)` 数组是否有有序反序，前一个小于后一个则返回错正序，前一个大于后一个则返回错
`Iterator<E>`	`iterator()`
`int`	`lastIndexOf(Object value)` 返回数组中指定最后的所在位置，未找到返回`PrimitiveArrayUtil.INDEX_NOT_FOUND`
`int`	`length()` 获取数组长度
`int`	`matchIndex(int offset, Predicate<E> matcher)` 返回数组中第一个匹配规则的值的位置
`int`	`matchIndex(Predicate<E> matcher)` 返回数组中第一个匹配规则的值的位置
`int`	`matchLastIndex(int offset, Predicate<E> matcher)` 返回数组中最后一个匹配规则的值的位置(从后向前查找)
`int`	`matchLastIndex(Predicate<E> matcher)` 返回数组中最后一个匹配规则的值的位置(从后向前查找)
`static <A,E> ArrayWrapper<A,E>`	`of(A array)` 包装数组为ArrayWrapper
`static <A,E> ArrayWrapper<A,E>`	`of(Class<E> componentType, int length)` 创建ArrayWrapper，创建一个指定长度的空数组
`ArrayWrapper<A,E>`	`replace(int index, A values)` 从数组中的指定位置开始，按顺序使用新元素替换旧元素如果指定位置为负数，那么生成一个新数组，其中新元素按顺序放在数组头部如果指定位置大于等于旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部如果指定位置加上新元素数量大于旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组
`ArrayWrapper<A,E>`	`setOrAppend(int index, E value)` 将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
`ArrayWrapper<A,E>`	`setOrPadding(int index, E value)` 将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加`null`或`0`直到到达index后，设置值
`ArrayWrapper<A,E>`	`setOrPadding(int index, E value, E paddingElement)` 将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加`paddingElement`直到到达index后，设置值
`String`	`toString()`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

从接口继承的方法 java.lang.Iterable
forEach, spliterator

- 构造器详细资料
  - ArrayWrapper
```
public ArrayWrapper(A array)
```
    构造
    
    参数:
    
    array - 数组对象（非空）
- 方法详细资料
  - of
```
public static <A,E> ArrayWrapper<A,E> of(Class<E> componentType,
                                         int length)
```
    创建ArrayWrapper，创建一个指定长度的空数组
    
    类型参数:
    
    A - 数组类型
    
    E - 数组元素类型
    
    参数:
    
    componentType - 元素类型
    
    length - 长度
    
    返回:
    
    ArrayWrapper
  - of
```
public static <A,E> ArrayWrapper<A,E> of(A array)
```
    包装数组为ArrayWrapper
    
    类型参数:
    
    A - 数组类型
    
    E - 元素类型
    
    参数:
    
    array - 数组（非空）
    
    返回:
    
    ArrayWrapper
  - getRaw
```
public A getRaw()
```
    从接口复制的说明: Wrapper
    
    获取原始对象
    
    指定者:
    
    getRaw 在接口中 Wrapper<A>
    
    返回:
    
    原始对象
  - length
```
public int length()
```
    获取数组长度
    
    返回:
    
    数组长度
  - isPrimitive
```
public boolean isPrimitive()
```
    是否原始类型数组
    
    返回:
    
    是否原始类型数组
  - getComponentType
```
public Class<?> getComponentType()
```
    获取数组对象的元素类型，方法调用参数与返回结果举例：
    - Object[] =》 Object.class
    - String[] =》 String.class
    - int[] =》 int.class
    - Integer[] =》 Integer.class
    - null =》 null
    - String =》 null
    返回:
    
    元素类型
  - getArrayType
```
public Class<?> getArrayType()
```
    获得数组类型
    
    返回:
    
    数组类型
  - isEmpty
```
public boolean isEmpty()
```
    数组是否为空
    
    返回:
    
    是否为空
  - get
```
public E get(int index)
```
    获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值
    如果数组下标越界，返回null
    
    参数:
    
    index - 下标，支持负数，-1表示最后一个元素
    
    返回:
    
    值
  - firstNonNull
```
public E firstNonNull()
```
    返回数组中第一个非空元素
    
    返回:
    
    第一个非空元素，如果不存在非空元素或数组为空，返回null
  - firstMatch
```
public E firstMatch(Predicate<E> matcher)
```
    返回数组中第一个匹配规则的值
    
    参数:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    返回:
    
    第一个匹配元素，如果不存在匹配元素或数组为空，返回 null
  - indexOf
```
public int indexOf(Object value)
```
    返回数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    参数:
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
  - matchIndex
```
public int matchIndex(Predicate<E> matcher)
```
    返回数组中第一个匹配规则的值的位置
    
    参数:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    返回:
    
    第一个匹配元素的位置，PrimitiveArrayUtil.INDEX_NOT_FOUND表示未匹配到
  - indexOf
```
public int indexOf(Object value,
                   int offset)
```
    返回数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    参数:
    
    value - 被检查的元素
    
    offset - 开始的位置
    
    返回:
    
    数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
  - matchIndex
```
public int matchIndex(int offset,
                      Predicate<E> matcher)
```
    返回数组中第一个匹配规则的值的位置
    
    参数:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    offset - 检索开始的位置，不能为负数
    
    返回:
    
    第一个匹配元素的位置，PrimitiveArrayUtil.INDEX_NOT_FOUND表示未匹配到
  - lastIndexOf
```
public int lastIndexOf(Object value)
```
    返回数组中指定最后的所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    参数:
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素最后的所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
  - matchLastIndex
```
public int matchLastIndex(Predicate<E> matcher)
```
    返回数组中最后一个匹配规则的值的位置(从后向前查找)
    
    参数:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    返回:
    
    最后一个匹配元素的位置，PrimitiveArrayUtil.INDEX_NOT_FOUND表示未匹配到
  - matchLastIndex
```
public int matchLastIndex(int offset,
                          Predicate<E> matcher)
```
    返回数组中最后一个匹配规则的值的位置(从后向前查找)
    
    参数:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    offset - 从后向前查找时的起始位置，一般为array.length - 1
    
    返回:
    
    最后一个匹配元素的位置，PrimitiveArrayUtil.INDEX_NOT_FOUND表示未匹配到
  - setOrPadding
```
public ArrayWrapper<A,E> setOrPadding(int index,
                                      E value)
```
    将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加null或0直到到达index后，设置值
    
    参数:
    
    index - 位置
    
    value - 新元素或新数组
    
    返回:
    
    this
    
    从以下版本开始:
    
    6.0.0
  - setOrPadding
```
public ArrayWrapper<A,E> setOrPadding(int index,
                                      E value,
                                      E paddingElement)
```
    将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加paddingElement直到到达index后，设置值
    
    参数:
    
    index - 位置
    
    value - 新元素或新数组
    
    paddingElement - 填充
    
    返回:
    
    this
    
    从以下版本开始:
    
    6.0.0
  - setOrAppend
```
public ArrayWrapper<A,E> setOrAppend(int index,
                                     E value)
```
    将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
    
    参数:
    
    index - 位置，大于等于长度则追加，否则替换
    
    value - 新元素或新数组
    
    返回:
    
    this
  - append
```
public ArrayWrapper<A,E> append(E element)
```
    将新元素添加到已有数组中
    添加新元素会生成一个新的数组，不影响原数组
    
    参数:
    
    element - 新元素或新数组
    
    返回:
    
    新数组
  - appendArray
```
public ArrayWrapper<A,E> appendArray(A array)
```
    将新数组追加到已有数组中
    追加新数组会生成一个新的数组，不影响原数组
    
    参数:
    
    array - 需要追加的数组数组
    
    返回:
    
    新数组
  - insert
```
public ArrayWrapper<A,E> insert(int index,
                                E element)
```
    将新元素插入到已有数组中的某个位置如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充
    
    参数:
    
    index - 插入位置，支持负数。此位置为对应此位置元素之前的空档
    
    element - 元素
    
    返回:
    
    新数组
  - insertArray
```
public ArrayWrapper<A,E> insertArray(int index,
                                     A arrayToInsert)
```
    将新元素插入到已有数组中的某个位置如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充
    
    参数:
    
    index - 插入位置，支持负数。此位置为对应此位置元素之前的空档
    
    arrayToInsert - 新元素数组
    
    返回:
    
    新数组
  - replace
```
public ArrayWrapper<A,E> replace(int index,
                                 A values)
```
    从数组中的指定位置开始，按顺序使用新元素替换旧元素
    - 如果指定位置为负数，那么生成一个新数组，其中新元素按顺序放在数组头部
    - 如果指定位置大于等于旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部
    - 如果指定位置加上新元素数量大于旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素
    - 否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组
    参数:
    
    index - 位置
    
    values - 新值或新数组
    
    返回:
    
    this
  - edit
```
public ArrayWrapper<A,E> edit(UnaryOperator<E> editor)
```
    对每个数组元素执行指定操作，替换元素为修改后的元素
    
    参数:
    
    editor - 编辑器接口，为 null则返回原数组
    
    返回:
    
    this
  - getSub
```
public A getSub(int beginInclude,
                int endExclude)
```
    获取子数组
    
    参数:
    
    beginInclude - 开始位置（包括）
    
    endExclude - 结束位置（不包括）
    
    返回:
    
    新的数组
    
    从以下版本开始:
    
    4.2.2
    
    另请参阅:
    
    Arrays.copyOfRange(Object[], int, int)
  - getSub
```
public A getSub(int beginInclude,
                int endExclude,
                int step)
```
    获取子数组
    
    参数:
    
    beginInclude - 开始位置（包括）
    
    endExclude - 结束位置（不包括）
    
    step - 步进
    
    返回:
    
    新的数组
  - isSorted
```
public boolean isSorted(Comparator<E> comparator)
```
    检查数组是否有序，升序或者降序
    若传入空数组，则返回false；元素全部相等，返回 true
    
    参数:
    
    comparator - 比较器
    
    返回:
    
    数组是否有序
    
    抛出:
    
    NullPointerException - 如果数组元素含有null值
    
    从以下版本开始:
    
    6.0.0
  - isSorted
```
public boolean isSorted(Comparator<E> comparator,
                        boolean isDESC)
```
    数组是否有有序
    - 反序，前一个小于后一个则返回错
    - 正序，前一个大于后一个则返回错
    参数:
    
    comparator - Comparator
    
    isDESC - 是否反序
    
    返回:
    
    是否有序
  - iterator
```
public Iterator<E> iterator()
```
    指定者:
    
    iterator 在接口中 Iterable<E>
  - toString
```
public String toString()
```
    覆盖:
    
    toString 在类中 Object

类 ArrayWrapper<A,E>

构造器概要

方法概要

从类继承的方法 java.lang.Object

从接口继承的方法 java.lang.Iterable

构造器详细资料

ArrayWrapper

方法详细资料

of

of

getRaw

length

isPrimitive

getComponentType

getArrayType

isEmpty

get

firstNonNull

firstMatch

indexOf

matchIndex

indexOf

matchIndex

lastIndexOf

matchLastIndex

matchLastIndex

setOrPadding

setOrPadding

setOrAppend

append

appendArray

insert

insertArray

replace

edit

getSub

getSub

isSorted

isSorted

iterator

toString