Rekurencja - odwracanie char[]

Witam napisalem metode rekurencyjna odwarcajaca tablice typu char. Pytanie moje jest nastepujace, czy jest to poprawnie zrobione? Zagwozdke mam dlatego, ze ta metode musze wywolywac ze stalym parametrem 0 i nie jestem pewny czy nie powinienem zrobic tego w inny sposob..

public class Main {
static public void main(String[] args)
{
	char[] tablica = {'K', 'a', 'm', 'i', 'l'};
	for(int i=0; i<tablica.length; i++)
	{
		System.out.print(tablica[i]);
	}
	tablica=Main.czytaj(tablica, 0);
	for(int i=0; i<tablica.length; i++)
	{
		System.out.print(tablica[i]);
	}
}
static char[]czytaj(char[] tab, int i)
{
	char a;
	if(i<tab.length)
	{
		a=tab[i];
		tab[i]=tab[tab.length-i-1];
		tab[tab.length-i-1]=a;
		i++;
	}
	return tab;
}
}

Pozdrawiam

1. przekazywanie i jako parametr - mija się ze zdrowym rozsądkiem
2. nie if tylko while
3. nie do długości tylko do połowy długości (może od połowy długości do 0 w dół)
4. nie musisz zwracać tablicy zmiany będą widoczne w funkcji wywołującej.
5. char a; warto zadeklarować przy pierwszym użyciu (ułatwiasz prace optymalizatorowi, oraz czytającemu kod)

Czyli generalnie jak w tym kawale o Ormiańskim Radio:
Słuchacz dzwoni do studio i pyta:

• Czy to prawda że Abarcumian wygrał milion w totolotka?
• Tak to prawda, lecz nie Abarcumian zaś Agadżanian i nie milion zaś tysiąc i nie w totolotka zaś w pokera i nie wygrał zaś przegrał.

Wersja Prologowa może Cię naprowadzi na rozwiązanie:

reverse([], A, A).
reverse([H|T], A, R) :- reverse(T, [H|A], R).

reverse(A, R) :- reverse(A, [], R).

Ewentualnie (prawie) to samo w Haskellu:

rev xs = rev' xs []
  where rev' [] acc = acc
            rev' (x:xs) acc = rev' xs (x:acc)

static void reverse(char[] tab)
  {
   for(int p=0,q=tab.length;p<--q;++p)
     {
      char temp=tab[p];
      tab[p]=tab[q];
      tab[q]=temp;
     }
  }

Poszedlem na latwizne i zrobilem 2 tablice bo slowo Kamil zmienialo sie w kamak :P
Dzieki wielekie za podpowiedzi mam nadzieje, ze teraz wyglada to sensowniej.
PS.
nie wiedzialem, ze w petli for moge zainicjowac 2 zmienie na poczatku ;o przyda sie

public class Main {
	static char a;
	static char[] tablica = {'K', 'a', 'm', 'i', 'l','K', 'a', 'm', 'i', 'l'}, tablica2 = new char[tablica.length];
static public void main(String[] args)
{
	for(int j=0; j<tablica.length; j++)
	{
		System.out.print(tablica[j]);
	}
	System.out.println();
	Main.czytaj(tablica);
	for(int j=0; j<tablica.length; j++)
	{
		System.out.print(tablica2[j]);
	}
}
static int czytaj(char[] tab)
{
	int i=0;
	while(i<tab.length)
	{
		tablica2[i]=tab[tab.length-i-1];
		i++;
	}
	return i;
}
}

@Edit
nie rozumiem nasze metody dzialaja na tej samej zasadzie
@edit2
a to wszystko przez Ciebie bo mi kazales if'a wyrzucic.. :P troche sie zagubilem probuje od nowa..

1. w kodzie w OP nie ma rekurencji (jest / powinna być iteracja)

2. rekurencja nie jest najlepszym rozwiązaniem tego problemu (jeśli istnieje taka wersja)

3. krótsza wersja:

import org.apache.commons.lang.ArrayUtils;

public class Main {
static public void main(String[] args)
{
    char[] tablica = {'K', 'a', 'm', 'i', 'l'};
    for(int i=0; i<tablica.length; i++)
    {
        System.out.print(tablica[i]);
    }

    ArrayUtils.reverse(tablica);

    for(int i=0; i<tablica.length; i++)
    {
        System.out.print(tablica[i]);
    }
}

}

Udalo sie.. Zadanie jest proste

[1 pkt.] Utwórz metode, która rekurencyjnie odwróci ciag znaków dostarczony jako
argument metody char[].

najprostrze rozwiazania sa najlepsze:

static void czytaj(char[] tab, int i)
{
    if(i<tablica.length)
    {
    	Main2.czytaj(tab, i+1);
        System.out.print(tab[i]);
        return;
    }
}

Mam przemeczony mozg, za duzo pracuje i jeszcze wzialem studia na klate, java i android to to do czego daze ale widze ze strasznie duzo pracy przede mna.
Coz kazdy profesjonalista byl kiedys amatorem..
Sry za zamieszanie, dzieki za pomoc ;)

Czy rozumiesz różnicę pomiędzy odwróceniem a wyświetleniem wspak?

public class Main2 {
	static char a;
	static char[] tablica = {'K', 'a', 'm', 'i', 'l'};
static public void main(String[] args)
{
	for(int j=0; j<tablica.length; j++)
	{
		System.out.print(tablica[j]);
	}
	System.out.println();
	Main2.reverse(tablica,0);
	for(int j=0; j<tablica.length; j++)
	{
		System.out.print(tablica[j]);
	}
}
static void reverse(char[] tab, int i)
{
	if(tab.length%2==0)
	{
		if(i<tab.length/2)
		{
			Main2.reverse(tab, i+1);
			a=tab[i];
			tab[i]=tab[tab.length-1-i];
			tab[tab.length-1-i]=a;
		}
	}
	else
	{
		if(i<tab.length/2+1)
		{
			Main2.reverse(tab, i+1);
			a=tab[i];
			tab[i]=tab[tab.length-1-i];
			tab[tab.length-1-i]=a;
		}
	}
}
}

Dzieki, ze mnie przycisnales :P
Pozdrawiam

Ależ przekombinowałeś:

public class Main2 {
    static public void main(String[] args)
    {
        char[] tablica = {'K', 'a', 'm', 'i', 'l'};
        System.out.println(new String(tablica));
        reverse(tablica,0);
        System.out.println(new String(tablica));
    }
    static void reverse(char[] tab, int i)
    {
        int k=tab.length-1-i;
        if(i>=k) return;
        char a=tab[i];
        tab[i]=tab[k];
        tab[k]=a;
        reverse(tab, i+1);
    }
}