Tablice. Przedłużanie, skracanie i łączenie

Tablice można z powodzeniem przedłużać, skracać i łączyć.
A oto klasy z przykładami

Klasa ArrayUtil
package arrays;
import java.util.Arrays;
public class ArrayUtil {
    static final String[] IMIONA = {"Aria", "Bemol", "Gawot", "Menuet", "Misio", "Nutka", "Ochłapek",
            "Pauza", "Skirli", "Suita"};
    private ArrayUtil() {
    }
    /**
     * Przedłuża tablicę o 1 element - dodaje element na końcu
     * @param tabl - tablica do przedłużenia
     * @param <T>  - dowolny typ
     * @return nową tablicę z tymi samymi elementami przedlużoną o 1 element
     */
    public static <T> T[] extendArray(T[] tabl) {
        int len = tabl.length;
        return Arrays.copyOf(tabl, len + 1);
    }
    /**
     * Przedłuża tablicę o wskazaną liczbę elementów - dodaje elementy na końcu
     *
     * @param tabl - tablica do przedłużenia
     * @param oIle - liczba dodanych elementów
     * @param <T>  - dowolny typ
     * @return -nową tablicę z tymi samymi elementami, przedłużoną o oIle elementów
     */
    public static <T> T[] extendArray(T[] tabl, int oIle) {
        int len = tabl.length;
        return Arrays.copyOf(tabl, len + oIle);
    }
    /**
     * Dodaje podaną wartość do tablicy pod wskazanym indeksem, przedłużając odpowiednio tablicę
     *
     * @param tabl          - tablica wyjściowa
     * @param indexInserted - indeks pod którym będzie wstawiony nowy element
     * @param value - wartość do wstawienia
     * @param <T> - typ tablicy
     * @return - nową przedłużoną tablicę z dodanym elementem
     */
    public static <T> T[] extendArray(T[] tabl, int indexInserted, T value) {
        int len = tabl.length;
        int lenNew;
        T[] tablNew;
        // sprawdza czy index miesci sie w tablicy
        if ((indexInserted > len) || (indexInserted < 0)) {
            throw new IndexOutOfBoundsException("index poza tablicą");
        } else {// jesli tak
            // przedluza tablice
            tablNew = extendArray(tabl);
            lenNew = tablNew.length;
            // to przepisuje rekordy za indeksem o 1 w prawo
            // zaczynajac od tylu
            for (int i = lenNew - 1; i > indexInserted; i--) {
                tablNew[i] = tablNew[i - 1];
            }
            //ręczne kopiowanie w pętli for można zastąpić poniższą konstrukcją
           // if (lenNew - 1 - indexInserted >= 0) {
            //    System.arraycopy(tablNew, indexInserted, tablNew, indexInserted + 1, lenNew - 1 - indexInserted);
           // }
            tablNew[indexInserted] = value;
        }
        return tablNew;
    }
    /**
     * Skraca tablicę usuwając jeden element o podanym indeksie
     *
     * @param tabl         - tablica do skrócenia
     * @param indexDeleted - indeks elementu do wyrzucenia
     * @param <T>          - typ obiektu
     * @return - zwraca nową tablicę bez podanego elementu.
     */
    public static <T> T[] shortenArray(T[] tabl, int indexDeleted) {
        int len = tabl.length;
        // sprawdza czy index miesci sie w tablicy
        if ((indexDeleted > len - 1) || (indexDeleted < 0)) {
            throw new IndexOutOfBoundsException("index poza tablicı");
        } else {// jesli tak
            // to przepisuje rekordy za indeksem o 1 w lewo
            for (int i = indexDeleted; i < tabl.length - 1; i++) {
                tabl[i] = tabl[i + 1];
            }
            // ręczne kopiowanie w pętli for można zastąpić poniższą konstrukcją
          //  if (tabl.length - 1 - indexDeleted >= 0) {
             //   System.arraycopy(tabl, indexDeleted + 1, tabl, indexDeleted, tabl.length - 1 - indexDeleted);
           // }
        }
        // a nastepnie skraca tablice o 1
        return Arrays.copyOf(tabl, len - 1);
    }
    /**
     * Skraca tablicę usuwając elementy w podanym zakresie
     *
     * @param tabl   - tablica do skrócenia
     * @param index1 - początek zakresu usuwania
     * @param index2 - koniec zakresu usuwania
     * @param <T>    - typ obiektu
     * @return - nowa, skrócona tablica
     */
    public static <T> T[] shortenArray(T[] tabl, int index1, int index2) {
        int len = tabl.length;
        int lenAdd = index2 - index1;
        if (index1 > index2) {
            throw new IllegalArgumentException(
                    "index1 nie może byĉ wiêkszy od index2");
        }
        // sprawdza czy indeksy mieszcza sie w tablicy
        if ((index2 > len - 1) || (index1 < 0)) {
            throw new IndexOutOfBoundsException("indeks poza tablicı");
        } else {// jesli tak
            // to przepisuje rekordy za indeksem o 1 w lewo
            for (int i = index1; i < tabl.length - lenAdd - 1; i++) {
                tabl[i] = tabl[i + lenAdd + 1];
            }
        }
        // a nastepnie skraca tablice o niezbedna dlugosc
        return Arrays.copyOf(tabl, len - lenAdd - 1);
    }
    /**
     * Łączy dwie tablice
     * @param tabl1 - tablica
     * @param tabl2 - tablica do dołączenia
     * @param <T> - typ tablicy
     * @return - nową tablicę zawierającą elementy obu tablic
     */
    public static <T>T[] concat(T[] tabl1, T[] tabl2) {
        int len1 = tabl1.length;
        int len2 = tabl2.length;
        T[] tablNew = Arrays.copyOf(tabl1, len1 + len2);
        for (int i = 0; i < len2; i++) {
            tablNew[i + len1] = tabl2[i];
        }
        //ręczne kopiowanie w pętli for można zastąpić poniższą konstrukcją
        //System.arraycopy(tabl2, 0, tablNew, 0 + len1, len2);
        return tablNew;
    }
    public static <T> void print(T[] array) {
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                System.out.print(array[i]);
            } else {
                System.out.print(array[i] + ", ");
            }
        }
        System.out.print("]");
        System.out.println();
    }
}
Klasa MainArray
package arrays;
public class MainArrays {
    public static void main(String[] args){
        String[] tabl = ArrayUtil.extendArray(ArrayUtil.IMIONA);
        ArrayUtil.print(tabl);
        //-
        String[] tabl1 = ArrayUtil.extendArray(ArrayUtil.IMIONA, 3);
        ArrayUtil.print(tabl1);
        //-
        String[] tabl2 = ArrayUtil.extendArray(ArrayUtil.IMIONA, 3, null);
        ArrayUtil.print(tabl2);
        //-
        String[] tabl3 = ArrayUtil.shortenArray(tabl2, 3);
        ArrayUtil.print(tabl3);
        //-
        String[] tabl4 = ArrayUtil.shortenArray(ArrayUtil.IMIONA, 2,5);
        ArrayUtil.print(tabl4);
        String[] imiona1 = {"Aria", "Bemol", "Gawot", "Menuet"};
        String[] imiona2 = {"Misio", "Nutka", "Ochłapek", "Pauza", "Skirli", "Suita"};
        String[] imionac= ArrayUtil.concat(imiona1, imiona2);
        ArrayUtil.print(imionac);
    }
}

