Office week Slevový týden - Květen
Pouze tento týden sleva až 80 % na e-learning týkající se MS Office
30 % bodů zdarma na online výuku díky naší Slevové akci!

Lekce 10 - Vícerozměrná pole v Javě

V předešlém cvičení, Řešené úlohy k 9. lekci Javy, jsme si procvičili nabyté zkušenosti z předchozích lekcí.

Dnešní tutoriál je v kurzu základních konstrukcí Javy v podstatě bonusový a pojednává o tzv. vícerozměrných polích. Teoreticky můžete rovnou přejít k objektově orientovanému programování, doporučuji však si konec této sekce ještě alespoň projít, abyste měli o zbývajících technikách povědomí, přeci jen se jedná o dosti základní vědomosti.

Již umíme pracovat s jednorozměrným polem, které si můžeme představit jako řádku přihrádek v paměti počítače.

Struktura pole v Javě

(Na obrázku je vidět pole osmi čísel)

Ačkoli to není tak časté, v programování se občas setkáváme i s vícerozměrnými poli a to zejména pokud programujeme nějakou simulaci (např. hru).

Dvourozměrné pole

Dvourozměrné pole si můžeme v paměti představit jako tabulku a mohli bychom takto reprezentovat např. rozehranou partii piškvorek. Pokud bychom se chtěli držet reálných aplikací, které budete později v zaměstnání tvořit, můžeme si představit, že do 2D pole budeme ukládat informace o obsazenostech sedadel v kinosálu. Situaci bychom si mohli graficky znázornit např. takto:

Struktura dvourozměrného pole v Javě

(Na obrázku je vidět 2d pole reprezentující obsazenost kinosálu)

Kinosál by byl v praxi samozřejmě větší, ale jako ukázka nám toto pole postačí. 0 znamená volno, 1 obsazeno. Později bychom mohli doplnit i 2 - rezervováno a podobně. Pro tyto stavy by bylo správnější vytvořit si vlastní datový typ, tzv. výčet, ale s ním se setkáme až později, takže si teď musíme vystačit pouze s čísly.

Java ve skutečnosti neposkytuje žádnou dodatečnou podporu pro vícerozměrná pole, můžeme si je však jednoduše deklarovat jako pole polí. Definice takového pole pro kinosál by vypadala takto:

int[][] kinosal = new int[5][5];

První číslice udává počet sloupců, druhá počet řádků (samozřejmě si to můžeme určit i obráceně, např. matice v matematice se zapisují opačně).

Všechna číselná pole v Javě jsou po deklaraci automaticky inicializována samými nulami, můžeme se na to spolehnout. Vytvořili jsme si tedy v paměti tabulku plnou nul.

Naplnění daty

Nyní kinosál naplníme jedničkami tak, jak je vidět na obrázku výše. Protože budeme jako správní programátoři líní, využijeme k vytvoření řádku jedniček for cykly :) Pro přístup k prvku 2D pole musíme samozřejmě zadat 2 souřadnice.

kinosal[2][2] = 1; // Prostředek
for (int i = 1; i < 4; i++) // 4. řádek
{
    kinosal[i][3] = 1;
}
for (int i = 0; i < 5; i++) // Poslední řádek
{
    kinosal[i][4] = 1;
}

Výpis

Tento výukový obsah pomáhají rozvíjet následující firmy, které dost možná hledají právě tebe!

Výpis pole opět provedeme pomocí cyklu, na 2d pole budeme potřebovat cykly 2 (jeden nám proiteruje sloupce a druhý řádky). Jako správní programátoři nevložíme počet řádků a sloupců do cyklů napevno, jelikož se může změnit.

Musíme však pamatovat na skutečnost, že když se zeptáme na kinosal.length, bude obsahovat počet sloupců (přesněji délku vnějšího pole, které představuje sloupce). Abychom získali počet řádků (délku vnitřního pole, které sloupec reprezentuje), zeptáme se na kinosal[0].length. Všimněte si, že na to v poli musí být tedy alespoň jeden řádek.

