Importar e manipular txt em Java

Programação Java
#1

Galera sou novo em java e estou com um problema em logica eu acho , tenho um arquivo txt , estou importando ele linha a linha , porem eu queria manter todo o arquivo no meu codigo para poder fazer soma das colunas, ordenar e fazer calculos em cima dos numeros e depois exportar os dados como por exemplo em ordem crescente … somente o total … porem nao estou conseguindo arrumar um jeito de manter todo as linhas do aruqivo para manipulalas, alguem consegue me ajudar ?
o arquivo contem :
sp,81.262,3.250,70.561
rj,94.119,4.287,6.007
bh,35.713,2.978,4.025
mn,17.147,767,1.107
pb,15.147,767,1.107

o modo que esta meu codigo ateh o momento eu soh conseguir somar os registros a cada looping, porem nao consigo ordenalos ou ateh mesmo organizalos para exportacao .

package packteste;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class testeimpor {

public static void main(String[] args) {

	String path = "c:\\brasil.txt";

	String linha;
	int mundInfect = 0;
	int mundFal = 0;
	int mundCur = 0;
	String teste1;
	String teste2;
	String teste3;

	try {
		FileInputStream arquivo = new FileInputStream(path);
		InputStreamReader input = new InputStreamReader(arquivo);
		BufferedReader br = new BufferedReader(input);

		do {
			linha = br.readLine();

			if (linha != null) {
				String[] linhaCompleta = linha.split(",");

				for (int i = 0; i < linhaCompleta.length; i++) {
					if (i == 1) {
						mundInfect += Integer.parseInt(linhaCompleta[1].replace(".", ""));
					}
					if (i == 2) {
						mundFal += Integer.parseInt(linhaCompleta[2].replace(".", ""));
					}
					if (i == 3) {
						mundCur += Integer.parseInt(linhaCompleta[3].replace(".", ""));
					}
				}

				System.out.println(linha);

			}

		} while (linha != null);

	} catch (Exception e) {
		System.out.println("Error : " + e.getMessage());
	}

	System.out.println("tot infectados" + mundInfect);
	System.out.println("tot falecidos" + mundFal);
	System.out.println("tot curados" + mundCur);

}

}

#2

Ao invés de fazer a soma direto dentro do seu for, vc deveria armazenar os dados num ArrayList para processá-los depois.

Ficaria mais fácil se vc criasse uma classe para representar cada linha do seu arquivo. Algo como:

class Estado {
  final String estado;
  final int infectados;
  final int falecidos;
  final int curados;
}

Eu fiz um exemplo completo:

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Scanner;

public class App3 {
  static class Estado {
    final String estado;
    final int infectados;
    final int falecidos;
    final int curados;

    Estado(final String estado, final int infectados, final int falecidos, final int curados) {
      this.estado = estado;
      this.infectados = infectados;
      this.falecidos = falecidos;
      this.curados = curados;
    }

    @Override
    public String toString() {
      final String fmt = "Estado[estado=%s, infectados=%d, falecidos=%d, curados=%d]";
      return String.format(fmt, this.estado, this.infectados, this.falecidos, this.curados);
    }
  }

  public static void main(String... args) {
    final Locale locale = Locale.forLanguageTag("pt-BR");
    final Path path = Paths.get("C:", "brasil.txt");

    try (final Scanner scan = new Scanner(path).useLocale(locale).useDelimiter("[,\n]")) {
      final List<Estado> estados = new ArrayList<>();

      while (scan.hasNext()) {
        estados.add(new Estado(scan.next(), scan.nextInt(), scan.nextInt(), scan.nextInt()));
      }

      // A partir daqui vc faz o que quiser com estados.

      estados.forEach(estado -> System.out.println(estado));

    } catch (final IOException e) {
      e.printStackTrace();
    }
  }
}

E se vc usar as streams do Java 8, poderia ficar mais elegante, veja:

public static void main(String... args) throws IOException {
  final List<Estado> estados = Files.lines(Paths.get("C:", "brasil.txt")).map(line -> {
    try (final Scanner scan = new Scanner(line).useLocale(Locale.forLanguageTag("pt-BR")).useDelimiter(",")) {
      return new Estado(scan.next(), scan.nextInt(), scan.nextInt(), scan.nextInt());
    }
  }).collect(Collectors.toList());

  // A partir daqui vc faz o que quiser com estados como ordenar por curados.

  estados.sort((a, b) -> Integer.compare(b.curados, a.curados));

  System.out.println(estados.get(0));
}

E vc poderia ir mais longe e criar seu proprio Collector para reunir os dados que vc precisa, veja:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Locale;
import java.util.Scanner;
import java.util.function.Consumer;
import java.util.stream.Collector;

public class App2 {
  static class Estado {
    final String estado;
    final int infectados;
    final int falecidos;
    final int curados;

    Estado(final String estado, final int infectados, final int falecidos, final int curados) {
      this.estado = estado;
      this.infectados = infectados;
      this.falecidos = falecidos;
      this.curados = curados;
    }

    @Override
    public String toString() {
      final String fmt = "Estado[estado=%s, infectados=%d, falecidos=%d, curados=%d]";
      return String.format(fmt, this.estado, this.infectados, this.falecidos, this.curados);
    }
  }

  static class ResumoPorEstado implements Consumer<Estado> {
    private static final Estado MAX = new Estado("--", Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
    private static final Estado MIN = new Estado("--", Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);

    private Estado maxInfectados = MAX;
    private Estado maxCurados = MAX;
    private Estado maxFalecidos = MAX;

    private Estado minInfectados = MIN;
    private Estado minCurados = MIN;
    private Estado minFalecidos = MIN;

    private int totalInfectados;
    private int totalCurados;
    private int totalFalecidos;

    private int quantidade;

    @Override
    public void accept(Estado t) {
      ++this.quantidade;
      this.totalInfectados += t.infectados;
      this.totalCurados += t.curados;
      this.totalFalecidos += t.falecidos;

      if (this.maxCurados.curados < t.curados)
        this.maxCurados = t;

      if (this.maxFalecidos.falecidos < t.falecidos)
        this.maxFalecidos = t;

      if (this.maxInfectados.infectados < t.infectados)
        this.maxInfectados = t;

      if (this.minCurados.curados > t.curados)
        this.minCurados = t;

      if (this.minFalecidos.falecidos > t.falecidos)
        this.minFalecidos = t;

      if (this.minInfectados.infectados > t.infectados)
        this.minInfectados = t;
    }

    public ResumoPorEstado combine(final ResumoPorEstado other) {
      this.quantidade += other.quantidade;
      this.totalInfectados += other.totalInfectados;
      this.totalCurados += other.totalCurados;
      this.totalFalecidos += other.totalFalecidos;

      if (this.maxCurados.curados < other.maxCurados.curados)
        this.maxCurados = other.maxCurados;

      if (this.maxFalecidos.falecidos < other.maxFalecidos.falecidos)
        this.maxFalecidos = other.maxFalecidos;

      if (this.maxInfectados.infectados < other.maxInfectados.infectados)
        this.maxInfectados = other.maxInfectados;

      if (this.minCurados.curados > other.minCurados.curados)
        this.minCurados = other.minCurados;

      if (this.minFalecidos.falecidos > other.minFalecidos.falecidos)
        this.minFalecidos = other.minFalecidos;

      if (this.minInfectados.infectados > other.minInfectados.infectados)
        this.minInfectados = other.minInfectados;

      return this;
    }

    @Override
    public String toString() {
      final String curados = String.format("Estado com maior/menor número de curados   : %s (%5d) / %s (%5d)\n",
          maxCurados.estado, maxCurados.curados, minCurados.estado, minCurados.curados);

      final String infectados = String.format("Estado com maior/menor número de infectados: %s (%5d) / %s (%5d)\n",
          maxInfectados.estado, maxInfectados.infectados, minInfectados.estado, minInfectados.infectados);

      final String falecidos = String.format("Estado com maior/menor número de falecidos : %s (%5d) / %s (%5d)\n",
          maxFalecidos.estado, maxFalecidos.falecidos, minFalecidos.estado, minFalecidos.falecidos);

      final String total = String.format("\nTotais:\n\tCurados   : %7d\n\tInfectados: %7d\n\tFalecidos : %7d\n",
          totalCurados, totalInfectados, totalFalecidos);

      final String media = String.format(
          "\nMédias:\n\tCurados   : %10.3f\n\tInfectados: %10.3f\n\tFalecidos : %10.3f\n",
          (float) totalCurados / quantidade, (float) totalInfectados / quantidade, (float) totalFalecidos / quantidade);

      return curados + infectados + falecidos + total + media;
    }

    public static Collector<Estado, ?, ResumoPorEstado> newCollector() {
      return Collector.of(ResumoPorEstado::new, ResumoPorEstado::accept, ResumoPorEstado::combine);
    }
  }

  public static void main(String... args) throws IOException {
    final ResumoPorEstado resumo = Files.lines(Paths.get("C:", "brasil.txt")).map(line -> {
      try (final Scanner scan = new Scanner(line).useLocale(Locale.forLanguageTag("pt-BR")).useDelimiter(",")) {
        return new Estado(scan.next(), scan.nextInt(), scan.nextInt(), scan.nextInt());
      }
    }).collect(ResumoPorEstado.newCollector());

    System.out.println(resumo);
  }
}
1 curtida
#3

man , demorei um pouco para entender tudo o codigo mas eu entendi kkkkkkkk …
ficou muito mais simples que eu o meu criando outra classe e centralizando la os registros …
estou com um problema para somar agora… criar dentro da classe estado …

int  SomaTotalInfectados(){
	 
	return totInf += this.infectados;
}

porem quando vou chamar o resultado na principal ele aparece zerado … ele nao pega o resultado uqe foi armazenado na classe…
eu tenho que fazer algumas somas… ordenacao e depois vou colocar eles ordenados e a soma em um .TXT …
quando estou chamado o metodo ele esta vindo zerado … coloquei ele assim …

Estado est = new Estado();

		int testesoma  = est.SomaTotalInfectados();
		System.out.println(testesoma);

poderia me ajudar com isso ???

#4

Eu não acho legal vc fazer essa soma dentro da classe Estado. Para fazer a soma de forma fácil vc poderia fazer assim:

try (final Scanner scan = new Scanner(path).useLocale(locale).useDelimiter("[,\n]")) {
  final List<Estado> estados = new ArrayList<>();

  while (scan.hasNext()) {
    estados.add(new Estado(scan.next(), scan.nextInt(), scan.nextInt(), scan.nextInt()));
  }

  // Faz a soma usando streams
  int totalDeInfectados = estados.stream().mapToInt(e -> e.infectados).sum();

  System.out.println(totalDeInfectados);

} catch (final IOException e) {
  e.printStackTrace();
}

Mas se vc realmente quiser ir por este caminho de somar dentro de Estado, vai precisa de uma variável estática. Poderia ser assim:

public class App3 {
  static class Estado {
    final String estado;
    final int infectados;
    final int falecidos;
    final int curados;

    private static int totalInfectados;
    private static int totalFalecidos;
    private static int totalCurados;

    Estado(final String estado, final int infectados, final int falecidos, final int curados) {
      this.estado = estado;
      this.infectados = infectados;
      this.falecidos = falecidos;
      this.curados = curados;

      totalInfectados += infectados;
      totalFalecidos += falecidos;
      totalCurados += curados;
    }

    static int getTotalInfectados() {
      return totalInfectados;
    }

    static int getTotalCurados() {
      return totalCurados;
    }

    static int getTotalFalecidos() {
      return totalFalecidos;
    }
  }

  public static void main(String... args) {
    Estado a = new Estado("SP", 1, 2, 3);
    Estado b = new Estado("RJ", 4, 5, 6);
    Estado c = new Estado("AM", 7, 8, 9);

    System.out.println(Estado.getTotalCurados());
    System.out.println(Estado.getTotalFalecidos());
    System.out.println(Estado.getTotalInfectados());
  }
}