Funções do Array

Bom eu setei um array com alguns numeros

int nomeArray[] = new int[] {10,10,20,30,40};

//Gostaria de pegar o numero que mais se repete, há uma função que faça isso para mim ?

Resposta para duvida

[code]

/**
* Calcular qual dos Termos é a Moda
*/
public static void Moda() {
int ind = 0, cont = 0;
for (int index = 0; index < var.length; index++) {
if (Convert(var, index) == Convert(var, ind)) {
ind = index;
cont++;
}
}
System.out.println("Moda…: " + Convert(var, ind));
}[/code]

não testei, mas está resolvido. isto parece com exercicios de selecionar o número maior em uma lista… vc tem que ir verificando sempre se é maior ao próximo e guardar o último que for maior…

Então neste caso, a lógica penso eu, é contar os números iguais, e caso surja um número igual com mais contagens, esquecer os outros e ficar com este…

Tem muitas formas de fazer…

A sua não testei, mas se funciona parece bem apurada.
té+

Vc criou um método ‘Convert’ é isto?
Ele não aparece no código, portanto não sei o que faz.

Se o seu método Convert, for igual ao outro seu POST -> http://www.guj.com.br/java/308503-abrir-arquivo-txt

Não funciona…
até…

[quote=raghy]não testei, mas está resolvido. isto parece com exercicios de selecionar o número maior em uma lista… vc tem que ir verificando sempre se é maior ao próximo e guardar o último que for maior…

Então neste caso, a lógica penso eu, é contar os números iguais, e caso surja um número igual com mais contagens, esquecer os outros e ficar com este…

Tem muitas formas de fazer…

A sua não testei, mas se funciona parece bem apurada.
té+

Vc criou um método ‘Convert’ é isto?
Ele não aparece no código, portanto não sei o que faz.[/quote]

package br.org.catolicasc.luiz.almeida.junior.program;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

/**
 *
 * @author Luiz Almeida Júnior
 */
public class Aplicativo {

    static int media = 0;
    static String entradaLinha;
    static String[] var;
    static int variancia;
    static ArrayList<String> arrayOrdem = new ArrayList<String>();
    static Scanner input = new Scanner(System.in);

    /**
     * Ler Arquivo .txt
     */
    public static void Ler() {

        System.out.print("Informe o nome de arquivo texto.: ");
        entradaLinha = input.nextLine();

        try {
            FileReader arq = new FileReader(entradaLinha);
            BufferedReader lerArq = new BufferedReader(arq);
            entradaLinha = lerArq.readLine();

            var = entradaLinha.split(" ");

            arrayOrdem.add(entradaLinha);
            arq.close();

        } catch (IOException e) {
            System.err.printf("Erro na abertura do arquivo \n", e.getMessage() + "!");
        }
    }

    /**
     * Converte para String
     */
    public static int Convert(String[] split, int parametro) {
        int conversao = Integer.parseInt(split[parametro]);
        return conversao;
    }

    /**
     * Ordenar Vetor
     */
    public static void Rol() {
        Arrays.sort(var);
        System.out.print("\nRol.............................: ");
        Imprimir();
    }

    /**
     * Calcular arrayOrdem Média
     */
    public static void Media() {
        for (int index = 0; index < var.length; index++) {
            media = media + Convert(var, index);
        }
        media = (media / var.length);
        System.out.print("\nMédia...........................: " + media);
    }

    /**
     * Calcular arrayOrdem Mediana
     */
    public static void Mediana() {
        int esquerda = 0;
        int direita = var.length - 1;
        int meio;
        meio = (esquerda + direita) / 2;
        int mediana = Convert(var, meio);
        System.out.println("\nMediana.........................: " + mediana);
    }

    /**
     * Calcular arrayOrdem Amplitude
     */
    public static void Amplitude() {
        int amplitude;
        int index = 0;
        int menor = Convert(var, 0);
        int maior = Convert(var, index);
        while (index < var.length) {
            if (maior <= maior) {
                maior = Convert(var, index);
            }
            index++;
        }
        amplitude = maior - menor;
        System.out.println("Amplitude.......................: " + amplitude);
    }

    /**
     * Calcular arrayOrdem Variancia g
     */
    public static void Variancia() {
        variancia = 0;
        int cont = 0;
        
        for (int index = 0; index < var.length; index++) {
            variancia += Math.pow(Convert(var, index) - media, 2);
        }
        variancia = variancia / var.length;
        System.out.println("Variancia.......................: " + variancia);
    }

    /**
     * Calcular o Desvio Padrão
     */
    public static void DesvioPadrao() {
        double desvioPadrao = (Math.sqrt(variancia));
        System.out.printf("Desvio Padrão...................: %.2f", desvioPadrao);
        System.out.println("");
    }

    /**
     * Método de imprimir
     */
    public static void Imprimir() {
        for (int index = 0; index < var.length; index++) {
            System.out.print(var[index] + ", ");
        }
    }