Cykly zanoříme do sebe tak, aby nám vnější cyklus projížděl řádky a vnitřní sloupce v aktuálním řádku. Po výpisu řádku je nutné odřádkovat. Oba cykly musí mít samozřejmě jinou řídící proměnnou:

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

Výsledek:

Konzolová aplikace
00000
00000
00100
01110
11111

N-rozměrná pole

Někdy může být příhodné vytvořit si pole o ještě více dimenzích. My všichni si jistě dokážeme představit minimálně 3D pole. S příkladem s kinosálem se nabízí případ užití, kdy má budova více pater (nebo obecně více kinosálů). Vizualizace by vypadala asi nějak takto:

3D pole v Javě

3D pole můžeme vytvořit tím samým způsobem, jako 2D pole:

int[][][] kinosaly = new int [5][5][3];

Kód výše vytvoří 3D pole jako na obrázku. Přistupovat k němu budeme opět přes indexery (hranaté závorky) jako předtím, jen již musíme zadat 3 souřadnice.

kinosaly[3][2][1] = 1; // Druhý kinosál, třetí řada, čtvrtý sloupec

Pokud se zeptáme na kinosaly[0][0].length, získáme počet "pater" (kinosálů).

Zubatá pole

Pro všechny sloupce nemusíme udávat tu samou délku. Výsledkem je potom pole "zubaté" (v anglické literatuře jako "jagged array"). Výhodou deklarování 2D polí tímto způsobem je, že do každého řádku/sloupce můžeme poté uložit jak velké pole chceme. Tímto způsobem můžeme ušetřit paměť.

Takové 2D pole deklarujeme následujícím způsobem:

int[][] kinosal = new int[5][];

A můžeme si jej představit takto:

Pole polí v Javě

Nevýhodou tohoto přístupu je, že musíme pole nepříjemně inicializovat sami. Původní řádek s pěti buňkami sice existuje, ale jednotlivé sloupečky si do něj musíme navkládat sami (zatím si vložme všechny sloupečky o 5ti prvcích):

for (int i = 0; i < kinosal.length; i++)
{
    kinosal[i] = new int[5];
}

Java rovněž dále neposkytuje žádný komfort ve formě získání počtu sloupců a řádků polí polí. Velikost pole musíme získat takto:

int sloupcu = kinosal.length;
int radku = 0;
if (sloupcu != 0)
    radku = kinosal[0].length;

Všimněte si, že je nutné ptát se na počet sloupců, pokud je totiž 0, nemůžeme se dostat k 1. sloupci, abychom zjistili jeho délku (počet řádků ve sloupci).

K hodnotám v poli poté přistupujeme pomocí 2 indexerů:

kinosal[4][2] = 1; // Obsazujeme sedadlo v 5. sloupci a 3. řadě

Zkrácená inicializace vícerozměrných polí

Ještě si ukážeme, že i vícerozměrná pole je možné rovnou inicializovat hodnotami (kód vytvoří rovnou zaplněný kinosál jako na obrázku):

int[][] kinosal = {
    { 0, 0, 0, 0, 1 },
    { 0, 0, 0, 1, 1 },
    { 0, 0, 1, 1, 1 },
    { 0, 0, 0, 1, 1 },
    { 0, 0, 0, 0, 1 }
};

(Pole je v tomto zápisu otočené, jelikož definujeme sloupce, které zde zapisujeme jako řádky).

Podobnou inicializaci můžeme použít dokonce i u polí zubatých (kód níže vytvoří zubaté pole jako na obrázku):

int[][] zubatePole = {
    new int[] {15, 2, 8, 5, 3},
    new int[] {3, 3, 7},
    new int[] {9, 1, 16, 13},
    new int[] {},
    new int[] {5}
};

Na závěr bych rád dodal, že někteří lidé, kteří neumí správně používat objekty, využívají 2D polí k ukládání více údajů o jediné entitě. Např. budeme chtít uložit výšku, šířku a délku pěti mobilních telefonů. Ačkoli se vám nyní může zdát, že se jedná o úlohu na 3D pole, ve skutečnosti se jedná o úlohu na obyčejné 1D pole (přesněji seznam) objektů typu Telefon. Ale o tom až u objektově orientovaného programování. Pole si můžete vyzkoušet ještě v cvičení v této sekci.

