Vydělávej až 160.000 Kč měsíčně! Akreditované rekvalifikační kurzy s garancí práce od 0 Kč. Více informací.
Hledáme nové posily do ITnetwork týmu. Podívej se na volné pozice a přidej se do nejagilnější firmy na trhu - Více informací.
Avatar
Tomhaus
Člen
Avatar
Tomhaus:15.12.2014 20:55

Ahojky lidi, mam jeden problém s 2D polem. Píše mi to že indexuju mimo pole, ale podle mě ty čísla sedí přesně.
Asi hodinu sem na to koukal a pořád sem na to nepřišel.

package Matrix;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import javax.swing.JPanel;

public class Screen extends JPanel {
        private static final long serialVersionUID = 1L;

        private static final int WIDTH = 630, HEIGHT = 320;

        private Font font1, font2;

        private int Ubits;
        private int ContChar;
        private int GWidth = ContChar + Ubits;

        private final ArrayList<GNumbers> values = new ArrayList<GNumbers>();
        private GNumbers[][] coors;

        private Color colorBack = new Color(0x919191);
        private Color colorVBorder = new Color(0x61FF61);
        private Color colorUBorder = new Color(0x5656FF);
        //private Color colorGBorder = new Color(0xFF4040);

        public Screen(){
                setFocusable(true);
                setPreferredSize(new Dimension(WIDTH, HEIGHT));



        }

        public void setUbits(int Ubits){
                this.Ubits = Ubits;
        }

        public void setContChar(int ContChar){
                this.ContChar = ContChar;
        }

        public void del(){
                values.clear();
        }

        public void fill(){
                coors = new GNumbers[Ubits][Ubits];
                System.out.println(Ubits);

                for(int i = 0; i <= Ubits; i++){
                        for(int j = 0; j <= Ubits; j++){
                                values.add(new GNumbers(100 + i * 20, 100 + j * 20, 0));
                        }
                }


                int index = 0;
                for(int x = 0; x <= Ubits; x++){
                        for(int y = 0; y <= Ubits; y++){
                                        coors[x][y] = values.get(index);
                                        int value = coors[x][y].getValue();
                                        int xPos = coors[x][y].getxCoor();
                                        int yPos = coors[x][y].getyCoor();
                                        System.out.println("Na index: [" + x + "][" + y + "] vkládám: " + xPos + " " + yPos + " " + value);

                                        index++;
                        }
                        if(index == values.size()){
                                break;
                        }
                }
        }

