Contador de repetições - Dúvida com Array condição (I dont understand this line of Code)

Programação Java
,
#1

Galera,eu estou boiando para tentar entender , pq o código funcionou na condição abaixo:

Estou usando metódos para gerar opções solicitadas conforme o que o exercício pede…

Peço ajuda para alguem poder me explicar melhor de como eu contar as posições do meu Array que foram repetidas…

esta liinha está presente dentro de um FOR:

for(repeticao…){
num = vetor[i];
if (num == 3) { //Perguntar ao professor!!
repetiu++;
}
}

aqui vai meu código…quem puder me ajudar agradeço.

/*

  • Faça um programa que gere um vetor de 50 posições
    com valores aleatórios de 1 à 50, crie métodos para os seguintes retornos:

  1. Exibe o vetor ordenado

  2. Gera novos valores para o vetor

  3. Exibe quais números foram repetidos no vetor

  4. Sair do programa

    // Alguem pode me explicar esta parte do codigo?q to boiando,só consegui resolver usando esta  condição dentro do loop;
     num = vetor[i];
     if (num == 3) { //Perguntar ao professor!!
         repetiu++;
     }

Desenvolvido por : Tiago Ribeiro Santos
Email : tiago.programador@hotmail.com
*/
package ListaMetodos;

import javax.swing.JOptionPane;

public class Exercicio5 {

public static void main(String[] args) {
    int[] vetor = new int[50];
    int i = 0;
    String mostra_vetor = "";
    int opcao = 0;

    try {
        while (i < 50) {
            vetor[i] = (int) (Math.random() * 50) + 1;
            mostra_vetor = mostra_vetor + "|" + vetor[i] + "|";
            i++;
        }

        while (opcao >= 0 && opcao <= 3) {
            //peça o usuário para escolher a opção.
            opcao = Integer.parseInt(JOptionPane.showInputDialog("Digite 1 para exibir o vetor ordenado:"
                    + "\n 2 para Gerar novos valores para o Vetor:" + "\n3 para Exibir números"
                    + " que foram repetidos no vetor:" + "\n 0 para Sair do Programa:"));

            if (opcao == 1) {
                exibeVetorOrdenado(vetor);
            } else if (opcao == 2) {
                geraValores(vetor);
            } else if (opcao == 3) {
                mostraNumerosRepetidos(vetor);
            } else if (opcao == 0) {
                saidoPrograma();
            } else {
                JOptionPane.showMessageDialog(null, "Opção Inválida!", "ERRO!", JOptionPane.ERROR_MESSAGE);

            }

        }
    } catch (Exception erro) {
        JOptionPane.showMessageDialog(null, "Inválido!!Exceção disparada!", "ERRO!!", JOptionPane.ERROR_MESSAGE);
    }
}

public static int[] exibeVetorOrdenado(int[] vetor) {
    int b = 0;
    int aux = 0;

    //Gera novos vetores;
    for (int i = 0; i < vetor.length; i++) {
        vetor[i] = (int) (Math.random() * 50) + 1;
        i++;
    }

    for (b = 0; b < vetor.length; b++) {
        for (int i = 0; i < vetor.length; i++) {
            //Criar o primeiro vetor para realizar a troca
            //vetor[i] = 3  , vetor[b] = 4 , aux = 4 (vetor[b])   
            if (vetor[b] < vetor[i]) {
                aux = vetor[b]; // aux = 4;
                vetor[b] = vetor[i]; // vetor[b] = 3
                vetor[i] = aux;
            }
        }
    }
    System.out.println("Mostrando Vetores Ordenados:");
    for (int i = 0; i < vetor.length; i++) {
        System.out.println(vetor[i]);
    }

    return vetor;
}

public static int[] geraValores(int[] vetor) {
    int i = 0;
    String mostra_vetor = "";
    while (i < 50) {
        vetor[i] = (int) (Math.random() * 50) + 1;
        mostra_vetor = mostra_vetor + "|" + vetor[i] + "|";
        i++;
    }
    System.out.println("Novos Vetores gerados:" + mostra_vetor);
    return vetor;
}

public static int[] mostraNumerosRepetidos(int[] vetor) {
    int repetiu;
    repetiu = 0; // contador;
    // String mostra_vetor = "";
    int num = 0;
    int i;

    //Roda o vetor(Numeros que serao rodados.
    /*
    while (i < 50) {
        vetor[i] = (int) (Math.random() * 50) + 1;
        i++;
    }
     */
    //for (int b = 0; b < vetor.length; b++) {
    for (i = 0; i < vetor.length; i++) {
        num = vetor[i];
        if (num == 3) { //Perguntar ao professor!!
            repetiu++;
        }
        //Exibindo o vetor; 
        System.out.println("O numero:" + num + " repetiu:" + repetiu + " vezes!");
    }

    //}
    return vetor;
}

public static int saidoPrograma() {
    JOptionPane.showMessageDialog(null, "Obrigado por usar nosso programa!Volte sempre!:)");
    System.exit(0);

    return 0;
}

}