    /**
     * Calcular qual dos Termos é a Moda
     */
    public static void Moda() {
        int ind = 0, cont = 0;
        for (int index = 0; index < var.length; index++) {
            if (Convert(var, index) == Convert(var, ind)) {
                ind = index;
                cont++;
            }
        }
        System.out.println("Moda............................: " + Convert(var, ind));
    }
}

Esse é meu código inteiro,

Boa Noite !!..

Não apenas o seu método Moda que tem problemas, seu método Mediana também não corresponde,
simplifique seu método Amplitude.
Siga as convenções de nomenclatura de métodos…

Você pretende ler apenas 1 linha no arquivo de texto ?

Até…

não cheguei a testar o código mas conseguiu resolver?

Boa Noite !! Resolvi fazer esse pequeno programa e mostrar meu ponto
de vista em relação as suas duvidas.

Faça um teste, espero que ajude !!!

/**
 * 
 * @author Andy11x
 */
public class Calculo { 
    
    public static void main(String[] args) {
        //Nosso Array poderia vir de um arquivo de texto como é seu caso
        //Basta adaptalo !!
        
        //Exemplo - Primeiro Conjunto
        Conjunto c = new Conjunto(new String[]{"30", "10", "20", "20", "10"});       
        System.out.println("Moda do Conjunto: " + c.moda());
        System.out.println("Mediana do Conjunto: " + c.mediana());
        System.out.println("Amplitude do Conjunto: " + c.amplitude());
        System.out.println("Variança do Conjunto: " + c.variancia());
        System.out.println("Desvio Padrão do Conjunto: " + c.desvioPadrao());
        
        //Exemplo - Segundo Conjunto
        c = new Conjunto(new String[]{"1.3", "5", "1.8", "1.3", "21", "2"});
        System.out.println("-------------------------------------------");       
        System.out.println("Moda do Conjunto: " + c.moda());
        System.out.println("Mediana do Conjunto: " + c.mediana());
        System.out.println("Amplitude do Conjunto: " + c.amplitude());
        System.out.println("Variança do Conjunto: " + c.variancia());
        System.out.println("Desvio Padrão do Conjunto: " + c.desvioPadrao());         
    }    
}
[/code][code]
import java.util.*;

/**
 * 
 * @author Andy11x
 */
public class Conjunto { 
    
    private double[] conjunto;   
    private List<Double> list;
    private double s;
    
    /**
     * Construtor 
     */
    public Conjunto(String[] conjunto) {                    
        init(conjunto);
    }   
    
    /**
     * O Método inicializa variáveis e popula nosso Array(double[])
     * e nossa Lista(List<Double>) e realiza a soma deixando-a pré
     * definida.No final ordena o Array.
     */
    private void init(String[] conjunto) {
        this.conjunto = new double[conjunto.length];
        list = new ArrayList<>();
        for(int i = 0; i < conjunto.length; i++){
            this.conjunto[i] = Double.parseDouble(conjunto[i]);
            list.add(this.conjunto[i]);
            s += this.conjunto[i];
        }
        Arrays.sort(this.conjunto);//Rol, ordena 
    }
    
    /**
     * O Método devolve o valor que surge com mais freqüência.
     * @Lembrando: pode haver mais que um valor com a mesma
     * frequência, nesse caso a moda teria dois resultados
     * ou mais, dependendo do conjunto.
     */
    public String moda() {
        int freq = 0, x = Integer.MIN_VALUE;    
        Set<Double> md = new HashSet<>();
        for(double n : conjunto){
            freq = Collections.frequency(list, n);
            if(freq >= x){
                x = freq;
                md.add(n);
            }
        }
        return x > 1 ? md.toString() : "Sem Moda";
    }    
    
    /**
     * O Método retorna há medida de localização do centro da
     * distribuição dos dados.
     * @Lembrando: Se o conjunto for ÍMPAR, a mediana é o elemento médio,
     * Se o conjunto for PAR, a mediana é a semi-soma dos dois elementos médios.
     */
    public double mediana() {                
        int e1 = (int)(conjunto.length / 2);
        double e2 = (conjunto[e1 - 1] + conjunto[e1]) / 2.0;        
        return conjunto.length % 2 == 0 ? e2 : conjunto[e1];
    } 
    
    /**
     * O Método retorna há diferença entre o valor maior e o valor menor
     * de um grupo de observações, no caso nosso conjunto. 
     */
    public double amplitude() {             
        return conjunto[conjunto.length - 1] - conjunto[0];
    }
    
    /**
     * O Método retorna o grau de variabilidade de determinadas situações,
     * através dela podemos perceber desempenhos iguais, muito próximos 
     * ou muito distantes. 
     */
    public double variancia() {
        double var = 0.0;       
        for(double n : conjunto){            
            var += Math.pow((n - media()), 2);
        }        
        return var / conjunto.length;
    } 
    
    /**
     * O Método retorna a medida de variabilidade que leva em
     * consideração toda a informação contida na amostra do 
     * conjunto. 
     */
    public double desvioPadrao() {
        return Math.sqrt(variancia());
    }  
    
