java mapy pytanie

Witam, mam pytanie - przerabiam kolejny "obszar" javy - kontenery i trafilem na ponizszy kod:

public class AssociativeArray<K,V> { 
	private Object[][] pairs; 
	private int index; 
	public AssociativeArray(int length) { 
		pairs = new Object[length][2]; 
} 
public void put(K key, V value) { 
	if(index >= pairs.length) 
		throw new ArrayIndexOutOfBoundsException(); 
	pairs[index++] = new Object[]{ key, value }; 
} 
@SuppressWarnings("unchecked") 
public V get(K key) { 
	for(int i = 0; i < index; i++) 
		if(key.equals(pairs[i][0])) 
			return (V)pairs[i][1]; 
	return null; // Did not find key 
} 
public String toString() { 
	StringBuilder result = new StringBuilder(); 
	for(int i = 0; i < index; i++) { 
		result.append(pairs[i][0].toString()); 
		result.append(" : "); 
		result.append(pairs[i][1].toString()); 
		if(i < index - 1) 
			result.append("\n"); 
	} 
	return result.toString(); 
} 

public static void main(String[] args) { 
	AssociativeArray<String,String> map = new AssociativeArray<String,String>(6); 
	map.put("sky", "blue"); 
	map.put("grass", "green"); 
	map.put("ocean", "dancing"); 
	map.put("tree", "tall"); 
	map.put("earth", "brown"); 
	map.put("sun", "warm"); 
	try { 
		map.put("extra", "object");
	} catch(ArrayIndexOutOfBoundsException e) { 
		print("Too many objects!"); 
		} 
	print(map); 
	print(map.get("ocean")); 
	} 
}

Czy ktos moglby mi pomoc troche polapac sie w tym?
Nie jest dla mnie jasne jak dziala metoda put, linia pairs[index++] = new Object[]{ key, value };. Pobieramy 2 argumenty typu K i V, sprawdzamy dlugosc, ale potem co robimy? Wstawiamy do dwuwymiarowej tablicy typu Object o nazwie pairs, na pozycji index++ nowa tablice typu Object, zainicjowana argumentami metody? Jak to dziala?
Metoda get jest bardziej zrozumiala, ale nie moge powiedziec, ze jestem na 100% pewien, ze rozumiem.
Moglby ktos napisac po kolei co sie dzieje, np krok po kroku?

mniej więcej. Do tablicy pairs na pozycji index++ wstawiasz obiekt będący dwuelementową tablicą typu Object gdzie pierwszym elementem jest klucz, a drugim wartość.

Hej, dzieki za odpowiedz, moglbys to sprecyzowac? Przeciez tablica pairs ma 2 wymiary, wiec skoro do jednego wstawiamy cos, to co sie dzieje z drugim? Jest zerowy? Taki sam jak pierwszy?

Po drugie, dwuelementowa tablica typu Obiekt jest trzymana w jednym "wymiarze" tablic pairs? Mamy wtedy 3-wymiarowa tablice?

pairs to tablica dwuwymiarowa lub konkretniej tablica tablic
pairs[index] to tablica jednowymiarowa
pairs[index1][index2] to pojedynczy element

Cały trik jest właśnie w tym "tablica tablic". Tablica więcej niż jednowymiarowa to tak naprawdę tablica wskaźników na tablice niżej-wymiarowe.

pairs = new Object[length][2] - to taka tablica tablic dwuelementowych

pairs[index] = new Object[]{ key, value }; to przypisanie do pierwszego wymiaru tablicy dwuelementowej

pairs[index] - odniesienie do tablicy dwuelementowej
pairs[index][0/1] - odniesienie do konkretnego elementu tablicy dwuelementowej

Mam nadzieję, że teraz troszkę jaśniej

Dwuwymiarowość tablicy, w ogólności wielowymiarowość, to pojęcie umowne. Jeżeli mówimy o tablicy dwuwymiarowej to mamy na myśli tablicę tablic. Tablica trójwymiarowa to tablica tablic tablic itp.

Zapis typu tablica[a][b] można też przeczytać jako

tablicaA = tablica[a];
elementB = tablcaA[b];

ten pierwszy jest zdecydowanie prostszy. Przy czym jeżeli zadeklarowałbyś zmienną tablica jako jednowymiarową to jej elementy nie będą automatycznie traktowane jako tablice. Zresztą taki przykładzik:

public class Main{
    
    public static void main(String[] args) {
 
        Object[] t = new Object[2];
        Object[] a = new Object[]{"test"};
        t[0]= a;
        System.out.println(((Object[])(t[0]))[0]);
//        System.out.println(t[0][0]); // nie skompiluje się ponieważ elementy w t są traktowane jako Object, a nie Object[]
        
        Object[][] d = new Object[2][];
        d[0] = a;
        System.out.println(d[0]);
        System.out.println(d[0][0]);
    }
}

@Swr: wlasnie to mnie meczy - skoro pairs = new Object[length][2] jest deklaracja tablicy dwuwymiarowej, to taka nazwa zostaje jakby "zarezerwowana", wiec czemu mozna odnosic sie pozniej do niej tak: pairs[index] = bla~, jakby byla tablicą jednowymiarową? Chyba nadal nie lapie :/

Przecież @Swr napisał:

pairs = new Object[length][2] jest deklaracja tablicy tablic
zatem pairs[0] jest tablicą.

Bo to jest tablica jednowymiarowa, która zawiera tablice o rozmiarze 2. Dzięki temu, że deklaracja wygląda tablica[][] kompilator wie, że odczytując tablica[indeks] otrzymasz tablicę, a nie "zwykły" obiekt.