#2

Isso é trabalhoso de explicar, pois depende da estratégia adotada, para resolver o problema.
Pelo que você está fazendo, está contando somente quando o número três se repete.

Uma estratégia de solução seria criar outro vetor com 50 posições e ao invés de você lançar if(num == 3), você poderia lançarif(num == valorAtualDe1a50);.

Ao invés de usar um contador, quando a comparação acima for verdade, você pega o valorAtualDe1a50 joga no “vetor de pareamento” -> vetorPareamento [valorAtualDe1a50 - 1]++.

Ou seja, ao invés de usar uma variável para cada valor, você usa um vetor.

Exemplo:

    public static void main(String args[]) {
        Random random = new Random();
        //gerando números aleatórios
        int[] numeros = random.ints(50, 1, 50).toArray(),
                repetidos = new int[numeros.length];
        
        //capturando os valores repetidos pelo index do vetor repetidos
        for (int sorteado = 0; sorteado < numeros.length; sorteado++) {
            for (int repetiu = 0; repetiu < repetidos.length; repetiu++) {
                if (numeros[sorteado] == repetiu + 1) {
                    repetidos[repetiu]++;
                }
            }
        }
        
        //mostrando valores repetidos
        for (int i = 0; i < repetidos.length; i++) {
            System.out.println((i+1)+" repetiu "+repetidos[i]);
        }
        //confirmando o total de números
        System.out.println("Total -> "+IntStream.of(repetidos).sum());
                
    }

Como disse, depende da estratégia adotada.

Em particular, considerando a necessidade de trabalhar com vetores, eu gostei da seguinte estratégia:

public class Teste {

    public static void main(String args[]) {
        Random random = new Random();
        //gerando números aleatórios
        int[] numeros = random.ints(50, 1, 51).toArray();
        //ajustando o tamanho da matriz
        int[][] matriz = new int[(int) IntStream.of(numeros).distinct().count()][2];

        povoar(numeros, matriz);
        somarRepetidos(numeros, matriz);
        mostrarRepetidos(matriz);                
    }

    //A matriz não aceita valores repetidos e foi ajustada para conter a quantidade certa de elementos não repetidos
    private static void povoar(int[] fonte, int[][] matriz) {
    Arrays.stream(matriz).forEach(coluna -> {
        coluna[0] = Integer.MIN_VALUE;
    });
    for (int i = 0; i < fonte.length; i++) {
        for (int[] coluna : matriz) {
            if (coluna[0] == fonte[i]) {
                break;
            } else if (coluna[0] == Integer.MIN_VALUE) {
                coluna[0] = fonte[i];
                break;
            }
        }
    }        
}

    private static void somarRepetidos(int[] numeros, int[][] matriz) {

        for (int num = 0; num < numeros.length; num++) {
            for (int[] lista1 : matriz) {
                if (lista1[0] == numeros[num]) {
                    ++lista1[1];//somando os repetidos
                }
            }
        }
    }

    private static void mostrarRepetidos(int[][] matriz) {
        Arrays.sort(matriz, Comparator.comparing(num -> num[0]));
        int total = Arrays.stream(matriz).mapToInt(num -> {
            System.out.println(num[0] + " repetiu " + num[1]);
            return num[1];
        }).sum();
        System.out.println("Total -> "+total);
    }
}

Esta mais difícil explicar e não sei te dizer no momento qual deles seria mais eficiente/vantajosa à medida em que a quantidade de elementos aumenta.