    /**
     * O Método retorna número de elementos somados, que é igual
     * ao número de elementos do conjunto, ou seja, a média de s
     * números é sua soma dividida por há quantidade do cojunto.
     */
    private double media() {
        return s / conjunto.length;
    }  
}

[quote=andy11x]Boa Noite !! Resolvi fazer esse pequeno programa e mostrar meu ponto
de vista em relação as suas duvidas.

Faça um teste, espero que ajude !!!

[code]
/**
*

  • @author Andy11x
    */
    public class Calculo {

    public static void main(String[] args) {
    //Nosso Array poderia vir de um arquivo de texto como é seu caso
    //Basta adaptalo !!

     //Exemplo - Primeiro Conjunto
     Conjunto c = new Conjunto(new String[]{"30", "10", "20", "20", "10"});       
     System.out.println("Moda do Conjunto: " + c.moda());
     System.out.println("Mediana do Conjunto: " + c.mediana());
     System.out.println("Amplitude do Conjunto: " + c.amplitude());
     System.out.println("Variança do Conjunto: " + c.variancia());
     System.out.println("Desvio Padrão do Conjunto: " + c.desvioPadrao());
     
     //Exemplo - Segundo Conjunto
     c = new Conjunto(new String[]{"1.3", "5", "1.8", "1.3", "21", "2"});
     System.out.println("-------------------------------------------");       
     System.out.println("Moda do Conjunto: " + c.moda());
     System.out.println("Mediana do Conjunto: " + c.mediana());
     System.out.println("Amplitude do Conjunto: " + c.amplitude());
     System.out.println("Variança do Conjunto: " + c.variancia());
     System.out.println("Desvio Padrão do Conjunto: " + c.desvioPadrao());         
    

    }
    }
    [/code][code]
    import java.util.*;

/**
*

  • @author Andy11x
    */
    public class Conjunto {

    private double[] conjunto;
    private List list;
    private double s;

    /**

    • Construtor
      */
      public Conjunto(String[] conjunto) {
      init(conjunto);
      }

    /**

    • O Método inicializa variáveis e popula nosso Array(double[])
    • e nossa Lista(List) e realiza a soma deixando-a pré
    • definida.No final ordena o Array.
      */
      private void init(String[] conjunto) {
      this.conjunto = new double[conjunto.length];
      list = new ArrayList<>();
      for(int i = 0; i < conjunto.length; i++){
      this.conjunto[i] = Double.parseDouble(conjunto[i]);
      list.add(this.conjunto[i]);
      s += this.conjunto[i];
      }
      Arrays.sort(this.conjunto);//Rol, ordena
      }

    /**

    • O Método devolve o valor que surge com mais freqüência.
    • @Lembrando: pode haver mais que um valor com a mesma
    • frequência, nesse caso a moda teria dois resultados
    • ou mais, dependendo do conjunto.
      */
      public String moda() {
      int freq = 0, x = Integer.MIN_VALUE;
      Set md = new HashSet<>();
      for(double n : conjunto){
      freq = Collections.frequency(list, n);
      if(freq >= x){
      x = freq;
      md.add(n);
      }
      }
      return x > 1 ? md.toString() : “Sem Moda”;
      }

    /**

    • O Método retorna há medida de localização do centro da
    • distribuição dos dados.
    • @Lembrando: Se o conjunto for ÍMPAR, a mediana é o elemento médio,
    • Se o conjunto for PAR, a mediana é a semi-soma dos dois elementos médios.
      */
      public double mediana() {
      int e1 = (int)(conjunto.length / 2);
      double e2 = (conjunto[e1 - 1] + conjunto[e1]) / 2.0;
      return conjunto.length % 2 == 0 ? e2 : conjunto[e1];
      }

    /**

    • O Método retorna há diferença entre o valor maior e o valor menor
    • de um grupo de observações, no caso nosso conjunto.
      */
      public double amplitude() {
      return conjunto[conjunto.length - 1] - conjunto[0];
      }

    /**

    • O Método retorna o grau de variabilidade de determinadas situações,
    • através dela podemos perceber desempenhos iguais, muito próximos
    • ou muito distantes.
      */
      public double variancia() {
      double var = 0.0;
      for(double n : conjunto){
      var += Math.pow((n - media()), 2);
      }
      return var / conjunto.length;
      }

    /**

    • O Método retorna a medida de variabilidade que leva em
    • consideração toda a informação contida na amostra do
    • conjunto.
      */
      public double desvioPadrao() {
      return Math.sqrt(variancia());
      }

    /**

    • O Método retorna número de elementos somados, que é igual
    • ao número de elementos do conjunto, ou seja, a média de s
    • números é sua soma dividida por há quantidade do cojunto.
      */
      private double media() {
      return s / conjunto.length;
      }
      }
      [/code][/quote]

De fato a moda estava errada, obrigado por me ajudar a implementar o código, referente a nomenclatura as vezes me confundo por programar em C# o que em java é camel lá é pascal e vice versa