V příští lekci, Matematické funkce v Javě a knihovna Math, se podíváme na matematické funkce a základní kurz úplně zakončíme.


 

 

Článek pro vás napsal David Čápka
Avatar
Jak se ti líbí článek?
21 hlasů
Autor pracuje jako softwarový architekt a pedagog na projektu ITnetwork.cz (a jeho zahraničních verzích). Velmi si váží svobody podnikání v naší zemi a věří, že když se člověk neštítí práce, tak dokáže úplně cokoli.
Unicorn College Autor sítě se informační technologie naučil na Unicorn College - prestižní soukromé vysoké škole IT a ekonomie.
Předchozí článek
Řešené úlohy k 9. lekci Javy
Všechny články v sekci
Základní konstrukce jazyka Java
Miniatura
Následující článek
Matematické funkce v Javě a knihovna Math
Aktivity (14)

 

 

Komentáře

Avatar
Peter Gasparik:28.2.2017 20:40

Hneď prvá veta. Píšeš: " V minulém tutoriálu o základech Javy jsme si uvedli metody Split() a Join() ..."

Kde si uvádzal metódy join() ?

Odpovědět
28.2.2017 20:40
while (noSuccess) { tryAgain(); if (Dead) break;
Avatar
David Čápka
Tým ITnetwork
Avatar
Odpovídá na Peter Gasparik
David Čápka:1.3.2017 11:18

Díky za upozornění, Java join() nemá, opravil jsem to.

Odpovědět
1.3.2017 11:18
Jsem moc rád, že jsi na síti, a přeji ti top IT kariéru, ať jako zaměstnanec nebo podnikatel. Máš na to! :)
Avatar
Lesní Muž
Člen
Avatar
Lesní Muž:22.4.2017 13:35

To tu dříve nebylo, že? Davide, plánuješ občas pilovat tyhle tutoriály v průběhu času způsobem dodáváním dílů, i když jsi ty předchozí psal např. před dvěma lety? Jestli tohle není vyjímka, pokuď ne, tak to budu muset každých pár měsíců zkontrolovat všechny tutoriály, ze kterých jsem čerpal, jestli tam nepřibyla nějaká moudrost navíc :D.

 
Odpovědět
22.4.2017 13:35
Avatar
gcx11
Redaktor
Avatar
Odpovídá na David Čápka
gcx11:22.4.2017 15:55

Statická metoda join na třídě String přibyla nově v Javě 8 (rok 2014).
https://docs.oracle.com/…/String.html#…...-

 
Odpovědět
22.4.2017 15:55
Avatar
Víťa Š.
Člen
Avatar
Víťa Š.:6.10.2019 20:44

Skvělá lekce. Díky!

Odpovědět
6.10.2019 20:44
Život by byl mnohem snazší, kdybychom k němu měli zdrojový kód.
Tento výukový obsah pomáhají rozvíjet následující firmy, které dost možná hledají právě tebe!
Avatar
Gemy
Člen
Avatar
Gemy:19. února 20:32

Když jsem uviděl vícerozměrná pole, hned mi hlavou probleskl nápad na textovou hru!
Dámy a pánové, ze jsem pro vás vytvořil hru zvanou TEMNÉ BLUDIŠTĚ.
Stačí jen celý kód nakopírovat a spustit, díky ITnetwork za tuto stránku.

package temne_bludiste_v_1_3;
import java.util.Scanner;
public class TEMNE_BLUDISTE_v_1_3 {

    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in,"Windows-1250");
    System.out.println("███▓▓▒▒░░▒▒▓▓████");
    System.out.println("██  Hra Michala Tomana ██");
    System.out.println("███▓▓▒ v1.3 ▒▓▓████");
    System.out.println("███  TEMNÉ BLUDIŠTĚ ! ██");
    System.out.println("███▓▓▒▒░░▒▒▓▓████");
    System.out.println("███▓▓ OVLÁDÁNÍ ▓▓████");
    System.out.println("Ve hře máš těchto 6 povelů");
    System.out.println("███▓▓▒▒░░▒▒▓▓████");
    System.out.println("ROVNE = pro 1 krok chodbou vpřed");
    System.out.println("PRAVA = pro 1 krok do chodby v pravo");
    System.out.println("LEVA = pro 1 krok do chodby v levo");
    System.out.println("ZPET = pro 1 krok zpět bez otočení");
    System.out.println("OTOC = pro otočení se na místě o 180°");
    System.out.println("KONEC = pro ukončení hry");
    System.out.println("███▓▓▒▒░░▒▒▓▓████");
