Tablice jedno i wielowymiarowe.

Tablice, czyli konstrukcje o jednorodnej strukturze. W nich możemy zapisać wiele elementów takich samych typów. Zrozumienie tych struktur jak są skonstruowane pozwoli na bezbłędne ich później używanie.

Tablice jednowymiarowe

Deklaracja tablicy zawiera w sobie informację o rodzaju (typie) przechowywanych w niej elementów, oraz o ilości tych elementów. Na tej podstawie rezerwowana jest pamięć, w której przechowywana jest ta struktura. Tak więc deklaracje tablic mogą przyjąć poniższy wygląd:

        String imiona[]={"Alicja", "Tomasz", "Wojtek", "Ewa", "Zofia"};
        String wyjazdy[]=new String[100];
        
        int tab1[]={1,2,3,4,5,6,7,8,9,10};
        int tab2[]=new int[100];
        
        boolean tab[]=new boolean[6];

        char znaki[]={'a','b','c','d','e','f','g','h','i'};

Deklaracja może być jednoczesna z inicjalizacją wartościami, może też opierać się tylko na samym podaniu ilości ilości elementów, a ich inicjalizacja wartościami nastąpi w głębi programu.

To co należy zapamiętać, to fakt że:

• indeksy wskazujące na konkretne miejsce w tablicy rozpoczynają się od 0, co znaczy, że pierwszy element tablicy ma indeks równy 0, drugi równy 1 itd.
• odwoływanie się do konkretnego elementu tablicy odbywa się poprzez podanie indeksu tego miejsca czyli np.: tab[4] to piąty element tablicy tab.
• powyższe informacje są istotne, bo gdy przekroczymy indeks ponad faktyczną ilość elementów w tablicy zostanie wygenerowany wyjątek ArrayIndexOutOfBoundsException, a program zakończy działanie.
• ilość elementów tablicy możemy sprawdzić za pomocą wartości length należącej do cechy tablicy. Tak więc aby sprawdzić ile elementów ma wspomniana tablica tab wystarczy odwołać się do liczby tab.length.

Typ tablicowy posiada również klasę zawierającą przydatne metody przetwarzania tablic. Jest to klasa Arrays.

Wadą tablic są statyczne ich rozmiary, zdefiniowane na sztywno w programie. Takich wad nie mają listy, których omówienie nastąpi w części „obiektowej”.

Tablice wielowymiarowe

Tablice wielowymiarowe nie są bynajmniej macierzą, jak czasem są przedstawiane. Tablice wielowymiarowe w języku Java to raczej jednowymiarowe tablice tablic, a ich deklaracja może przyjąć poniższy wygląd:

       String czlowiek[][]={{"Alicja","Maciąg"},{"Tomasz","Wojtaszek"},{"Wojtek","Onufry"}, {"Ewa", "Małecka"}, {"Zofia","Eleonora","Kosoń"}};

Deklaracja i inicjalizacja (częściowa) tablicy wielowymiarowej o nierównomiernej strukturze przedstawiona jest poniżej.

public class TabliceWielowymiarowe {



    public static void main(String[] args) {
        char Z[][][]=new char[3][][];
        
        char Z0[][]=new char [4][];
        char Z1[][]=new char [2][];
        char Z2[][]=new char [3][];
        
        Z[0]=Z0;
        Z[1]=Z1;
        Z[2]=Z2;
        
        char Z00 [] = new char [4];
        Z00[0]='E';
        Z00[1]='l';
        Z00[2]='a';
        Z00[3]=' ';
        char Z01 [] = {'b','a','r','d','z','o',' '};
        char Z02 [] = {'l','u','b','i',' '};
        char Z03 [] = {'T','o','m','k','a','.',' '};
        
        Z[0][0]=Z00;
        Z[0][1]=Z01;
        Z[0][2]=Z02;
        Z[0][3]=Z03;
        
        //Ela bardzo lubi Tomka. Jest jak jest! Bo gdy jest, to jest!
        System.out.print(Z[0][0]);System.out.print(Z[0][1]);System.out.print(Z[0][2]);System.out.println(Z[0][3]);
            
    }
    
}

Zapisanie kodu w sposób jednorodny (estetyczny, nie dydaktyczny) jest przedstawione poniżej (przykład został przygotowany przez jednego z Waszych kolegów) .

public class TabliceWielowymiarowe {
    public static void main(String[] args){

        char Z[][][] = new char[3][][];
        
        Z[0] = new char[4][];
        Z[1] = new char[3][];
        Z[2] = new char[2][];
        
        Z[0][0] = new char[4];
        Z[0][1] = new char[7];
        Z[0][2] = new char[5];
        Z[0][3] = new char[7];
        
        Z[0][0][0] = 'E';
        Z[0][0][1] = 'l';
        Z[0][0][2] = 'a';
        Z[0][0][3] = ' ';
        
        Z[0][1][0] = 'b';
        Z[0][1][1] = 'a';
        Z[0][1][2] = 'r';
        Z[0][1][3] = 'd';
        Z[0][1][4] = 'z';
        Z[0][1][5] = 'o';
        Z[0][1][6] = ' ';
        
        Z[0][2][0] = 'l';
        Z[0][2][1] = 'u';
        Z[0][2][2] = 'b';
        Z[0][2][3] = 'i';
        Z[0][2][4] = ' ';
        
        Z[0][3][0] = 'T';
        Z[0][3][1] = 'o';
        Z[0][3][2] = 'm';
        Z[0][3][3] = 'k';
        Z[0][3][4] = 'a';
        Z[0][3][5] = '.';
        Z[0][3][6] = ' ';
        
        System.out.print(Z[0][0]);
        System.out.print(Z[0][1]);
        System.out.print(Z[0][2]);
        System.out.println(Z[0][3]);
        
        Z[1][0] = new char[4];
        Z[1][1] = new char[3];
        Z[1][2] = new char[6];
        
        Z[1][0][0] = 'A';
        Z[1][0][1] = 'l';
        Z[1][0][2] = 'a';
        Z[1][0][3] = ' ';
        
        Z[1][1][0] = 'm';
        Z[1][1][1] = 'a';
        Z[1][1][2] = ' ';
        
        Z[1][2][0] = 'k';
        Z[1][2][1] = 'o';
        Z[1][2][2] = 't';
        Z[1][2][3] = 'a';
        Z[1][2][4] = '.';
        Z[1][2][5] = ' ';
        
        System.out.print(Z[1][0]);
        System.out.print(Z[1][1]);
        System.out.println(Z[1][2]);
        
        Z[2][0] = new char[4];
        Z[2][1] = new char[9];
        
        Z[2][0][0] = 'T';
        Z[2][0][1] = 'a';
        Z[2][0][2] = 'k';
        Z[2][0][3] = ' ';
        
        Z[2][1][0] = 'w';
        Z[2][1][1] = 'ł';
        Z[2][1][2] = 'a';
        Z[2][1][3] = 'ś';
        Z[2][1][4] = 'n';
        Z[2][1][5] = 'i';
        Z[2][1][6] = 'e';
        Z[2][1][7] = '.';
        Z[2][1][8] = ' ';
        
        System.out.print(Z[2][0]);
        System.out.println(Z[2][1]);
    }
    
}