Funções do Array

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));
    }
}

/**
 * 
 * @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());         
    }    
}

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;
    }  
}