Jak dodwać po jednym elemcie do pełnej juz tablicy zwiekszając ją ?

Jak dodwać po jednym elemcie do pełnej juz tablicy zwiekszając ją ?

Użyć java.util.List.

https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html

Nie da się zwiększyć ani zmniejszyć raz zadeklarowanej tablicy. Zamiast tablic użyj np. klasy ArrayList.

https://commons.apache.org/proper/commons-lang/javadocs/api-3.9/org/apache/commons/lang3/ArrayUtils.html#add-T:A-T-

https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#copyOf(T[],%20int)

Uwaga: może być za wolne jeśli zmieniasz rozmiar wielokrotnie, po jednym elemencie. W takim wypadku lepiej użyć ArrayList.

Albo Listy/Array z Vavra :P

Możesz w metodzie która dodaje element do tablicy stworzyć nową tablicę o n+1 rozmiarze ze zbiorem danych poprzedniej tablicy, dodać element i zwrócić taką tablicę, wówczas przypisujesz do zmiennej nową referencje z nową tablicą o zwiększonym rozmiarze
To by mogło wyglądać np. w ten sposób:

public class Test {
    public static void main(String[] args) {
        int[] myArray = new int[2];
        myArray[0] = 6;
        myArray[1] = 9;
        Helper helper = new Helper(myArray);
        myArray = helper.add(3);
        myArray = helper.add(2);
        Arrays.stream(myArray).forEach(System.out::println);
    }
}

class Helper{
    private  int[] myArray;

    public Helper(int[] myArray) {
        this.myArray = myArray;
    }

    public int[] add(int e){
        int[] myArray = new int[this.myArray.length+1];
        int index = 0;
        for(int ar: this.myArray){
            myArray[index++] = ar;
        }
        myArray[myArray.length - 1] = e;
        this.myArray = myArray;
        return myArray;
    }
}

Pytanie tylko czy sensowne :)

@Orenz12:
Podobnie działa CopyOnWriteArrayList :P

 public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
       }
 }

No i oczywiście niemutowalne kolekcje funkcyjne (te oparte o tablice), przy czym one nie pozwalają na modyfikację elementów starej tablicy :)

   @Override
    public Array<T> append(T element) {
        final Object[] copy = copyOf(delegate, delegate.length + 1);
        copy[delegate.length] = element;
        return wrap(copy);
    }