Array com duas dimensões!

Estou tentando implementar um código para prencher uma matriz mas recebo varios erros.
Obrigado por ler.

package projetolista;

/**
 *
 * @author jubei
 */
public class Tela {
    
    private int x = 10,y = 10;
    private int[][] matriz = new int[10][10];
    
    public void preencheComZero(){
        
        for(int i = 0; i < x;i++){
            for(int j = 0; j < y; j++ ){
                
                matriz[i][j] = 0;
                
            }//fim do for de j
        }//fim do for de i
    }//fim do metodo preenchComZero()
    
    
    
    public void mostra(){
        
        for(int i = 1; i <= x-1;i++){
            for(int j = 1; j <= y-1; j++ ){
                
                System.out.printf(null, matriz[i][j]);
                
            }//fim do for de j
        }//fim do for de i
    }//fim do metodo mostra()

}//fim da classe

package projetolista;

/**
 *
 * @author jubei
 */
public class TelaTeste {
    public static void main(String[]args){
        
        Tela Tela1 = new Tela();
        
        Tela1.preencheComZero();
        Tela1.mostra();
    }

}

Estes são os erros

init:
deps-jar:
compile-single:
run-single:
Exception in thread “main” java.lang.NullPointerException
at java.util.regex.Matcher.getTextLength(Matcher.java:1140)
at java.util.regex.Matcher.reset(Matcher.java:291)
at java.util.regex.Matcher.(Matcher.java:211)
at java.util.regex.Pattern.matcher(Pattern.java:888)
at java.util.Formatter.parse(Formatter.java:2457)
at java.util.Formatter.format(Formatter.java:2413)
at java.io.PrintStream.format(PrintStream.java:920)
at java.io.PrintStream.printf(PrintStream.java:821)
at projetolista.Tela.mostra(Tela.java:35)
at projetolista.TelaTeste.main(TelaTeste.java:18)
Java Result: 1
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)

Para quê o null no printf?

                System.out.printf(null, matriz[i][j]);  

O primeiro parämetro nunca, nunca, nunca pode ser null, já que é a formatação do dado. Use “%d”.

Se você não quiser formatar, use simplesmente System.out.print() ou System.out.println() (este quebra a linha).

Outra coisa… observe essa linha:
Tela Tela1 = new Tela();

Por uma questão de conveção, é comum atribuir nomes de objetos iniciando com letras minúsculas.

continuo com o mesmo problema

Qual é o novo código e que erro dá agora?

Exception in thread “main” java.lang.NullPointerException
at java.util.regex.Matcher.getTextLength(Matcher.java:1140)
at java.util.regex.Matcher.reset(Matcher.java:291)
at java.util.regex.Matcher.(Matcher.java:211)
at java.util.regex.Pattern.matcher(Pattern.java:888)
at java.util.Formatter.parse(Formatter.java:2457)
at java.util.Formatter.format(Formatter.java:2413)
at java.io.PrintStream.format(PrintStream.java:920)
at java.io.PrintStream.printf(PrintStream.java:821)
at projetolista.Tela.mostra(Tela.java:35)
at projetolista.TelaTeste.main(TelaTeste.java:18)
Java Result: 1
CONSTRUÍDO COM SUCESSO (tempo total: 1 segundo)

Esta funcionando perfeitamente, porem vc pediuy para ele preenche tudo com ZERO estou certo?


package projetolista;

/**
 *
 * @author jubei
 */
    public class Tela {
    
      private int x,y;
      private int[][]matriz;
   
    
       public Tela(){
         x = 10;
         y = 10;
         matriz = new int[10][10];
      }
    
         
       public void preencheComZero(){
        
         for(int i = 0; i < x;i++){
            for(int j = 0; j < y; j++ ){
                
               matriz[i][j] = 0;
                
            }//fim do for de j
         }//fim do for de i
      }//fim do metodo preenchComZero()
    
    
    
       public void mostra(){
        
         for(int i = 1; i <= x-1;i++){
            for(int j = 1; j <= y-1; j++ ){
                
               System.out.print(matriz[i][j]);
                
            }//fim do for de j
            System.out.println();
         }//fim do for de i
      }//fim do metodo mostra()
   
   }//fim da classe

package projetolista;



/**
 *
 * @author jubei
 */
    public class TelaTeste {
    
      static Tela Tela1;
    
       public static void main(String[]args){
        
         Tela1 = new Tela();
        
         Tela1.preencheComZero();
         Tela1.mostra();
      }
   
   }


