[RESOLVIDO] NullPointerException ao popular o array

Eae galera.
Sou novo no grupo e estou com um problema, acredito que de lógica, e gostaria de help.
O trecho de código abaixo gera uma NullPointerException… Conseguem ver onde estou errando?
O compilador acusa a linha 25…

[code]import java.util.Random;

/**
*

  • @author Lucian Thomaz
    */
    public class Main {
    private int lista1[];
    private int lista2[];
    // private int auxLista1[];
    // private int auxLista2[];
    private int maior1, maior2,maiorAmbos=-1, num=0;
    private Random sorteio;
    private static final int MAX=100;

    public void run() {
    lista1 = new int[MAX];
    lista2 = new int[MAX];
    // auxLista1 = new int[MAX];
    // auxLista2 = new int[MAX];

     //preencher com valores aleatórios
     for(int i=0; i<MAX; i++) {            
         num = sorteio.nextInt();
         lista1[i] = num;
         num = sorteio.nextInt();
         lista2[i] = num;
     }
     
     maior1 = lista1[1];        
     //descobrir o maior nas duas
     while(maiorAmbos==-1) {
         for (int i=0; i<MAX; i++) {
             if (maior1>lista1[i]){
                 maior1=lista1[i];
                 lista1[i]=0;
             }            
         }
         for (int i=0; i<MAX; i++) {
             if (maior1==lista2[i]) maiorAmbos=maior1;            
         }            
     }
     
     System.out.println("Maior em ambos: "+maiorAmbos);
    

    }

    public static void main(String args[]) {
    Main x = new Main();
    x.run();
    }

}
[/code]

