Longs (polaris-toolkit 3.3.6 API)

java.lang.Object
- io.polaris.core.lang.primitive.Longs

```
public class Longs
extends Object
```
从以下版本开始:

Sep 28, 2024

作者:

Qt

构造器概要

构造器
构造器和说明

Longs()

构造器
构造器和说明
`Longs()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static boolean`	`contains(long[] array, long value)` 数组中是否包含元素
`static long`	`defaultIfZero(long value)` 如果给定值为0，返回1，否则返回原值
`static long`	`defaultIfZero(long value, long defaultValue)`
`static int`	`indexOf(long[] array, long value)` 返回数组中指定元素所在位置，未找到返回 -1
`static boolean`	`isEmpty(long[] array)` 数组是否为空
`static boolean`	`isNotEmpty(long[] array)` 数组是否为非空
`static boolean`	`isSorted(long[] array)` 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
`static boolean`	`isSortedAsc(long[] array)` 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
`static boolean`	`isSortedDesc(long[] array)` 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
`static long[]`	`join(long[]... arrays)` 将多个数组合并在一起忽略null的数组
`static int`	`lastIndexOf(long[] array, long value)` 返回数组中指定元素所在最后的位置，未找到返回 -1
`static long`	`max(long... numberArray)` 取最大值
`static long`	`min(long... numberArray)` 取最小值
`static long`	`parse(String text, int radix)`
`static long`	`parseBin(String text)`
`static long`	`parseHex(String text)`
`static long`	`parseOct(String text)`
`static long[]`	`remove(long[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static long[]`	`removeElement(long[] array, long element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static long[]`	`reverse(long[] array)` 反转数组，会变更原数组
`static long[]`	`reverse(long[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static long[]`	`shuffle(long[] array)` 打乱数组顺序，会变更原数组
`static long[]`	`shuffle(long[] array, Random random)` 打乱数组顺序，会变更原数组
`static long[]`	`sub(long[] array, int start, int end)` 获取子数组
`static long[]`	`swap(long[] array, int index1, int index2)` 交换数组中两个位置的值
`static String`	`toBinStr(long num)`
`static String`	`toHexString(long num)`
`static String`	`toOctStr(long num)`
`static long[]`	`unwrap(Long... values)` 包装类数组转为原始类型数组
`static Long[]`	`wrap(long... values)` 将原始类型数组包装为包装类型

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

- 构造器详细资料
  - Longs
```
public Longs()
```
- 方法详细资料
  - toBinStr
```
public static String toBinStr(long num)
```
  - toOctStr
```
public static String toOctStr(long num)
```
  - toHexString
```
public static String toHexString(long num)
```
  - parseBin
```
public static long parseBin(String text)
```
  - parseOct
```
public static long parseOct(String text)
```
  - parseHex
```
public static long parseHex(String text)
```
  - parse
```
public static long parse(String text,
                         int radix)
```
  - join
```
public static long[] join(long[]... arrays)
```
    将多个数组合并在一起
    忽略null的数组
    
    参数:
    
    arrays - 数组集合
    
    返回:
    
    合并后的数组
  - wrap
```
public static Long[] wrap(long... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unwrap
```
public static long[] unwrap(Long... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - sub
```
public static long[] sub(long[] array,
                         int start,
                         int end)
```
    获取子数组
    
    参数:
    
    array - 数组
    
    start - 开始位置（包括）
    
    end - 结束位置（不包括）
    
    返回:
    
    新的数组
    
    另请参阅:
    
    Arrays.copyOfRange(Object[], int, int)
  - remove
```
public static long[] remove(long[] array,
                            int index)
                     throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
  - removeElement
```
public static long[] removeElement(long[] array,
                                   long element)
                            throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
  - reverse
```
public static long[] reverse(long[] array,
                             int startIndexInclusive,
                             int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 起始位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
  - reverse
```
public static long[] reverse(long[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
  - min
```
public static long min(long... numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
  - max
```
public static long max(long... numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
  - shuffle
```
public static long[] shuffle(long[] array)
```
    打乱数组顺序，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    打乱后的数组
  - shuffle
```
public static long[] shuffle(long[] array,
                             Random random)
```
    打乱数组顺序，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    random - 随机数生成器
    
    返回:
    
    打乱后的数组
  - swap
```
public static long[] swap(long[] array,
                          int index1,
                          int index2)
```
    交换数组中两个位置的值
    
    参数:
    
    array - 数组
    
    index1 - 位置1
    
    index2 - 位置2
    
    返回:
    
    交换后的数组，与传入数组为同一对象
  - indexOf
```
public static int indexOf(long[] array,
                          long value)
```
    返回数组中指定元素所在位置，未找到返回 -1
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回 -1
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long value)
```
    返回数组中指定元素所在最后的位置，未找到返回 -1
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回 -1
  - contains
```
public static boolean contains(long[] array,
                               long value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
  - isSorted
```
public static boolean isSorted(long[] array)
```
    检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    数组是否升序
  - isSortedAsc
```
public static boolean isSortedAsc(long[] array)
```
    检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    数组是否升序
  - isSortedDesc
```
public static boolean isSortedDesc(long[] array)
```
    检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    数组是否降序
  - isEmpty
```
public static boolean isEmpty(long[] array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isNotEmpty
```
public static boolean isNotEmpty(long[] array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - defaultIfZero
```
public static long defaultIfZero(long value,
                                 long defaultValue)
```
  - defaultIfZero
```
public static long defaultIfZero(long value)
```
    如果给定值为0，返回1，否则返回原值
    
    参数:
    
    value - 值
    
    返回:
    
    1或非0值

类 Longs

构造器概要

方法概要

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

构造器详细资料

Longs

方法详细资料

toBinStr

toOctStr

toHexString

parseBin

parseOct

parseHex

parse

join

wrap

unwrap

sub

remove

removeElement

reverse

reverse

min

max

shuffle

shuffle

swap

indexOf

lastIndexOf

contains

isSorted

isSortedAsc

isSortedDesc

isEmpty

isNotEmpty

defaultIfZero

defaultIfZero