//======================== MAPA ================================================
       int[][] mapa = {
           {1,1,1,1,1,1,1,1,1,1},
           {1,0,0,0,6,1,0,0,0,1},
           {1,7,1,1,0,1,1,0,1,1},
           {1,0,0,0,0,0,0,0,0,1},
           {1,1,0,1,1,1,0,1,0,1},
           {9,0,0,1,0,0,0,1,8,1},
           {1,1,0,1,1,0,1,1,0,1},
           {1,0,0,0,1,0,0,0,0,1},
           {1,-6,1,0,0,0,1,0,1,1},
           {1,1,1,1,1,1,1,1,1,1}
       };
//======================== PŘEDSTARTOVNÍ NASTAVENÍ =============================
    int x = 5;      // startovní pozice X
    int y = 4;      // startovní pozice Y
    int index = 2;  // směr natočení hráče
        // index 0 = SEVER
        // index 1 = VÝCHOD
        // index -1 = ZÁPAD
        // index 2 = JIH
//------------------------ jiná přednastavení ----------------------------------
    int pohyb;                      // v1.0
    int pocitadloKroku = 0;         // v1.0
    String dalsiKrok = "ano";       // v1.0
    String kompasSmer = "";         // v1.1
    String kompas = "ne";           // v1.1
    String kompasNalezen = "ne";    // v1.1
    int pocetKoster = 0;            // v1.2
    String kostlivec = "ne";        // v1.2