correto, quero simular um programa de pintura, esta é apenas a primeira parte.

Tudo bem jubei?

não sei se já resolveu o problema, mas uma outra dica.

Não precisa setar todas as posições com 0, pois mesmo em um array de tipos primitivos eles são setados com o seu valor padrão, ou seja, um array de int já são setados por default com 0 em todas as posições.

Mas a não ser que futuramente queira setar para apagar valores.

Abraços.

Acho que a melhor forma de zerar tudo é simplesmente um matriz = new int[10][10];

poder ser que sim ou não.

Se ele for fazer várias vezes o interessante pode ser ele zerar posição por posição, pois assim estaria criando mais objetos (arrays) na memoria, sendo que o array é pequeno.

Não sei se estou certo, mas desenvolvo meus programas tentando utilizar o menos de memória possível, seja com um array ou uma String.

O que você sitou é o meio mais prático. Mas as vezes nem mais eficiente.
Se estiver errado me corrigam.

Abraço a todos.

Depende também se ele ficar passando a referência direta ao array pra toda parte. O coletor de lixo pode não pegar o objeto caso alguém esteja usando. Zerar manualmente é o que dá pra se fazer aqui.

Agora, se puder encapsular a Matriz para que ninguém tenha a referência ao array, aí preferiria instanciar um novo objeto para zerar tudo. O motivo é a velocidade, o compilador pode implementar isso como zerar um bloco contínuo da memória. Também o coletor vai chegar corretamente pra fazer o trabalho dele, a economia de memória viria disso.

Não faz diferença, e se fizer, ela não será perceptível. O Java mantém um espaço de memória pré-alocado. Ele também consegue identificar objetos de “vida curta”, que são constantemente recriados e reaproveitar a memória alocada. Aliás, nesse sentido, ele é bem mais eficiente as linguagens “não gerenciadas”, como o C++. Claro que isso vem com um custo: a memória pré-alocada ocupa espaço. Não é a toa que qualquer aplicação Java, por mais ridícula que seja, vai ocupar muita memória.

[quote=gabrielmassote]Não sei se estou certo, mas desenvolvo meus programas tentando utilizar o menos de memória possível, seja com um array ou uma String.

O que você citou é o meio mais prático. Mas as vezes nem mais eficiente.
[/quote]

É claro que não é bom abusar, mas é um erro grave de projeto ter muita preocupação com memória e desempenho. Especialmente se isso for afetar a elegância e a legibilidade do código. O que você tem que pensar é que um código mais difícil, mesmo que seja mais eficiente, é mais caro de se fazer, mais sujeito a erros e mais caro de se manter também.

Existem alguns estágios que um código deve atingir, quando trabalhamos com performance. Tenha certeza de não queimar etapas:

  1. Eficácia: Antes de otimizar, tenha certeza que você tem uma solução perfeitamente funcional.
  2. Eficiência: Use um profiler para identificar os problemas de performance. Nesses pontos, corrija bugs e procure soluções mais eficientes. Em 90% das vezes, só reorganizar o código já resolve o problema de performance, sem que seja necessário usar estruturas complexas, menos flexíveis ou abrir mão da simplicidade e elegância;
  3. Especialidade: Sempre usando o profiler, otimize levando em consideração aspectos de negócio do problema. Otimizações desse tipo tornam o software menos flexível, mas ainda podem apresentar grandes ganhos de performance. Um exemplo clássico é o algoritmo de busca A*, que é o mais utilizado em mapas hoje em dia, mas que, diferente da busca de Dijkstra, não pode ser usado em muito mais situações fora essa…
  4. Ilegibilidade: Se todas as etapas anteriores foram vencidas, é hora de questionar se vale a pena abrir mão da legibilidade do código. Primeiro, use o profiler e tenha absoluta certeza que os passos 1, 2 e 3 não resolvem mesmo o seu problema. Depois, otimize só os pontos necessários, e tente restringir o escopo das mudanças ao máximo possível.

A regra básica é a seguinte: Se você não tem um problema, não tente otimizar. No caso da sua alocação, dificilmente seria perceptível a diferença entre alocar com new ou zerar o array todo com Arrays.fill. Ou seja, você estará gastando tempo, preocupação, deixando o código mais complexo para corrigir um problema que não está lá.

Por isso, priorize sempre um código fácil de ler e fácil de manter.

Obrigado a todos, resolvemos mais um problema e aprendi um pouco mais de java.