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)
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();
}
}
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.
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.
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:
Eficácia: Antes de otimizar, tenha certeza que você tem uma solução perfeitamente funcional.
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;
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…
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.