com.jongsoft.lang.collection.Array Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of collections Show documentation
The newest version!
package com.jongsoft.lang.collection;

import java.util.*;
import java.util.function.*;
import java.util.stream.Collector;

import static java.lang.String.format;
import static java.util.Arrays.copyOf;

public class Array implements List {

    private static final Array EMPTY = new Array<>(new Object[0]);

    private final T[] delegate;

    private Array(T[] delegate) {
        this.delegate = delegate;
    }

    @Override
    public int size() {
        return delegate.length;
    }

    @Override
    public T get(int index) throws IndexOutOfBoundsException {
        validateOutOfBounds(index);
        return delegate[index];
    }

    @Override
    public Iterator iterator() {
        return Collections.unmodifiableList(Arrays.asList(delegate)).iterator();
    }

    @Override
    public List filter(Predicate predicate) {
        return stream()
                .filter(predicate)
                .collect(collector());
    }

    @Override
    public List insert(int index, T value) {
        T[] newDelegate = (T[]) new Object[delegate.length + 1];
        System.arraycopy(delegate, 0, newDelegate, 0, index);
        newDelegate[index] = value;
        System.arraycopy(delegate, index, newDelegate, index + 1, delegate.length - index);
        return create(newDelegate);
    }

    @Override
    public int indexOf(Object lookFor) {
        for (int i = 0; i < size(); i++) {
            if (Objects.equals(delegate[i], lookFor)) {
                return i;
            }
        }

        return -1;
    }

    @Override
    public List remove(int index) {
        validateOutOfBounds(index);
        T[] newDelegate = (T[]) new Object[delegate.length - 1];

        System.arraycopy(delegate, 0, newDelegate, 0, index);
        System.arraycopy(delegate, index  + 1, newDelegate, index, delegate.length - index - 1);

        return create(newDelegate);
    }

    public static  Collector, Array> collector() {
        final BinaryOperator> combiner = (left, right) -> {
            left.addAll(right);
            return left;
        };

        return Collector.of(ArrayList::new, ArrayList::add, combiner, Array::ofAll);
    }

    private void validateOutOfBounds(int index) {
        if (index >= delegate.length || index < 0) {
            throw new IndexOutOfBoundsException(format("%s is not in the bounds of 0 and %s", index, delegate.length));
        }
    }

    //------------------------------------------------------------------
    //-- Static supporting methods

    private static  Array create(T[] array) {
        return array.length == 0
                ? (Array) EMPTY
                : new Array<>(array);
    }

    public static  Array empty() {
        return (Array) EMPTY;
    }

    public static  Array of(T element) {
        return create((T[]) new Object[]{element});
    }

    /**
     * Creates a new {@link Array} with the provided elements as the contents.
     *
     * @param elements  the elements to add to the array
     * @param        the type that the elements represent
     * @return          the new array list
     *
     * @throws NullPointerException in case the passed elements is null
     */
    public static  Array of(T...elements) {
        Objects.requireNonNull(elements, "The provided elements cannot be null");
        return create(copyOf(elements, elements.length));
    }

    public static  Array ofAll(Iterable elements) {
        return elements instanceof Array
                ? (Array) elements
                : create(toArray(elements));
    }

    private static  T[] toArray(Iterable elements) {
        if (elements instanceof java.util.List) {
            final java.util.List list = (java.util.List) elements;
            return (T[]) list.toArray();
        } else {
            final java.util.Iterator it = elements.iterator();
            final java.util.List list = new java.util.ArrayList<>();
            while (it.hasNext()) {
                list.add(it.next());
            }
            return (T[]) list.toArray();
        }
    }
}