Wyniki

Po uruchomieniu otrzymujemy

[Aria, Bemol, Gawot, Menuet, Misio, Nutka, Ochłapek, Pauza, Skirli, Suita, null]
[Aria, Bemol, Gawot, Menuet, Misio, Nutka, Ochłapek, Pauza, Skirli, Suita, null, null, null]
[Aria, Bemol, Gawot, null, Menuet, Misio, Nutka, Ochłapek, Pauza, Skirli, Suita]
[Aria, Bemol, Gawot, Menuet, Misio, Nutka, Ochłapek, Pauza, Skirli, Suita]
[Aria, Bemol, Ochłapek, Pauza, Skirli, Suita]
[Aria, Bemol, Gawot, Menuet, Misio, Nutka, Ochłapek, Pauza, Skirli, Suita]

Uwagi

Podane metody można łatwo rozszerzyć na metody przyjmujące jako parametr tablice lu elementy typów prymitywnych.
Równie łatwo można przekształcić kod tak, aby elementy dodawać zbiorowo np. wstawiając np. tablicę elementów.
W moich metodach elementy do nowych tablic kopiowałam ręcznie. W trzech przypadkach, gdzie możliwe było zastosowanie lepszego sposobu System.arraycopy podałam sposób zastosowania jako komentarz.
Należy pamiętać, że w przypadku niektórych obiektów, przy kopiowaniu obiektu do tablicy, może być wymagane kopiowanie głębokie.

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *