/** * Returns a singleton {@code Array}, i.e. a {@code Array} of one element. * * @param element An element. * @param <T> The component type * @return A new Array instance containing the given element */ public static <T> Array<T> of(T element) { return wrap(new Object[] { element }); }
@Override public Array<T> intersperse(T element) { if (delegate.length <= 1) { return this; } else { final Object[] arr = new Object[delegate.length * 2 - 1]; for (int i = 0; i < delegate.length; i++) { arr[i * 2] = delegate[i]; if (i > 0) { arr[i * 2 - 1] = element; } } return wrap(arr); } }
@Override public Array<T> append(T element) { final Object[] copy = copyOf(delegate, delegate.length + 1); copy[delegate.length] = element; return wrap(copy); }
@Override public Array<T> sorted() { final Object[] arr = copyOf(delegate, delegate.length); sort(arr); return wrap(arr); }
/** * Creates an Array that contains the elements of the given {@link java.util.stream.Stream}. * * @param javaStream A {@link java.util.stream.Stream} * @param <T> Component type of the Stream. * @return An Array containing the given elements in the same order. */ public static <T> Array<T> ofAll(java.util.stream.Stream<? extends T> javaStream) { Objects.requireNonNull(javaStream, "javaStream is null"); return wrap(javaStream.toArray()); }
@SuppressWarnings("unchecked") @Override public Array<T> sorted(Comparator<? super T> comparator) { final Object[] arr = copyOf(delegate, delegate.length); sort(arr, (o1, o2) -> comparator.compare((T) o1, (T) o2)); return wrap(arr); }
/** * Creates an Array of the given elements. * * @param <T> Component type of the Array. * @param elements Zero or more elements. * @return An Array containing the given elements in the same order. * @throws NullPointerException if {@code elements} is null */ @SuppressWarnings("varargs") @SafeVarargs public static <T> Array<T> of(T... elements) { Objects.requireNonNull(elements, "elements is null"); return wrap(copyOf(elements, elements.length)); }
@Override public Array<T> reverse() { if (size() <= 1) { return this; } else { final int length = delegate.length; final Object[] arr = new Object[length]; for (int i = 0, j = length - 1; i < length; i++, j--) { arr[j] = delegate[i]; } return wrap(arr); } }
@Override public Array<T> tail() { if (isEmpty()) { throw new UnsupportedOperationException("tail() on empty Array"); } else { final Object[] arr = new Object[delegate.length - 1]; System.arraycopy(delegate, 1, arr, 0, arr.length); return wrap(arr); } }
@Override public Array<T> update(int index, T element) { if ((index < 0) || (index >= length())) { throw new IndexOutOfBoundsException("update(" + index + ")"); } else { final Object[] arr = copyOf(delegate, delegate.length); arr[index] = element; return wrap(arr); } }
@Override public Array<T> insert(int index, T element) { if (index < 0 || index > length()) { throw new IndexOutOfBoundsException("insert(" + index + ", e) on Array of length " + length()); } final Object[] arr = new Object[delegate.length + 1]; System.arraycopy(delegate, 0, arr, 0, index); arr[index] = element; System.arraycopy(delegate, index, arr, index + 1, delegate.length - index); return wrap(arr); }
@Override public <U> Array<U> map(Function<? super T, ? extends U> mapper) { Objects.requireNonNull(mapper, "mapper is null"); final Object[] arr = new Object[length()]; for (int i = 0; i < delegate.length; i++) { arr[i] = mapper.apply(get(i)); } return wrap(arr); }
@Override public Array<T> removeAt(int index) { if (index < 0) { throw new IndexOutOfBoundsException("removeAt(" + index + ")"); } else if (index >= length()) { throw new IndexOutOfBoundsException("removeAt(" + index + ")"); } else { final Object[] arr = new Object[length() - 1]; System.arraycopy(delegate, 0, arr, 0, index); System.arraycopy(delegate, index + 1, arr, index, length() - index - 1); return wrap(arr); } }
@Override public Array<T> drop(int n) { if (n <= 0) { return this; } else if (n >= length()) { return empty(); } else { final Object[] arr = new Object[delegate.length - n]; System.arraycopy(delegate, n, arr, 0, arr.length); return wrap(arr); } }
@Override public Array<T> dropRight(int n) { if (n <= 0) { return this; } else if (n >= length()) { return empty(); } else { return wrap(copyOf(delegate, delegate.length - n)); } }
@SuppressWarnings("varargs") @SafeVarargs public final BitSet<T> of(T... values) { return empty().addAll(Array.wrap(values)); }
@Override public Array<T> take(int n) { if (n >= length()) { return this; } else if (n <= 0) { return empty(); } else { return wrap(copyOf(delegate, n)); } }
@Override public Array<T> takeRight(int n) { if (n >= length()) { return this; } else if (n <= 0) { return empty(); } else { final Object[] arr = new Object[n]; System.arraycopy(delegate, delegate.length - n, arr, 0, n); return wrap(arr); } }
@Override public Array<T> slice(int beginIndex, int endIndex) { if (beginIndex >= endIndex || beginIndex >= length() || isEmpty()) { return empty(); } if (beginIndex <= 0 && endIndex >= length()) { return this; } final int index = Math.max(beginIndex, 0); final int length = Math.min(endIndex, length()) - index; final Object[] arr = new Object[length]; System.arraycopy(delegate, index, arr, 0, length); return wrap(arr); }
@Override public Array<T> subSequence(int beginIndex, int endIndex) { Collections.subSequenceRangeCheck(beginIndex, endIndex, length()); if (beginIndex == endIndex) { return empty(); } else if (beginIndex == 0 && endIndex == length()) { return this; } else { final Object[] arr = new Object[endIndex - beginIndex]; System.arraycopy(delegate, beginIndex, arr, 0, arr.length); return wrap(arr); } }