        public void paint(Graphics g){
                //základní tabulka pro 4x1 (4-bit) matici U a 6x4 matici G => 6x1 matice V
                //šířka a výška rámenčku (políčka matice) 30px
                //mezera mezi maticemi 10px

                g.setColor(colorBack);
                g.fillRect(0, 0, WIDTH, HEIGHT);

                font1 = new Font("Arial", Font.PLAIN, 24);
                font2 = new Font("Adobe Arabic", Font.PLAIN, 18);

                //m = posun matice U kvůli zvětšující se velikosti matice V
                int m = GWidth;
                if(GWidth >= 6){
                        m++;
                }else if(GWidth < 6){
                        m = GWidth + 1;
                }

                g.setFont(font2);
                g.setColor(Color.BLUE);
                g.drawString("G", 495 - (GWidth - 6) * 15, 118 - (Ubits - 4) * 30);
                g.drawString("U", (335 - (Ubits - 4) * 15) - (m - 7) * 30, 310);
                g.drawString("V", 495 - (GWidth - 6) * 15, 310);


                g.setColor(Color.BLACK);

                g.setFont(font1);
                /*
                // 1 -> G
                for(int i = 0; i <= 3; i++){
                        g.drawString("1", 424 + i * 30, 149 + i * 30);
                }
                // 0 -> G
                for(int i = 0; i <= 3; i++){
                        for(int j = 0; j <= 3; j++){
                                if(i != j){
                                        //(i != 0 || j != 0) && (i != 1 || j != 1) && (i != 2 || j != 2) && (i != 3 || j != 3)
                                        g.drawString("0", 424 + i * 30, 149 + j * 30);
                                }
                        }
                }
                */


                for(int i = 0; i <= Ubits; i++){
                        for(int j = 0; j <= Ubits; j++){
                                try {
                                        g.drawString(Integer.toString(coors[i][j].getValue()), coors[i][j].getxCoor(), coors[i][j].getyCoor());
                                } catch (Exception e) {
                                        PrintWriter pw = null;
                                        try {
                                                pw = new PrintWriter(new FileOutputStream("Log"));
                                        } catch (FileNotFoundException e1) {
                                                // TODO Auto-generated catch block
                                                e1.printStackTrace();
                                        }
                                    e.printStackTrace(pw);
                                }
                        }
                }

                if(Ubits > GWidth - ContChar){
                        GWidth++;
                }
                if(Ubits < GWidth - ContChar){
                        GWidth--;
                }


                //matice V
                for(int l = 0; l <= GWidth; l++){
                        //svisle V
                        for(int i = 0; i <= l; i++){
                                g.drawLine((415 + i *30) - (l - 6) * 30, 255, (415 + i * 30) - (l - 6) * 30, 285);
                        }
                        //vodorovně V
                        for(int i = 255; i <= 285; i += 30){
                                g.drawLine(415 - (l - 6) * 30, i, 595, i);
                        }
                }


                //matice U
                for(int k = 0; k <= Ubits; k++){
                        //svisle U
                        for(int i = 0; i <= k; i++){
                                g.drawLine(((285 + i * 30) - (k - 4) * 30) - (m - 7) * 30, 255, ((285 + i * 30) - (k - 4) * 30) - (m - 7) * 30, 285);
                        }
                        //vodorovně U
                        for(int i = 0; i <= 1; i++){
                                g.drawLine((285 - (k - 4) * 30) - (m - 7) * 30, 255 + i * 30, 405 - (m - 7) * 30, 255 + i * 30);
                        }
                }


                //matice G
                for(int k = 0; k <= Ubits; k++){
                        for(int l = 0; l <= GWidth; l++){
                                //svisle G
                                for(int i = 0; i <= l; i++){
                                        g.drawLine((415 + i * 30) - (l - 6) * 30, 125 - (k - 4) * 30, (415 + i * 30) - (l - 6) * 30, 245);
                                }
                                //vodorovně G
                                for(int i = 0; i <= k; i++){
                                        g.drawLine(415 - (l - 6) * 30, (125 + i * 30) - (k - 4) * 30, 595, (125 + i * 30) - (k - 4) * 30);
                                }
                        }
                }


                //rámeček V
                g.setColor(colorVBorder);
                g.drawRect(414 - (GWidth - 6) * 30, 254, 182 + (GWidth - 6) * 30, 32);

                //rámeček U
                g.setColor(colorUBorder);
                g.drawRect((284 - (Ubits - 4) * 30) - (m - 7) * 30, 254, 122 + (Ubits - 4) * 30, 32);
                /*
                if(ContChar != 0){
                        //rámeček G
                        g.setColor(colorGBorder);
                        //g.drawRect(414, 124, 182, 122);
                        g.drawRect(564 - (ContChar - 1) * 30, 184 - (Ubits - 2) * 30, 32 + (ContChar - 1) * 30, 62 + (Ubits - 2) * 30);
                }
                */
                repaint();
        }
}

Když k tomu poli coors přidam k té proměnné + 1 (k oběma rozměrům), tak to tu chybu nevykazuje, ale já nechci mít to pole větší o 1 než tu proměnnou.
Kde je teda ta chyba?

Editováno 15.12.2014 20:58
Odpovědět
15.12.2014 20:55
Být lepší a chytřejší je důležité, ale někdy se musíme spokojit s tím, co máme.
Avatar
tomisoka
Tvůrce
Avatar
Odpovídá na Tomhaus
tomisoka:15.12.2014 21:01
for(int x = 0; x <= Ubits; x++){

tento cyklus ti dá největší x = Ubits. Zatímco pole coors má největší index = Ubits-1.

 
Nahoru Odpovědět
15.12.2014 21:01
Avatar
Tomhaus
Člen
Avatar
Odpovídá na Tomhaus
Tomhaus:15.12.2014 21:11

tak nic přišel sem na to sám, stačilo smazat ty = u těch for loopů :)

Nahoru Odpovědět
15.12.2014 21:11
Být lepší a chytřejší je důležité, ale někdy se musíme spokojit s tím, co máme.
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 3 zpráv z 3.