//========================= HLAVNÍ PROGRAM =====================================
while (dalsiKrok.equals("ano"))
{
    pocitadloKroku++;   // počet kroků pro vítěze
//============================ KOMPAS v1.1 =====================================
    while (kompas.equals("ano")){
        System.out.println("██▓ ▲ " + kompasSmer + " ▲ ▓██");
        kompas = "ne";
        kompasNalezen = "ano";
    }
//============================== POVELY ========================================
    System.out.print("██ " + pocitadloKroku + ": POVEL : ");
    String povel = sc.nextLine().trim().toLowerCase();
//-------------- určení povelu v závislosti na směru natočení ------------------
    switch (povel)
    {
        case "rovne":
                pohyb = index;
        break;
        case "zpet":
            if ((index == 0) || (index == -1)){
                pohyb = index + 2;
            }
            else pohyb = index - 2;
        break;
        case "prava":
            if ((index > -2) && (index < 2)){
                pohyb = index + 1;
            }
            else pohyb = -1;
        break;
        case "leva":
            if ((index > -1) && (index < 3)){
                pohyb = index - 1;
            }
            else pohyb = 2;
        break;
        case "otoc":
            pohyb = 5;
        break;
        case "konec":
            pohyb = 3;
            dalsiKrok = "x"; // konec programu při chybném zadání
        break;
        default:
            pohyb = 3;
            System.out.println("Chybný povel!");
    }
//------------------- vložení nuly do předchozího místa ------------------------
    mapa[x][y] = 0;
        int predchoziX = x; // poslední pozice X při nárazu do zdi
        int predchoziY = y; // poslední pozice Y při nárazu do zdi
//============================ KOSTLIVEC v1.2 ==================================
    while (kostlivec.equals("ano")){
        mapa[2][1] = 7;     // návrat kostlivce na pozici
        /* Předchozí funkce vložení nuly by pri nalezení kostlivce
        na jeho pozici vložila nulu, tento while cyklus ho navrátí zpět.*/
        kostlivec = "ne";
    }
//=========================== POHYB DLE POVELU =================================
    switch (pohyb)
    {
        case 0: // ROVNE
            y--;
        break;
        case 2: // ZPET
            y++;
        break;
        case 1: // PRAVA
            x++;
        break;
        case -1: // LEVA
            x--;
        break;
        case 5: // OTOC
            index += 2;
        break;
    } // --- konec pohybu ------------------------------------------------------
    int predchoziIndex = index;     // pokud hráč narazí do zdi
//================== ROTACE INDEXŮ DLE SMĚRU POHYBU ============================
    if (povel.equals("prava")){     // otočení ve směru hodin
        index++;
    }
    if (povel.equals("leva")){      // otočení proti směru hodin
        index--;
    }
    //---------------------- trasformace indexů při rotaci ---------------------
        if (index == 3){    // z 3 na -1 při otočení ze 2 na 3
            index = -1;
        }
        if (index == -2){   // z -2 na 2 při otočení ze -1 na -2
            index = 2;
        }
        if (index == 4){    // z 4 na 0 = otočení o 180°
            index = 0;
        }
    //------------------------ jen "grafika" -----------------------------------
            System.out.println("███▓▓▒▒░░▒▒▓▓████");
            System.out.println("███▓▓▒▒░░▒▒▓▓████");
//=================== REAKCE BLUDIŠTĚ NA ZÁKLADĚ POHYBU ========================
//---------------------------- krok je možný -----------------------------------
    if (mapa[x][y] == 0){
        mapa[x][y] = 2;     // současná pozice hráče
        if (povel.equals("rovne")){
            System.out.println("██ " + pocitadloKroku + ". Jdeš rovně chodbou");
        }
        if (povel.equals("prava")){
            System.out.println("██ " + pocitadloKroku + ". Jdeš do chodby v pravo");
        }
        if (povel.equals("leva")){
            System.out.println("██ " + pocitadloKroku + ". Jdeš do chodby v levo");
        }
        if (povel.equals("zpet")){
            System.out.println("██ " + pocitadloKroku + ". Udělal jsi krok zpět");
        }
        if (povel.equals("otoc")){
            System.out.println("██ " + pocitadloKroku + ". Otočil ses na místě");
        }
    }
//---------------------------- náraz do zdi ------------------------------------
    if (mapa[x][y] == 1){ // při nárazu do zdise hrác vrátí zpět na stejnou pozici a stejný index
        System.out.println("██ " + pocitadloKroku + ". Narazil jsi do zdi!");
        mapa[predchoziX][predchoziY] = 2;
        x = predchoziX;
        y = predchoziY;
        index = predchoziIndex;
    }
//----------------------- nalezení východu z bludiště --------------------------
    if (mapa[x][y] == 9){
        System.out.println("██  !!! JSI VENKU !!!  ██");
        System.out.println("Našel jsi cestu ven, gratuluji!");
        System.out.printf("Celkem jsi udělal %d kroků,\n", pocitadloKroku);
        System.out.println("nejmenší možný počet kroků je 12.");
            dalsiKrok = "x";    // ukončení opakování programu
    }
//--------------------------- kompas v1.1 --------------------------------------
    if (mapa[x][y] == 8){
        System.out.println("███ NAŠEL JSI KOMPAS ███");
        System.out.println("Jeho luminiscenční text");
        System.out.println("ti pomůže s orientací.");
        kompas = "ano";
    }

    while (kompasNalezen.equals("ano")){ // povolení opakovaného použití kompasu
        kompas = "ano";
        kompasNalezen = "ne";
    }

        switch (index){     // určení směru kompasu kde směru (indexu) hráče
            case 0:
                kompasSmer = "SEVER";
                break;
            case 1:
                kompasSmer = "VÝCHOD";
                break;
            case -1:
                kompasSmer = "ZÁPAD";
                break;
            case 2:
                kompasSmer = "JIH";
                break;
        }
//---------------------------- kostlivec v1.2 ----------------------------------
    if (mapa[x][y] == 7){
        pocetKoster++;
        if (pocetKoster == 1){  // první nalezení kostlivce
            System.out.println("████▓ KOSTLIVEC ▓████");
            System.out.println("Našel jsi kostlivce, ");
            System.out.println("asi nějaký hráč před tebou. ");
            kostlivec = "ano";
        }
        else {                  // opakované nalezení kostlivce
            System.out.println("████▓ KOSTLIVEC ▓████");
            System.out.println("Zase ten kostlivce, ");
            System.out.println("asi chodíš v kruhu. ");
            kostlivec = "ano";
        }
    }
//----------------------------- pasti v1.3 -------------------------------------
    if (mapa[x][y] == 6){
        System.out.println("███▓▓▒ CVAK! ▒▓▓████");
        System.out.println("Dlaždice pod tebou cvakla,");
        System.out.println("z bludiště se ozval rachot,");
        System.out.println("jako by se stěny začaly hýbat!");
        if (mapa[6][2] == 0){
            mapa[4][2] = 1;
        }
        if (mapa[6][2] == 1){
            mapa[4][2] = 1;
            mapa[6][2] = 0;
        }
    }
    if (mapa[x][y] == -6){
        System.out.println("███▓▓▒ CVAK! ▒▓▓████");
        System.out.println("Dlaždice pod tebou cvakla,");
        System.out.println("z bludiště se ozval rachot,");
        System.out.println("jako by se stěny začaly hýbat!");
        if (mapa[4][2] == 0){
            mapa[6][2] = 1;
        }
        if (mapa[4][2] == 1){
            mapa[6][2] = 1;
            mapa[4][2] = 0;
        }
    }
//------------------------ konec reakce bludiště -------------------------------
} //--------------------------- konec while ------------------------------------
    System.out.println("███▓▓▒ KONEC ▒▓▓███");
    System.out.println("███▓▓▒▒░░▒▒▓▓████");
    }
}
Odpovědět
19. února 20:32
Peníze neznamenají úspěch.
Avatar
Rozbita Zaluzie:25. dubna 19:56