Agradeço desde já (:

Segue comentado: (não sei o objetivo do teu código)

  • Dificilmente vai sair do while.

[code]//declarar o random
sorteio = new Random();
lista1 = new int[MAX];
lista2 = new int[MAX];
// auxLista1 = new int[MAX];
// auxLista2 = new int[MAX];

    //preencher com valores aleatórios  
    for(int i=0; i<MAX; i++) { 
        num = sorteio.nextInt();  
        lista1[i] = num;  
        num = sorteio.nextInt();  
        lista2[i] = num;  
    }  
      
    maior1 = lista1[0];          
    //descobrir o maior nas duas  
    while(maiorAmbos==-1) {
        //roda lista 1 atras de maior
        for (int i=1; i<MAX; i++) {
            //se maior for o da lista
            if (maior1>lista1[i]){  
                //maior recebe o da lista
                maior1=lista1[i];  
                //e o da lista recebe 0
                //nao sei pra que.
                lista1[i]=0;  
            }              
        }  
        //roda toda a lista2
        for (int i=0; i<MAX; i++) {
            //se maior1 for igual a algum item da lista2
            if (maior1==lista2[i]) 
                //um numero repetido nas 2 listas
                //que seja o maior
                //quase impossivel de sair do while
                maiorAmbos=maior1;              
        }              
    }  
      
    System.out.println("Maior em ambos: "+maiorAmbos); [/code]

Então kara… o objetivo é o seguinte:
Escreva um programa Java que cria duas listas de valores inteiros inicializadas com 100 valores aleatórios. Em seguida o programa deverá imprimir qual o maior valor que está armazenado nas duas listas simultaneamente. No exemplo abaixo, com listas de 5 elementos, o maior valor armazenado nas duas é 07.

L1: 04,12,07,30,20
L2: 50,07,04,21,33

… Eu não compreendi muito bem se você alterou algo no código, pelo o que eu entendi vc apenas comentou certo?

O problema é que quando eu executo esse código, ele gera um NullPointerException, acusando o primeiro FOR.

Dá uma olhada que os comentários estão explicando o que foi alterado. Não havia sido instanciado o Random sorteio.
Agora dá uma modificada no que está dentro do while, pelo seu objetivo o algoritmo não está correto.
Tenta arrumar e manda pra a gente dar uma olhada.

eae Rafael,
vlw pela ajuda, quebrei bastante a cabeça, consegui resolver agora… \o HESIUAHEIAHE
Segue o código…
Agora, não sei se você pode dar uma força sobre isso… Meu professor começou a introduzir conceitos de complexidade de algoritmos, e disse que performance será levado em conta.
Pelo o que eu pude perceber, caso eu use um array de 100 posições, na pior das hipóteses serão feitas 100100=10000 operações. Se eu dobrar o tamanho, array de 200, serão feitos 200200=40000 operações. Se dobrar novamente 400400=160000, e depois 800800=640000. Ou seja, a solução tem um crescimento exponencial.
Sabe se há como melhorar o algoritmo?

Obrigado pela ajuda.

[code]import java.util.Random;

/**
*

  • @author Lucian Thomaz
    */
    public class Main {

    private int lista1[];
    private int lista2[];
    //Lista auxiliar para a lista1 para não modificar a original
    //Não é necessário auxiliar para a lista2 pois será usada apenas para consulta
    private int auxLista1[];
    private int maior1, maiorAmbos=-1, num=0;
    private Random sorteio;
    private static final int MAX=10;
    private static final int MAX_RANDOM=100;

    public void run() {
    sorteio = new Random();
    lista1 = new int[MAX];
    lista2 = new int[MAX];
    auxLista1 = new int[MAX];
    int contaux=0;

     //preencher listas com valores aleatórios
     for(int i=0; i<MAX; i++) {            
         num = sorteio.nextInt(MAX_RANDOM);
         lista1[i] = num;
         auxLista1[i]=num;
         num = sorteio.nextInt(MAX_RANDOM);
         lista2[i] = num;
     }
     int index=0;
     //descobrir o maior nas duas
     while(maiorAmbos==-1 && contaux<(MAX)*(MAX)) {            
         maior1=-1;
         for (int i=0; i<MAX; i++) {                
             if (maior1<auxLista1[i]){
                 maior1=auxLista1[i];                                        
                 index=i;
             }            
         }
         auxLista1[index]=0;
         //Print apenas para acompanhar o ocorrido
         System.out.println("Maior= "+maior1);
         for (int i=0; i<MAX; i++) {
             if (maior1==lista2[i]) maiorAmbos=maior1;            
             contaux++;                
         }
         System.out.println(contaux);
     }
     
     //Parte do código apenas para visualização do ocorrido
     for (int i=0; i<MAX; i++) {
         System.out.print(", "+lista1[i]);            
     }
     System.out.println("");
     for (int i=0; i<MAX; i++) {
         System.out.print(", "+auxLista1[i]);            
     }        
     System.out.println("");
     for (int i=0; i<MAX; i++) {
         System.out.print(", "+lista2[i]);            
     }        
     System.out.println("");
     
     
     if (maiorAmbos==-1) System.out.println("Nada feito");
     else
         System.out.println("Maior em ambos: "+maiorAmbos);
    

    }

    public static void main(String args[]) {
    Main x = new Main();
    x.run();
    }

}
[/code]

me parece que vc está dando muitas voltas para chegar ao resultado.

Por que você precisa comparar 100100 vezes? Iterar 100100 vezes?

Assim, minha sugestão é que você pense como você iria comparar sem usar o computador. (cria duas listas de 4 números cada, e faça na mão, para você ver como você faria normalmente)

Agora, só para você conhecer (pois creio que não possa usar isso para incrementar o desempenho), você pode usar um Comparator http://download.oracle.com/javase/1.4.2/docs/api/java/util/Comparator.html

Edit: Ah, um outro detalhe, se me lembro bem o Random retorna entre 0 e 1, mas não é legal para a lógica colocar o valor inicial em maior1 como -1, se mudar a lógica de entrada de dados você fica preso nisso.

evefuji, a lógica que eu usei foi a seguinte…
Como eu tenho que achar o maior valor que esteja em ambos os arrays, primeiro eu percorro o primeiro array todo e acho o maior, aí depois comparo esse valor com todos valores do segundo array e vejo se há algum igual a ele, se não houver, pego o segundo maior valor do primeiro array e comparo novamente com todos os do segundo, e assim sucessivamente, até comparar todos com todos. Seguindo essa lógica, no pior dos casos, que é nenhum ser igual a nenhum, ele terá que percorrer o segundo array, (com 4 pra exemplificar), 4 vezes comparando com o maior do primeiro, depois mais 4 comparando com o segundo maior do primero, depois mais 4 … e mais 4… ou seja 44 = 16 …
Aí, se eu for dobrando o tamanho, acontece o que já disse antes… 8
8=64 , 16*16=256 …exponencial.
Não consigo pensar se há uma outra forma mais eficiente que essa pra resolver o problema…

entendi agora, “maior valor que esteja em ambos os arrays” no caso, o valor tem que estar presente em ambos os arrays ao invés de ser o maior dos dois (independente de estar em ambos)

Vou dar uma dica, ordena antes os arrays (procura sobre algoritmos de ordenamento, ou desenvolva a própria lógica, o que recomendo no início, mas o que eu costumo usar por ter maior desempenho é o balance line, usado bastante em bancos de dados, outra opção também boa, é o bubble sort)

evefuji…
é, ordenando os arrays mataria a charada… Um colega chegou a propor isso em sala na sexta (dia que o exercicio foi dado). O professor disse que até pode, mas aí estaria “fugindo” da lógica do problema…
Mas acho que também esse assunto já fugiu completamente do problema inicial do tópico \o… EHASIUEAHE… Vou dar uma pesquisada, e falar com alguns colegas…
Mas vlw mesmo pela ajuda…