Diskuze: Rada?
No a cykly:)
Máme 6 druhy cyklů:
For
For-each
While
Do-while
Rekurze
a zacyklit podmínky do sebe, ale to je jen příklad prasárny (ani to už
neumím, jen to uvádím, že to nějak jde, asi tak, jakože existuje
stupidSort:) )
Základ je For cyklus
důležitá je syntaxe - teď ti ukážu jak to vypadá:
for(int i = 0, i < 10;i++){
}tak.... vypadá to složitě, ale po tom předchozím spamu mi věř, že to
projdu step by step:D
takže stejně jako třídy a metody, i cykly se skládají z hlavičky a
těla
- for Hlavička for cyklu začíná slovíčkem for (popravdě nešťoural jsem, proč zrovna for:) to si vygoogli nebo to tu někdo doplní, ale pamatuj, že prostě for (a není to fór:D))
- () kulatá závorka přestavuje "tělo" hlavičky.
Tak a teď menší vsuvka.
PAMATUJ, ŽE KAŽDÝ CYKLUS MUSÍ MÍT 3 PARAMETRY!!!!!!!!
a logicky bys je i odvodil, když se zeptáš, co potřebuješ k nějakému
opakování furt dokola:
1.) potřebuješ nějakou výchozí hodnotu - řekněme, že budeš třeba
opakovat 10 čísel, ale začneš od čísla 15 Takže pro nás by byla
výchozí hodnota 15
2.) potřebuješ vědět, do kdy to máš dělat, ať jak debil nezačneš
třeba od 0 a zkončíš u trilionů. Takže třeba určíme, že zkončíš,
až budeš mít číslo 30
3.) no a za třetí sice víš, že začínáš od 15 do 30, ale nevíš, jestli
jít po jedné, dvou nebo po patnácti. Takže to je ten třetí parametr - ten
nám řekne, o kolik to budeme zvyšovat
PS: snaž se to vždy i při zadávání parametrů takhle: 1. od kolika, 2.
DOKUD a 3. o kolik (když by sis třeba místo toho druhého například
říkal,ne dokud ale do, tak tě to může časem zavádět na blbé úvahy - a
věř že vím o čem mluvím, já byl ten blbec, který se nechal svést-.- ale
včil su šikovný tester z Moravy:) )
Takže teď už možná trošku chápeš tu hlavičku. Ve for cyklu je
zajímavost, že tady toto nejsou parametry, ale dá se říct takové "bloky"
toho cyklu. Proto se neoddělují čárkou, ale středníkem;)
takže jdeme na první for-cyklus (nebo taky for-loop loopa je cyklus:) )
začínáme tedy magickým slovíčkem for a kulatými závorkami:
for()včil začneme těmi bloky, takže nejdřív si zadeklarujeme třeba proměnnoui a naplníme ji hodnotou 15 (to je to, co už umíš) a dáme V ZÁVORCE ZA TENTO BLOK středník!!!!!! NE ZA KULATÉ ZÁVORKY, TAM ANI NEPATŘÍ!!!! (tedy mohl by být, ale... o tom potom)
for( int i = 15 ; ) //mezer si dělej kolik chceš, jediné, kde by to vadilo, je v názvech, ale kolem názvů a mezer si dělej so chceš (tedy jen bílé znaky. a jestli nevíš co je bílý znak - ITNetwork a jedem od první lekce)tak druhý blok je podmínka DOKUD ne do ale DOKUD. takže si to tak
řeknem:
"cyklus se bude furt opakovat DOKUD je hodnota i menší nebo rovna 30" NEBO
"cyklus se bude furt opakvoat DOKUD hodnota i není rovna 30" to si vyber sám,
co se ti líbí, ale častěji je ten první případ
Matematicky zapsáno: dokud je hodnota i (i) menší nebo rovna (<=) 30
(30)
takže bez těch keců kolem závorek máme: i <= 30 a to tam šoupnem jako
druhý blok:
for( int i = 15 ; i <= 30 ; ) //a zase středník za druhý blokno a třetí blok je ta inkrementace nebo dekrementace. No... tyto dva
výrazy znamenají něco specifičtějšího, to ti řeknu za chvíli....
Takže zvolíme si třeba, že se bude i zvyšovat vždy o 3, ať je prdel,
takže výstup by měl být od 15 do 30 a po třech, takže bys měl mít
vypsaná čísla 15, 18, 21, 24, 27 a 30
zvyšování o několik je zase matematická úloha, stačí správně
mluvit:
"přičítám hodnotě i (i) k její původní hodnotě (což je i) + 3 (+3)
takže matematicky: i = i +3 (nová hodnota i se rovná stará hodnota i +
3)
no a takhle to zapíšeme do třetího bloku OVŠEM UŽ BEZ
STŘEDNÍKU!!!!!!!!!
for( int i = 15 ; i <= 30 ; i = i + 3 ) //závorka a hlavičku máme dokončenouTeď už jen přidáme tělo (jako vždy složenými závorkami)
for(int i = 15;i<=;30;i=i+3){
}a máme hotový cyklus. Do těla pak napiš, aby vypsal hodnoty i
System.out.println(i);
Zkus si třeba zaexperimentovat - když nenapíšeš třeba i<=30, ale jen
i<30, nebo když napíšeš, že i = 31 v tomto případě - co se asi
stane:) nebo že nebudeš zvyšovat o součty 3,ale násobky 3 (násobení je
hvězdičkou* a dělení /, ale bacha, uvědom si, žekdyž dělíš nebo
odčítáš, že podmínka musí být zapsána jinak:) Jeslti nejsi úplný
tukan, tak ti to dojde - stačí správě mluvit a říkat si, co vlastně
děláš (a proto tak dbám, abys to správně říkal)
tak ještě k tomu třetímu bloku....
Java je chytrý jazyk a existují i různé finty, jak si ušetřit zápis.
Např.: když napíšeš jako jsme to psali předtím (i = i + 3) tak tam
píšeš dvakrát i a jak něco v programování píšeš stejné a víckrát,
je to hnus. Např.: tento konrkténě příklad by se dal zkrátit tak, že bys
vynechal to i za rovná se a to plusko dal za to první i a před rovná se.
Prostě si zapamtuj, že i = i + 3 je to samé, jako i += 3 Java to pochopí a
ty vypadáš drsně:)
Pochopitelně to tak funguje s jakoukoliv operací. Např.: i *= 99 atd.
ale pozor - záleží hodně na to pořadí před
rovnítkem!!!!!!!!!!!!!!!!!!!
pokud napíšeš i += 3, tak Java chápe, že má nejdřív k nějakému číslu
přičíst 3 a pak vykonat nějakou operaci.
Kdybys napsal i =+ 3, tak nejdřív vykoná operaci a pak až přičte 3. Což
by třeba dělalo s některými cykly hodně velký problém! takže pozor na
to.
Znamínka okolo rovnítka jsou vcelku složitější a přejdi k tomu radši
až po nějaké praxi. Ale existuje ještě jedna finta v programování, kterou
jsem tu už nakousl a ukázal v prvním příkladu cyklu:
říká se tomu:
INKREMENTACE a
DEKREMENTACE
(a nemá to nic společného s exkrementy, to někteří developeři
vytvářejí, ale to je zase něco jiného:) )
**Inkrement znamená navýšení
dekrement zase snížení
**
Prostě co zvyšuješ (ať už plusem, nebo násobením nebo různými
výpočty) tak je inkrementace
když naopak jakkoliv snižuješ, je to dekrementace
A existují dva velmi příjemné zápisy ve dvou zvláštních
případech
Dost často se stává (třeba zrovna pro procházení všech prvků v poli),
že potřebuješ zvyšovat/snižovat pouze o jedničku. Takže bys to psal furt
dokola jak osel i = i +/- 1
Ve všech jazycích se používá pro sčítání a odčítání (násobení a
dělení NE) zjednodušený zápis:
i = i + 1 je to samé, jako i++
i = i - 1 je to samé jako i--
PS: nemá to nic společného s c++, i kdyby sis to céčko dal místo ička a
takhle to zapsal, ale s jazykem c++ toto nesouvíisí:)
Ještě bych měl trošku říct, proč i..... je to takový nejčastější případ - právě kvůli té Inkrementaci - to je takový nejobecnější příklad cyklu:
for(int i = 0;i<10;i++){´
System.out.println(i);
}tento kód vypíše čísla od 0 do 9 a je na to dokonce v netbeansech klávesová zkratka, která ti vytvoří přesně takovýto for cyklus (když chceš třeba na rychlo otestovat část pole a tak) Proto se používá i, a když máš cyklus v cyklu, tak "i" a "j". Ale můžeš použít jakýkoliv název, třeba i fň:) nebo auto - je to obyčejná proměná a ty s ní nějak pracuješ.
NO.... to byl první cyklus - for a už je tu spam jak blázen:D
For cyklu je hodně podobný while cyklus. dá se říct, že bys ho dokázal
zapsat stejně - ukážu ti dva stejné cykly, ale jeden for a jeden while:
for(int i = 100;i>=0;i--){
System.out.println(i);
}
int i = 0;
while(i>=0){
System.out.println(i);
i--;
}Pozor!!! zrovna v tomto případě - napíšeš-li tento while před for, tak
ti to vyhodí chybu, protože ve for cyklu bys deklaroval novou proměnnou i,
kterou ovšem deklaruješ lokálně "nad" tím cyklem, to jen na
upozornění!
Jinak vidíš, že v tomto případě není žádná změna - zase tři
bloky,akorát že si tu proměnnou připravuješ mimo ten cyklus (právě to je
jeden z hlavních rozdílů mezi forkem a whileem - while cyklus může
začínat od hodnoty, kterou třeba někdo zadá nebo ji někde nějak později
získáš. For vstupní hodnotu nastavuješ ty jako dev/tester. while má v
závorce jen jeden blok a to je podmínka DOKDY, nebo DOKUD platí. A
inkrementaci si zařizuješv těle toho cyklu. to se třeba hodí, když máš
případ, že chceš ještě na začátku toho cyklu pracovat s vypočítanou
hodnotou, kterou sis vypočítal na konci těla. A až ji použiješ, tak teprve
inkrementuješ. Já to třeba akorát přesně tak dělám v tetrisu:) zatím co
mi jedna kostička padá - já si potom vygeneruji novou kostičku a na
začátku cyklu ji předeám,aby padala a mezi tím si vytvořím novou atd.
furt do kola (cyklus)
While je ještě specifický tím, že je hodně dá se říct
"uživatelský" zrovna tady v prvních tutoriálech ho krásně využívají -
kdy vlastně se dá říct, že while cyklus bude probíhat DOKUD uživatel
nezmění nějakou hodnotu, nebo dokud uživatel nezmačkne Alt + F4 
Šlo by to tak psát i u for cyklu, ale to by pak vypadalo takto:
for(;UZIVATEL_NEZMACKL_KLAVESU_M;){
}
//zatím co while:
while(UZIVATEL_NEZMACKL_KLAVESU_M){
}
//tam ty středníky nemá a vypadá to líp. Oba fungují, ale je o ty středníky (jinak přečteš správně tuhle podmínku, kterou oba mají?:) schválně jestli si vzpomeneš na to důležité slovíčko:)Tak třetí cyklus je DO-WHILE cyklus,který představuje v podstatě while cyklus,ale ještě navíc s tělem DO, takže zápis vypadá následovně:
int i = 0;
do{
System.out.println("Jů hele a do prdele!");
}while(i > 3)schválně jsem to napsal takhle!
Když se na to pozorně podíváš, tak bez toho do, které zatím nevnímáme,
bychom to přečetli:
"hodnota "i" je 0. Opakuj cyklus while DOKUD je hodnota i větší než 3" To je
kokotina co? tak ona je 0 a on to má opakovat, dokud je hodnota stále větší
než 3 - což není ani jednou.
A TO JE TEN ROZDÍL!!!! mezi while a do-while. i kdybychom v cyklu pracovali s
hodnotou, která má být naplněná, ale není a to je třeba chyba, tak mi
chceme,aby ASPOŇ JEDNOU ten cyklus prošel! prostě nesere nás, že podmínka
není splněná, my to chceme jednou projít, tečka konec diskuze!!
no a proto on udělá do, ok, tak já vám to jednou pustím, ale pak neplatí
podmínka.
(trošku jsem se teď prokecl - ano jak devy, tak testři, jsou debilové a povídají si s počítačem:) akorát, že on vrací zprávy typu get a jejich znění je v hodnotách:) - např.: taková aspoň u mě každodenní konverzace s počítačem: "ty kokote, proč vracíš null ??!!!!!??":)
Takže for, je základ, while je uživatelský,do-while musí aspoň jedno
uproběhnout
Potom je tzv. for-each (ano, dalo by se to tak i přeložit - "pro každého")
To zase navážu na ten minulý spam. Asi by ti došlo, že abys zjistil
všechny hodnoty v poli a nechal si je třeba vypsat nebo bys hledal hodnotu,
která přdstavuje dejme tomu písmenko "b", tak bys to nechal projet cyklem.
Např.:
String slovo = "ůvjdsssssgdsjdsjjjgdasggjsajsgkůvjdsssssgdsjdsjjjgdasggjsajsgkdkgdkg";
//a já chci vědět, na kolikátém indexu je první písmeno "a", tak udělám třeba takvový for cyklus:) nebo while - tady je to jedno, jaký bys použil, ale do while je teď na hovno, protože to projde určitě víckrát, takže to nepotřebujeme
String[] pole = slovo.split(""); //jo ještě k tomu splitu - do závorky mezi uvozovky zadáváš, čím chceš to slovo rozdělit, tak třeba kdybys tam dal tečku (".") tak řekneš, že chceš rozdělit slovo natolik dílů, kolik je mezi nimi teček - tak třeba slovo "ůldfsů.fůsjfj.ůljf" bys rozdělil na tři díly a to pole by mělo 3 prvky. No a když tam dávám jen prázdné uvozovky, tak chci rozdělit žádným parametrem - proto to bere všechna písmena jako a tolik bude mít to pole indexů
String pismenoA; //teď si nejsem jistý jestli by nechtěla Java totu proměnnou inicializovat:O kyžtak by to bylo String pismenoA = ""; jakože je zatím prázdný řetězec
for(int i = 0; pismenoA.equals("a") ;i++) { //jen tak mimochodem:) hádej proč začínáme od 0 a ne od 1:) A jinak vidíš - zadávám podmínku a nemusí to být s íčkem. Já chci prostě najít první písmeno A - tak takovou dám podmínku. To equals - tose používá pro porovnání řetězců - je to vlastně to samé, jako bych napsal pismenoA == "a" (při porovnání se používají dvě rovnítka, protože jedno rovnítko přiřazuje nějakou hodnotu proměnným nebo neměnným:)
pismenoA = pole[i];
if(pismenoA.equals("a"){
System.out.println(i);
}
}A až to najde "a", tak to skončí a vypíše index (když jdem od nuly, tak
index pole je stejný jako íčko:) )
PS: třeba konkrétně toto je diskutabilní otázka,jestli tam rvát podmínku
(to je to if) a nebo si dřív deklarovat nějakou proměnnou typu int a vždy
ji naplňovat novým íčkem (to by vypadlo jednoduše takhle: proměnná = i;
no a jak by ten cyklus skončil, tak bych už tu poslední hodnotu měl v té
proměnné a použil ji a nemusel bych dělat podmínku.
Osobně jsem byl vždy pro rychlejší řešení, ale co začínám nabírat zkušenosti v profi firmě (hlavně od jednoho borce, u kterého jsem si jistý, že by bez problémů hacknul třeba i databázi Pentagonu) tak se "přeučuju" návyky. Není prý vždy nejlepší psát všechno zrychlenými metodami - pak se neví, co se čím chtělo dokázat a kód začíná být hůř čitelný. Prioritou je psát kódy tak, aby je po tobě nemusel nikdo luštit, ale aby mrknul a updatoval. Ale to jen taková poznámečka bokem - takhle třeba uvažují ITáci, tak abys měl simple example:)
No a teď proč jsem psal tento příklad. Takhle by se dalo procházet jak
pole, tak kolekce a nešikovně i mapa (nešikovně asi chápeš proč - spousta
hodnot by byla null). No ale, máš-li pole nebo kolekci!! (u mapy to nejde),
kde máš postupně seřazené indexy a máš jistotu, že žádný z indexů
nemůže být prázdný (prostě to nejde - viz článek výš), tak můžeš
použít ten for each - cyklus pro každého. Je to lepší varianta v tom, že
nepoužíváš žádné proměnné, ale rovnou saháš na tu konkrétní hodnotu
(je to vlastně for cyklus, ale zkrácený zápis)
Existují dva zápisy for-each:
for(Integer number : array){
}toto je první a jednodušší zápis, i když se nepodobá ani jednom ze zmíněnýh tří cyklů. Jde vlastně o to, že ty pracuješ s nějakou konkrétní kolekcí - to je tady array. (budeme vycházet že v tom máš integery, takže sis předtím deklaroval kolekci, takto:
ArrayList<Integer> array = new ArrayList<>();a nastrkals do něj nějaké hodnoty pomocí metody add().
Tak ukážu ti ještě, jak bys to mohl udělat obyčejným for cyklem:
for(int i = 0;i<array.size();i++){
}tento cyklus bys přečetl tak, že bys začal od indexu 0 a procházel bys
kolekci po jednom indexu až na konec. Pokud potřebuješ takhle projít celou
kolekci a ne třeba jen půlku z nich (pokud to není na celou kolekci, musí se
použít buď for nebo while, a ne for-each cyklus) tak je výhodnější
použít ten for-each
for-each je zkrácená verze právě tohoto for cyklu.
Je to cyklus, který ví, že půjde po jednom indexu přes celou kolekci, proto
nepotřebuje uvádět ten třetí blok. Ví dokonce, že půjde od prvního
indexu až po poslední v kolekdi, proto nepotřebuje ani první ani druhý
blok.
Jenže musí mít v hlavičce aspoň nějaký parametr. tady se zcela
vyjímečně oddělují dva parametry dvojtečkou. Tak se i for-each dá lehce
poznat.První parametr je deklarace proměnné, která má stejný datový typ,
jakého je celá kolekce nebo pole. Ale nesmíš ji naplňovat - to už si
cyklus udělá sám za tebe. Ty jen musíš deklarovat tu proměnnou, abys ty
měl s čím pracovat:) (jinak by sice cyklus prošel, ale ty by ses nemohl ani
dívat na výpis, prostě by cyklus prošel tak, že by se počítač podíval
na prvky a řekl si: "hezké moc hezké a co já s tím?":)
For-each ti v každém průchodu do té proměnné nastaví další a další
index - prostě tu proměnnou při každé své inkrementaci přepíše další
hodnotou indexu, který je o jedničku vyšší.
No a co si s tím uděláš ty - to je už tvoje věc
Takže tento for-each vypíše naprosto všechny prvky z celé kolekce a je mu
jedno, jestli jich je tam 13 nebo 100 000:
for(Integer number :array){
System.out.println(number);
}a abys pracoval s větším objemem dat:) zkus si tohle:
ArrayList<Integer> array = new ArrayList<>();
for(int i = 0;i<1000000;i++){
array.add(i);
}
for(int i = 0;i<array.size();i++){
System.out.println(array.get(i));
}
for(Integer kikiriki:array){
System.out.println(kikiriki);
}první cyklus ti naplní kolekci milionkem dat (možná se ti sekne kompl
) no a ty další dva
udělejaí naprosto to samé - vypíšou potsupně hodnoty té kolekce. Takže
tady můžeš vidět, že v tomto případě je mezi for cyklem a for-each
cyklem rozdíl v tom, že for-each je přehlednější a rychleji zapsaný:)
Ale kdybys změnil u toho for vypisovacího for cyklu hodnotu z i++ na i += 2
(nebo i = i + 2) tak to už je for each nahraný. Taky by to tak uměl přiadala
by se mu podmínka, ale zbytečně by načítal (v tomto případě o půl
milionu víc dat, než by bylo potřeba) a se vší úctou, to už je kurva
rozdíl.
Druhý zápis for-each je trošku složitější.Dělá naprosto to samé, ale je to jiný zápis, takže ho uvedu jen pro info:
array.stream().forEach((number) ->{
System.out.println(number);
});abych se přiznal -taky nevím všechno a zatím jsem nezkoumal, proč a co
je vlastně ten strream. Jen jsem se to naučil a popravdě z jednoho jediného
důvodu - sere mě, když mi netbeans píše nějaké warningy a jsem líný je vypínat
No a na závěr - Rekurze
rekurze je vlastně metoda, která vola samu sebe.
Např.:
//někde předtím zavolám tuto metodu s parametrem třeba 0 - rekurze(0);
public int rekurze(int a){
if(a < 3){
a++;
rekurze(a);
}else{
System.out.println("tato větev je ukončena");
}
}Tento kód si lze špatně představit a rekurzi vůbec. Nejvíce se rekurze používá pro prohledávání adresářů - to je asi ten nejlepší příklad. Prostě jde furt a furt do hloubky. Kdysi dávno jsem průběh rekurze od začátku až po konec tady kdesi popisoval -zkusím to najít. a pak přiložím. Je to hodně o představivosti, ale já to tu i zakreslil:) tak to zkopčím a hodím sem.
Lubor Pešek:24.9.2016 0:13
to v dalším vlákně:D:D:D ale až teď je konečně chápu - díky tomu
kolegovi, kterého jsem zmiňoval - on je fakt neuvěřitelný. Nepřemýšlí,
prostě se usměje a radí stylem: vymaž tyhle kokotiny, napiš tenhle
jednoduchý command (pochopitelně spletitý řetězec jak kráva ) a funguje to:D
Zobrazeno 17 zpráv z 17.