Zdravím potřeboval bych pomoc pokusil jsem se udělat něco jako pohybový system který by měnil znak podle toho kde je aktuální pozice "hráče" a udělal jsem tento kó problém je v tom že pří pohybu doleva a nahoru (což jsou pohyby které zmenšují aktuální pozici viz. POHYBOVÝ SYSTÉM)se předešlé políčko nezmění zase na původní znak už jsem zkoušel nějaké řešení ale doteď nevím co s tím PS. ano vím je to dost podobné graficky k Gemymu ale to byl taky účel :)

package testypole;

import java.util.Scanner;

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

    Scanner sc = new Scanner(System.in, "Windows-1250");

    // ========================ÚVOD DO HRY======================
    System.out.println("███▓▓▒▒░░▒▒▓▓████");
    System.out.println("██ Hra Rozbité žaluzie ██");
    System.out.println("███▓▓▒ v0.1 ▒▓▓████");
    System.out.println("████ Mini Bludiště ████");
    System.out.println("███▓▓▒▒░░▒▒▓▓████");
    System.out.println("███▓▓ OVLÁDÁNÍ ▓▓████");
    System.out.println("█Ve hře máš tyto 4 povely█");
    System.out.println("███▓▓▒▒░░▒▒▓▓████");
    System.out.println("█NAHORU = pro 1 krok nahoru");
    System.out.println("█LEVA = pro 1 krok doleva");
    System.out.println("█PRAVA = pro 1 krok doprava");
    System.out.println("█DOLU = pro 1 krok dolů");
    System.out.println("█KONEC = pro ukončení hry");
    System.out.println("███▓▓▒▒░░▒▒▓▓████");

    //=====================PŘEDNASTAVENÍ=======================
    int pohyb = 0;
    int poziceY = 2;
    int poziceX = 2;
    String povel = "konec";
    String konec = "play";

    //========================MAPA================================
    String[][] mapa = {
        {"█","█","█","█","█"},
        {"█","█","█","█","█"},
        {"█","█","█","█","█"},
        {"█","█","█","█","█"},
        {"█","█","█","█","█"}
    };

    //======================HLAVNÍ CYKLUS===========================
    while ("play".equals(konec)){

        //================ÚVOD NA DALŠÍ TAH==================
        System.out.println();
        System.out.println("███▓▓▒▒░░▒▒▓▓████");
        System.out.println("█ tvůj následující pohyb █");
        System.out.print("███▓▓▒▒");
        povel = sc.next();
        System.out.println("███▓▓▒▒░░▒▒▓▓████");
        System.out.println();

        //==================POHYBOVÝ (pozicový) SYSTÉM=================
        switch (povel.toLowerCase()){
            case "nahoru":
                poziceY--;
                break;
            case "dolu":
                poziceY++;
                break;
            case "leva":
                poziceX--;
                break;
            case "prava":
                poziceX++;
                break;
            case "konec":
                konec = "end";
                break;
        }

        //=========== KONTROLA POLÍČEK A OBNOVENÍ  NA PŮVODNÍ ==========
        mapa[poziceY][poziceX] = "░";

        for (int y = 0;y < mapa[0].length; y++){
            for (int x = 0; x < mapa.length; x++){
                if (mapa[y][x] ==  mapa[poziceY][poziceX]){
                    mapa[y][x] = "░";
                }
                else if (mapa[y][x] != mapa[poziceY][poziceX]){
                    mapa[y][x] = "█";
                }
            }
        }

        //=================VYTISKNUTÍ AKTUÁLNÍ MAPY===================
        for (int y = 0;y < mapa[0].length; y++){
            for (int x = 0; x < mapa.length; x++){
                System.out.print(mapa[y][x] + " ");
            }
            System.out.println();
            }
        }
    }
}
 
