模块 aya.ij.parsing.core
程序包 com.intellij.util

类 ArrayUtil

java.lang.Object
com.intellij.util.ArrayUtil
public final class ArrayUtil extends Object

  • 字段概要

    字段
    修饰符和类型
    字段
    说明
    static final byte[]
    EMPTY_BYTE_ARRAY
     
    static final char[]
    EMPTY_CHAR_ARRAY
     
    static final CharSequence
    EMPTY_CHAR_SEQUENCE
    已过时。
    use Strings.EMPTY_CHAR_SEQUENCE instead
    static final Class<?>[]
    EMPTY_CLASS_ARRAY
     
    static final double[]
    EMPTY_DOUBLE_ARRAY
     
    static final File[]
    EMPTY_FILE_ARRAY
     
    static final int[]
    EMPTY_INT_ARRAY
     
    static final long[]
    EMPTY_LONG_ARRAY
     
    static final Object[]
    EMPTY_OBJECT_ARRAY
     
    static final Runnable[]
    EMPTY_RUNNABLE_ARRAY
     
    static final String[]
    EMPTY_STRING_ARRAY
     
    static final ArrayFactory<Object>
    OBJECT_ARRAY_FACTORY
     
    static final ArrayFactory<String>
    STRING_ARRAY_FACTORY
     

  • 方法概要

    修饰符和类型
    方法
    说明
    static boolean @NotNull []
    append(boolean @NotNull [] array, boolean value)
     
    static byte @NotNull []
    append(byte @NotNull [] array, byte value)
     
    static int @NotNull []
    append(int @NotNull [] array, int value)
     
    static long @NotNull []
    append(long @NotNull [] array, long value)
     
    static <T> T @NotNull []
    append(T @NotNull [] src, T element)
    Appends element to the src array.
    static <T> T @NotNull []
    append(T @NotNull [] src, T element, @NotNull ArrayFactory<? extends T> factory)
     
    static <T> T @NotNull []
    append(T @NotNull [] src, T element, @NotNull Class<T> componentType)
     
    static long
    averageAmongMedians(int @NotNull [] time, int part)
     
    static long
    averageAmongMedians(long @NotNull [] time, int part)
     
    static boolean
    contains(@Nullable String s, String @NotNull ... strings)
     
    static <T> boolean
    contains(T o, T @NotNull ... objects)
     
    static <T> void
    copy(@NotNull Collection<? extends T> src, T @NotNull [] dst, int dstOffset)
     
    static boolean @Nullable []
    copyOf(boolean @Nullable [] original)
     
    static byte @Nullable []
    copyOf(byte @Nullable [] original)
     
    static int @Nullable []
    copyOf(int @Nullable [] original)
     
    static <T> T @Nullable []
    copyOf(T @Nullable [] original)
     
    static <E> E @NotNull []
    ensureExactSize(int count, E @NotNull [] sample)
     
    static <T> boolean
    equals(T @NotNull [] a1, T @NotNull [] a2, @NotNull Comparator<? super T> comparator)
    已过时。
    Use Arrays.equals(Object[], Object[], Comparator)
    static int
    find(int @NotNull [] src, int obj)
     
    static <T> int
    find(T @NotNull [] src, T obj)
     
    static <T> @NotNull Class<T>
    getComponentType(T @NotNull [] collection)
     
    static <T> T
    getFirstElement(T @Nullable [] array)
     
    static int
    getLastElement(int @Nullable [] array, int defaultValue)
     
    static <T> T
    getLastElement(T @Nullable [] array)
     
    static int
    indexOf(byte @NotNull [] array, byte @NotNull [] pattern, int startIndex)
     
    static int
    indexOf(int @NotNull [] ints, int value)
     
    static int
    indexOf(long @NotNull [] ints, long value)
     
    static <T> int
    indexOf(@NotNull List<? extends T> objects, T object, @NotNull BiPredicate<? super T,? super T> predicate)
     
    static int
    indexOf(Object @NotNull [] objects, @Nullable Object object)
     
    static <T> int
    indexOf(T @NotNull [] objects, T object, @NotNull BiPredicate<? super T,? super T> comparator)
     
    static <T> int
    indexOfIdentity(T @NotNull [] array, T element)
     
    static char @NotNull []
    insert(char @NotNull [] array, int index, char value)
     
    static int @NotNull []
    insert(int @NotNull [] array, int index, int value)
     
    static long @NotNull []
    insert(long @NotNull [] array, int index, long value)
     
    static <T> T @NotNull []
    insert(T @NotNull [] array, int index, T value)
     
    static int[]
    intersection(int @NotNull [] a1, int @NotNull [] a2)
     
    static <T> boolean
    isEmpty(T @Nullable [] array)
     
    static int
    lastIndexOf(int @NotNull [] src, int obj)
     
    static <T> int
    lastIndexOf(@NotNull List<? extends T> src, T obj, @NotNull BiPredicate<? super T,? super T> comparator)
     
    static <T> int
    lastIndexOf(T @NotNull [] src, T obj)
     
    static <T> int
    lastIndexOf(T @NotNull [] src, T obj, @NotNull BiPredicate<? super T,? super T> predicate)
     
    static int
    lastIndexOfNot(int @NotNull [] src, int obj)
     
    static int
    lexicographicCompare(int @NotNull [] obj1, int @NotNull [] obj2)
     
    static int
    lexicographicCompare(String @NotNull [] obj1, String @NotNull [] obj2)
     
    static <T extends Comparable<T>>
    int
    lexicographicCompare(T @NotNull [] obj1, T @NotNull [] obj2)
     
    static double
    max(double @NotNull [] values)
     
    static int
    max(int @NotNull [] values)
     
    static <T> T @NotNull []
    mergeArrayAndCollection(T @NotNull [] array, @NotNull Collection<? extends T> collection, @NotNull ArrayFactory<? extends T> factory)
    Allocates new array of size array.length + collection.size() and copies elements of array and collection to it.
    static byte @NotNull []
    mergeArrays(byte @NotNull [] a1, byte @NotNull [] a2)
     
    static int @NotNull []
    mergeArrays(int @NotNull [] a1, int @NotNull [] a2)
     
    static String @NotNull []
    mergeArrays(String @NotNull [] a1, String @NotNull ... a2)
     
    static <T> T @NotNull []
    mergeArrays(T @NotNull [] a1, T @NotNull [] a2)
     
    static <T> T @NotNull []
    mergeArrays(T @NotNull [] a1, T @NotNull [] a2, @NotNull ArrayFactory<? extends T> factory)
     
    static <T> T @NotNull []
    mergeCollections(@NotNull Collection<? extends T> c1, @NotNull Collection<? extends T> c2, @NotNull ArrayFactory<? extends T> factory)
     
    static int[]
    mergeSortedArrays(int @NotNull [] a1, int @NotNull [] a2, boolean mergeEqualItems)
     
    static int
    min(int @NotNull [] values)
     
    static <T> T @NotNull []
    newArray(@NotNull Class<T> type, int length)
     
    static byte @NotNull []
    newByteArray(int count)
     
    static int @NotNull []
    newIntArray(int count)
     
    static long @NotNull []
    newLongArray(int count)
     
    static Object @NotNull []
    newObjectArray(int count)
     
    static String @NotNull []
    newStringArray(int count)
     
    static byte @NotNull []
    prepend(byte element, byte @NotNull [] array)
     
    static <T> T @NotNull []
    prepend(T element, T @NotNull [] array)
     
    static <T> T @NotNull []
    prepend(T element, T @NotNull [] src, @NotNull ArrayFactory<? extends T> factory)
     
    static <T> T @NotNull []
    prepend(T element, T @NotNull [] array, @NotNull Class<T> type)
     
    static boolean @NotNull []
    realloc(boolean @NotNull [] array, int newSize)
     
    static byte @NotNull []
    realloc(byte @NotNull [] array, int newSize)
     
    static char @NotNull []
    realloc(char @NotNull [] array, int newSize)
     
    static double @NotNull []
    realloc(double @NotNull [] array, int newSize)
     
    static int @NotNull []
    realloc(int @NotNull [] array, int newSize)
     
    static long @NotNull []
    realloc(long @NotNull [] array, int newSize)
     
    static short @NotNull []
    realloc(short @NotNull [] array, int newSize)
     
    static <T> T @NotNull []
    realloc(T @NotNull [] array, int newSize, @NotNull ArrayFactory<? extends T> factory)
     
    static int @NotNull []
    remove(int @NotNull [] src, int idx)
     
    static short @NotNull []
    remove(short @NotNull [] src, int idx)
     
    static <T> T @NotNull []
    remove(T @NotNull [] src, int idx)
    Removes element with index idx from array src.
    static <T> T @NotNull []
    remove(T @NotNull [] src, int idx, @NotNull ArrayFactory<? extends T> factory)
     
    static <T> T @NotNull []
    remove(T @NotNull [] src, T element)
     
    static <T> T @NotNull []
    remove(T @NotNull [] src, T element, @NotNull ArrayFactory<? extends T> factory)
     
    static int @NotNull []
    reverseArray(int @NotNull [] array)
     
    static <T> T @NotNull []
    reverseArray(T @NotNull [] array)
     
    static <T> void
    rotateLeft(T @NotNull [] array, int i1, int i2)
     
    static <T> void
    rotateRight(T @NotNull [] array, int i1, int i2)
     
    static boolean
    startsWith(byte @NotNull [] array, byte @NotNull [] prefix)
     
    static boolean
    startsWith(byte @NotNull [] array, int start, byte @NotNull [] subArray)
     
    static <E> boolean
    startsWith(E @NotNull [] array, E @NotNull [] subArray)
     
    static <T> T @NotNull []
    stripTrailingNulls(T @NotNull [] array)
     
    static void
    swap(boolean @NotNull [] array, int i1, int i2)
     
    static void
    swap(char @NotNull [] array, int i1, int i2)
     
    static void
    swap(int @NotNull [] array, int i1, int i2)
     
    static <T> void
    swap(T @NotNull [] array, int i1, int i2)
     
    static int @NotNull []
    toIntArray(@NotNull Collection<Integer> list)
     
    static <T> T @NotNull []
    toObjectArray(@NotNull Class<T> aClass, Object @NotNull ... source)
     
    static Object @NotNull []
    toObjectArray(@NotNull Collection<?> collection)
     
    static <T> T @NotNull []
    toObjectArray(@NotNull Collection<? extends T> collection, @NotNull Class<T> aClass)
     
    static String @NotNull []
    toStringArray(@Nullable Collection<String> collection)
     

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

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • 字段详细资料

    • EMPTY_CHAR_ARRAY

      public static final char[] EMPTY_CHAR_ARRAY

    • EMPTY_BYTE_ARRAY

      public static final byte[] EMPTY_BYTE_ARRAY

    • EMPTY_DOUBLE_ARRAY

      public static final double[] EMPTY_DOUBLE_ARRAY

    • EMPTY_INT_ARRAY

      public static final int[] EMPTY_INT_ARRAY

    • EMPTY_OBJECT_ARRAY

      public static final Object[] EMPTY_OBJECT_ARRAY

    • EMPTY_STRING_ARRAY

      public static final String[] EMPTY_STRING_ARRAY

    • EMPTY_CLASS_ARRAY

      public static final Class<?>[] EMPTY_CLASS_ARRAY

    • EMPTY_LONG_ARRAY

      public static final long[] EMPTY_LONG_ARRAY

    • EMPTY_FILE_ARRAY

      public static final File[] EMPTY_FILE_ARRAY

    • EMPTY_RUNNABLE_ARRAY

      public static final Runnable[] EMPTY_RUNNABLE_ARRAY

    • EMPTY_CHAR_SEQUENCE

      @Deprecated public static final CharSequence EMPTY_CHAR_SEQUENCE
      已过时。
      use Strings.EMPTY_CHAR_SEQUENCE instead

    • STRING_ARRAY_FACTORY

      public static final ArrayFactory<String> STRING_ARRAY_FACTORY

    • OBJECT_ARRAY_FACTORY

      public static final ArrayFactory<Object> OBJECT_ARRAY_FACTORY

  • 方法详细资料

    • realloc

      @Contract(pure=true) public static byte @NotNull [] realloc(byte @NotNull [] array, int newSize)

    • realloc

      @Contract(pure=true) public static double @NotNull [] realloc(double @NotNull [] array, int newSize)

    • realloc

      @Contract(pure=true) public static boolean @NotNull [] realloc(boolean @NotNull [] array, int newSize)

    • realloc

      @Contract(pure=true) public static short @NotNull [] realloc(short @NotNull [] array, int newSize)

    • realloc

      @Contract(pure=true) public static long @NotNull [] realloc(long @NotNull [] array, int newSize)

    • realloc

      @Contract(pure=true) public static int @NotNull [] realloc(int @NotNull [] array, int newSize)

    • realloc

      @Contract(pure=true) public static <T> T @NotNull [] realloc(T @NotNull [] array, int newSize, @NotNull @NotNull ArrayFactory<? extends T> factory)

    • append

      @Contract(pure=true) public static long @NotNull [] append(long @NotNull [] array, long value)

    • append

      @Contract(pure=true) public static int @NotNull [] append(int @NotNull [] array, int value)

    • insert

      @Contract(pure=true) public static <T> T @NotNull [] insert(T @NotNull [] array, int index, T value)

    • insert

      @Contract(pure=true) public static int @NotNull [] insert(int @NotNull [] array, int index, int value)

    • insert

      @Contract(pure=true) public static long @NotNull [] insert(long @NotNull [] array, int index, long value)

    • insert

      @Contract(pure=true) public static char @NotNull [] insert(char @NotNull [] array, int index, char value)

    • append

      @Contract(pure=true) public static byte @NotNull [] append(byte @NotNull [] array, byte value)

    • append

      @Contract(pure=true) public static boolean @NotNull [] append(boolean @NotNull [] array, boolean value)

    • realloc

      @Contract(pure=true) public static char @NotNull [] realloc(char @NotNull [] array, int newSize)

    • toObjectArray

      @Contract(pure=true) public static <T> T @NotNull [] toObjectArray(@NotNull @NotNull Collection<? extends T> collection, @NotNull @NotNull Class<T> aClass)

    • toObjectArray

      @Contract(pure=true) public static <T> T @NotNull [] toObjectArray(@NotNull @NotNull Class<T> aClass, Object @NotNull ... source)

    • toObjectArray

      @Contract(pure=true) public static Object @NotNull [] toObjectArray(@NotNull @NotNull Collection<?> collection)

    • toIntArray

      @Contract(pure=true) public static int @NotNull [] toIntArray(@NotNull @NotNull Collection<Integer> list)

    • mergeArrays

      @Contract(pure=true) public static <T> T @NotNull [] mergeArrays(T @NotNull [] a1, T @NotNull [] a2)

    • mergeCollections

      @Contract(pure=true) public static <T> T @NotNull [] mergeCollections(@NotNull @NotNull Collection<? extends T> c1, @NotNull @NotNull Collection<? extends T> c2, @NotNull @NotNull ArrayFactory<? extends T> factory)

    • mergeArrays

      @Contract(pure=true) public static <T> T @NotNull [] mergeArrays(T @NotNull [] a1, T @NotNull [] a2, @NotNull @NotNull ArrayFactory<? extends T> factory)

    • mergeArrays

      @Contract(pure=true) public static String @NotNull [] mergeArrays(String @NotNull [] a1, String @NotNull ... a2)

    • mergeArrays

      @Contract(pure=true) public static int @NotNull [] mergeArrays(int @NotNull [] a1, int @NotNull [] a2)

    • mergeArrays

      @Contract(pure=true) public static byte @NotNull [] mergeArrays(byte @NotNull [] a1, byte @NotNull [] a2)

    • intersection

      @Contract(pure=true) public static int[] intersection(int @NotNull [] a1, int @NotNull [] a2)

    • mergeArrayAndCollection

      @Contract(pure=true) public static <T> T @NotNull [] mergeArrayAndCollection(T @NotNull [] array, @NotNull @NotNull Collection<? extends T> collection, @NotNull @NotNull ArrayFactory<? extends T> factory)
      Allocates new array of size array.length + collection.size() and copies elements of array and collection to it.
      参数:
      array - source array
      collection - source collection
      factory - array factory used to create destination array of type T
      返回:
      destination array

    • append

      @Contract(pure=true) public static <T> T @NotNull [] append(T @NotNull [] src, @Nullable T element)
      Appends element to the src array. As you can imagine the appended element will be the last one in the returned result.
      参数:
      src - array to which the element should be appended.
      element - object to be appended to the end of src array.
      返回:
      new array

    • prepend

      @Contract(pure=true) public static <T> T @NotNull [] prepend(T element, T @NotNull [] array)

    • prepend

      @Contract(pure=true) public static <T> T @NotNull [] prepend(T element, T @NotNull [] array, @NotNull @NotNull Class<T> type)

    • prepend

      @Contract(pure=true) public static <T> T @NotNull [] prepend(T element, T @NotNull [] src, @NotNull @NotNull ArrayFactory<? extends T> factory)

    • prepend

      @Contract(pure=true) public static byte @NotNull [] prepend(byte element, byte @NotNull [] array)

    • append

      @Contract(pure=true) public static <T> T @NotNull [] append(T @NotNull [] src, T element, @NotNull @NotNull ArrayFactory<? extends T> factory)

    • append

      @Contract(pure=true) public static <T> T @NotNull [] append(T @NotNull [] src, @Nullable T element, @NotNull @NotNull Class<T> componentType)

    • remove

      @Contract(pure=true) public static <T> T @NotNull [] remove(T @NotNull [] src, int idx)
      Removes element with index idx from array src.
      参数:
      src - array.
      idx - index of element to be removed.
      返回:
      modified array.

    • newArray

      public static <T> T @NotNull [] newArray(@NotNull @NotNull Class<T> type, int length)

    • remove

      @Contract(pure=true) public static <T> T @NotNull [] remove(T @NotNull [] src, int idx, @NotNull @NotNull ArrayFactory<? extends T> factory)

    • remove

      @Contract(pure=true) public static <T> T @NotNull [] remove(T @NotNull [] src, T element)

    • remove

      @Contract(pure=true) public static <T> T @NotNull [] remove(T @NotNull [] src, T element, @NotNull @NotNull ArrayFactory<? extends T> factory)

    • remove

      @Contract(pure=true) public static int @NotNull [] remove(int @NotNull [] src, int idx)

    • remove

      @Contract(pure=true) public static short @NotNull [] remove(short @NotNull [] src, int idx)

    • find

      @Contract(pure=true) public static int find(int @NotNull [] src, int obj)

    • find

      @Contract(pure=true) public static <T> int find(T @NotNull [] src, T obj)

    • startsWith

      @Contract(pure=true) public static boolean startsWith(byte @NotNull [] array, byte @NotNull [] prefix)

    • startsWith

      @Contract(pure=true) public static <E> boolean startsWith(E @NotNull [] array, E @NotNull [] subArray)

    • startsWith

      @Contract(pure=true) public static boolean startsWith(byte @NotNull [] array, int start, byte @NotNull [] subArray)

    • equals

      @ScheduledForRemoval @Deprecated public static <T> boolean equals(T @NotNull [] a1, T @NotNull [] a2, @NotNull @NotNull Comparator<? super T> comparator)
      已过时。
      Use Arrays.equals(Object[], Object[], Comparator)

    • reverseArray

      @Contract(pure=true) public static <T> T @NotNull [] reverseArray(T @NotNull [] array)

    • reverseArray

      @Contract(pure=true) public static int @NotNull [] reverseArray(int @NotNull [] array)

    • lexicographicCompare

      @Contract(pure=true) public static int lexicographicCompare(String @NotNull [] obj1, String @NotNull [] obj2)

    • lexicographicCompare

      @Contract(pure=true) public static int lexicographicCompare(int @NotNull [] obj1, int @NotNull [] obj2)

    • lexicographicCompare

      @Contract(pure=true) public static <T extends Comparable<T>> int lexicographicCompare(T @NotNull [] obj1, T @NotNull [] obj2)

    • swap

      public static <T> void swap(T @NotNull [] array, int i1, int i2)

    • swap

      public static void swap(int @NotNull [] array, int i1, int i2)

    • swap

      public static void swap(boolean @NotNull [] array, int i1, int i2)

    • swap

      public static void swap(char @NotNull [] array, int i1, int i2)

    • rotateLeft

      public static <T> void rotateLeft(T @NotNull [] array, int i1, int i2)

    • rotateRight

      public static <T> void rotateRight(T @NotNull [] array, int i1, int i2)

    • indexOf

      @Contract(pure=true) public static int indexOf(Object @NotNull [] objects, @Nullable @Nullable Object object)

    • indexOf

      @Contract(pure=true) public static <T> int indexOf(@NotNull @NotNull List<? extends T> objects, T object, @NotNull @NotNull BiPredicate<? super T,? super T> predicate)

    • indexOf

      @Contract(pure=true) public static <T> int indexOf(T @NotNull [] objects, T object, @NotNull @NotNull BiPredicate<? super T,? super T> comparator)

    • indexOf

      @Contract(pure=true) public static int indexOf(long @NotNull [] ints, long value)

    • indexOf

      @Contract(pure=true) public static int indexOf(int @NotNull [] ints, int value)

    • indexOf

      @Contract(pure=true) public static int indexOf(byte @NotNull [] array, byte @NotNull [] pattern, int startIndex)

    • lastIndexOf

      @Contract(pure=true) public static <T> int lastIndexOf(T @NotNull [] src, @Nullable T obj)

    • lastIndexOf

      @Contract(pure=true) public static int lastIndexOf(int @NotNull [] src, int obj)

    • lastIndexOfNot

      @Contract(pure=true) public static int lastIndexOfNot(int @NotNull [] src, int obj)

    • lastIndexOf

      @Contract(pure=true) public static <T> int lastIndexOf(T @NotNull [] src, T obj, @NotNull @NotNull BiPredicate<? super T,? super T> predicate)

    • lastIndexOf

      @Contract(pure=true) public static <T> int lastIndexOf(@NotNull @NotNull List<? extends T> src, T obj, @NotNull @NotNull BiPredicate<? super T,? super T> comparator)

    • contains

      @SafeVarargs @Contract(pure=true) public static <T> boolean contains(@Nullable T o, T @NotNull ... objects)

    • contains

      @Contract(pure=true) public static boolean contains(@Nullable @Nullable String s, String @NotNull ... strings)

    • newIntArray

      @Contract(pure=true) public static int @NotNull [] newIntArray(int count)

    • newByteArray

      @Contract(pure=true) public static byte @NotNull [] newByteArray(int count)

    • newLongArray

      @Contract(pure=true) public static long @NotNull [] newLongArray(int count)

    • newStringArray

      @Contract(pure=true) public static String @NotNull [] newStringArray(int count)

    • newObjectArray

      @Contract(pure=true) public static Object @NotNull [] newObjectArray(int count)

    • ensureExactSize

      @Contract(pure=true) public static <E> E @NotNull [] ensureExactSize(int count, E @NotNull [] sample)

    • getFirstElement

      @Contract(value="null -> null", pure=true) @Nullable public static <T> T getFirstElement(T @Nullable [] array)

    • getLastElement

      @Contract(value="null -> null", pure=true) public static <T> T getLastElement(T @Nullable [] array)

    • getLastElement

      @Contract(pure=true) public static int getLastElement(int @Nullable [] array, int defaultValue)

    • isEmpty

      @Contract(value="null -> true", pure=true) public static <T> boolean isEmpty(T @Nullable [] array)

    • toStringArray

      @Contract(pure=true) public static String @NotNull [] toStringArray(@Nullable @Nullable Collection<String> collection)

    • copy

      public static <T> void copy(@NotNull @NotNull Collection<? extends T> src, T @NotNull [] dst, int dstOffset)

    • copyOf

      @Contract(value="null -> null; !null -> !null", pure=true) public static <T> T @Nullable [] copyOf(T @Nullable [] original)

    • copyOf

      @Contract(value="null -> null; !null -> !null", pure=true) public static boolean @Nullable [] copyOf(boolean @Nullable [] original)

    • copyOf

      @Contract(value="null -> null; !null -> !null", pure=true) public static int @Nullable [] copyOf(int @Nullable [] original)

    • copyOf

      @Contract(value="null -> null; !null -> !null", pure=true) public static byte @Nullable [] copyOf(byte @Nullable [] original)

    • stripTrailingNulls

      @Contract(pure=true) public static <T> T @NotNull [] stripTrailingNulls(T @NotNull [] array)

    • averageAmongMedians

      public static long averageAmongMedians(long @NotNull [] time, int part)

    • averageAmongMedians

      public static long averageAmongMedians(int @NotNull [] time, int part)

    • min

      @Contract(pure=true) public static int min(int @NotNull [] values)

    • max

      @Contract(pure=true) public static int max(int @NotNull [] values)

    • max

      @Contract(pure=true) public static double max(double @NotNull [] values)

    • mergeSortedArrays

      @Contract(pure=true) public static int[] mergeSortedArrays(int @NotNull [] a1, int @NotNull [] a2, boolean mergeEqualItems)

    • getComponentType

      @NotNull public static <T> @NotNull Class<T> getComponentType(T @NotNull [] collection)

    • indexOfIdentity

      @Contract(pure=true) public static <T> int indexOfIdentity(T @NotNull [] array, T element)