Odpovědět
25. dubna 19:56
Avatar
Gemy
Člen
Avatar
Odpovídá na Rozbita Zaluzie
Gemy:26. dubna 19:46

Já bych udělal mapu z čísel na místo █, například 0 a pak ten pohyb dělal tak že půjdu x nebo y ++ nebo -- a tak do místa kde chci jít vložil místo 0 číslo 1, a zároveň předchozí pozici zase vynuloval.

Pak už jen pro výpis pole stačí dát podmínku že pokud má pole hodnotu 0 tak se vypíše █ a else dal vypsat ░ třeba takto:

Nezapomeň si naimportovat Scenner

int[][] mapa = new int[5][5];

int poziceX = 2;
int poziceY = 2;
boolean opak = true;

mapa[poziceX][poziceY] = 1;

do{
//-------------- výpis mapy -----------------------------------------------
for (int j = 0; j < mapa[0].length; j++)
{
    for (int[] mapa1 : mapa) {
        if (mapa1[j]== 0){
            System.out.print("█");
        }
        else System.out.print("░");
    }
System.out.println();
}
//--------------------------------------------------------------------------
System.out.print("Pohyb: ");
String pohyb = sc.nextLine().trim().toLowerCase();

int predchoziX = poziceX;
int predchoziY = poziceY;

switch (pohyb){
    case "nahoru":
        poziceY--;
        break;
    case "dolu":
        poziceY++;
        break;
    case "leva":
        poziceX--;
        break;
    case "prava":
        poziceX++;
        break;
    case "konec":
        opak = false;
        break;
    default:
        System.out.println("Chybné zadání");
}

mapa[predchoziX][predchoziY] = 0; // zápis do předchozí pozice
mapa[poziceX][poziceY] = 1; // zápis do nové pozice

}while (opak == true);
Odpovědět
26. dubna 19:46
Peníze neznamenají úspěch.
Avatar
Odpovídá na Gemy
Rozbita Zaluzie:26. dubna 22:50

Dobře taky jsem nad něčím podobným přemýšlel ale nedomyslel jsem to takto takže díky jo a ještě jenom... Není v Javě něco jako metoda odpočtu například na několik sekund... Že během intervalu bude něco True nebo nějaká přesná hodnota a pak se to změní zpět??

 
Odpovědět
26. dubna 22:50
Avatar
jan šín
Člen
Avatar
Odpovídá na Rozbita Zaluzie
jan šín:17. května 13:48

stačí vložit do metody main

int i=0;
new Thread(new Runnable() {
                                    @Override
                                    public void run() {
                                        try {
                                        i=1
                                        //t= počet zdržení v milisekundách
                                             Thread.sleep(t);
                                                i=0;
                                        }
                                        catch (InterruptedException r){
                                            System.out.println("err");
                                        }
                                         }
                                });
 
Odpovědět
17. května 13:48
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 10 zpráv z 10.