segunda-feira, 27 de outubro de 2014

2014-2-Oda: Organizador de Arquivos Abstrato

package br.pitagoras.oda.orgarq;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import br.pitagoras.oda.orgarq.util.OrgArquivosUtil;

public abstract class OrgArquivoAbstrato {

private String nomeArquivoDados;
private String nomeArquivoIndices;

protected RegistroDeArquivo buscarEmArquivoDeDados(String chave){
RegistroDeArquivo registro = null;

        try {
BufferedReader br = new BufferedReader(new FileReader(nomeArquivoDados));
String s = br.readLine();
String colunas = null;
if (s != null){
colunas = s;
}
s = br.readLine();
while (s != null) {
if (chave.equals(s.split(";")[0])){
registro = new RegistroDeArquivo(s);
break;
}
s = br.readLine();
}
br.close();
} catch (Exception e) {
System.err.println("ERRO ao realizar a busca pela chave " + chave);
throw new RuntimeException("ERRO ao realizar a busca pela chave ", e);

return registro;
}

public void setNomeArquivoDados(String nomeArquivoDados) {
this.nomeArquivoDados = nomeArquivoDados;
}

public void setNomeArquivoIndices(String nomeArquivoIndices) {
this.nomeArquivoIndices = nomeArquivoIndices;
}

public String getNomeArquivoDados() {
return nomeArquivoDados;
}

public String getNomeArquivoIndices() {
return nomeArquivoIndices;
}

public List<RegistroDeArquivo> listarRegistros() {

List<RegistroDeArquivo> registros = new ArrayList<RegistroDeArquivo>();
RegistroDeArquivo reg = null;

try {
// Para cada registro no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
for (String s: listDados){
//   se o registro possuir o valor
reg = new RegistroDeArquivo(s);
registros.add(reg);
}
// retornar a listagem de resultados
} catch (Exception e) {
String msg = "ERRO ao tentar listar registros";
System.err.println(msg);
throw new RuntimeException(msg, e);
}

return registros;
}

public List<RegistroDeArquivo> pesquisarRegistrosEmArquivoDeDados(String valor) {

List<RegistroDeArquivo> registros = new ArrayList<RegistroDeArquivo>();
RegistroDeArquivo reg = null;

try {
// Para cada registro no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
for (String s: listDados){
//   se o registro possuir o valor
if (s.contains(valor)){
reg = new RegistroDeArquivo(s);
registros.add(reg);
}
}
// retornar a listagem de resultados
} catch (Exception e) {
String msg = "ERRO ao tentar listar registros";
System.err.println(msg);
throw new RuntimeException(msg, e);
}

return registros;
}

public List<String> listarIndices(){
try {
return OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoIndices());
} catch (Exception e) {
String msg = "ERRO ao tentar listar os indices do arquivo";
System.err.println(msg);
throw new RuntimeException(msg, e);
}
}

}

2014/2 - OdA: Organização Básica de Arquivos: Arquivo Indexado

package br.pitagoras.oda.orgarq;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import br.pitagoras.oda.orgarq.util.OrgArquivosUtil;
import br.pitagoras.oda.orgarq.util.StringUtil;

public class ProcessadorDeArquivoIndexado extends OrgArquivoAbstrato implements OrgArquivosInterface {


public ProcessadorDeArquivoIndexado(String nomeArquivoDeIndices, String nomeArquivoDeDados) {
this.setNomeArquivoDados(nomeArquivoDeDados);
this.setNomeArquivoIndices(nomeArquivoDeIndices);
System.out.println("Criando um processador de arquivo indexado . . .");
System.out.println("Arquivo de índices: " + nomeArquivoDeIndices);
System.out.println("Arquivo de dados: " + nomeArquivoDeDados);
}

String buscarNoIndice(String chave) throws FileNotFoundException, IOException{
// buscar no arquivo de indices
Map<String, String> mapaIndices = OrgArquivosUtil.obterMapaRegistrosDoArquivo(getNomeArquivoIndices());
//   obter o indice associado a chave
String indice = mapaIndices.get(chave);
// se o indice existir
return indice;
}

@Override
public RegistroDeArquivo buscar(String chave){
RegistroDeArquivo reg = null;

try {
// buscar no arquivo de indices
String indice = buscarNoIndice(chave);
// se o indice existir
if (indice != null){
//   obter o registro associado ao indice
int pos = Integer.parseInt(indice);
List<String> dadosDoArquivo = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
reg = new RegistroDeArquivo(dadosDoArquivo.get(pos));
//   retornar o registro encontrado
}
} catch (Exception e) {
String msg = "ERRO: busca pela chave " + chave;
System.err.println(msg);
throw new RuntimeException(msg, e);
}

return reg;
}

@Override
public void inserir(RegistroDeArquivo registro){

// realizar a busca pelo registro
try {
String chave = registro.getId();
String indice = buscarNoIndice(chave);
// se ele existir
if (indice != null){
//   informar que o registro já existe
System.out.println("AVISO: o registro com chave " + chave + " já existe.");
} else { // senão
//  adicionar o registro novo no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
listDados.add(registro.obterCampos());
int pos = listDados.indexOf(registro.obterCampos());
OrgArquivosUtil.escreverRegistrosEmArquivo(getNomeArquivoDados(), listDados);
System.out.println("Arquivo de dados salvo com sucesso: " + listDados.size());
// adicionar o registro novo no arquivo de indices
Map<String, String> mapaRegistros = OrgArquivosUtil.obterMapaRegistrosDoArquivo(getNomeArquivoIndices());
mapaRegistros.put(registro.getId(), String.valueOf(pos));
OrgArquivosUtil.escreverMapaRegistrosEmArquivo(getNomeArquivoIndices(), mapaRegistros);
System.out.println("Arquivo de indices salvo com sucesso: " + mapaRegistros.size());
}
} catch (Exception e) {
String msg = "ERRO ao tentar inserir um novo registro " + registro;
System.err.println(msg);
throw new RuntimeException(msg, e);
}

}

@Override
public void atualizar(String chave, String valorAtual, String valorNovo){

try {
// buscar pelo registro
String indice = buscarNoIndice(chave);
// se o registro nao for encontrado
if (indice == null){
//   mostrar mensagem de erro
} else { // senão
//   obter o registro do arquivo de dados
RegistroDeArquivo registro = buscarEmArquivoDeDados(chave);
//   atualizar o campo
registro.atualizar(valorAtual, valorNovo);
//   salvar o novo registro
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
int pos = Integer.parseInt(indice);
listDados.set(pos, registro.obterCampos());
OrgArquivosUtil.escreverRegistrosEmArquivo(getNomeArquivoDados(), listDados);
}
} catch (Exception e) {
String msg = "ERRO ao tentar atualizar um registro com chave " + chave;
System.err.println(msg);
throw new RuntimeException(msg, e);
}

}

@Override
public List<RegistroDeArquivo> pesquisar(String valor){

List<RegistroDeArquivo> registros = new ArrayList<RegistroDeArquivo>();
RegistroDeArquivo reg = null;

try {
// Para cada registro no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
for (String s: listDados){
//   se o registro possuir o valor
if (s.contains(valor)){
//     adiciona-lo na lista de resultados
reg = new RegistroDeArquivo(s);
registros.add(reg);
}
}
// retornar a listagem de resultados
} catch (Exception e) {
String msg = "ERRO ao tentar pesquisar por um registro com valor " + valor;
System.err.println(msg);
throw new RuntimeException(msg, e);
}

return registros;
}

@Override
public void excluir(String chave){
try {
// verificar se a chave existe no arquivo de indices
String indice = buscarNoIndice(chave);
// se sim
if (StringUtil.isEmpty(indice)){
System.out.println("AVISO: o registro com chave " + chave + " não existe.");
} else {
//   buscar o registro no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
int pos = Integer.parseInt(indice);
//   remover o registro do arquivo
listDados.remove(pos);
// atualizar o arquivo
OrgArquivosUtil.escreverRegistrosEmArquivo(getNomeArquivoDados(), listDados);
//   remover o registro do arquivo de indices
Map<String, String> mapaIndices = OrgArquivosUtil.obterMapaRegistrosDoArquivo(getNomeArquivoIndices());
mapaIndices.remove(chave);
OrgArquivosUtil.escreverMapaRegistrosEmArquivo(getNomeArquivoIndices(), mapaIndices);
}
} catch (Exception e) {
String msg = "ERRO ao tentar excluir um registro com chave " + chave;
System.err.println(msg);
throw new RuntimeException(msg, e);
}
}
}

quinta-feira, 25 de setembro de 2014

2014/2: AED2 - Ordenação Interna: Gerador de números aleatórios em arquivo

package br.edu.pitagoras.aed2.ordenacao;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Random;

public class GeradorNumerosAleatoriosEmArquivo {

    public static final String NOME_ARQUIVO = "numeros.txt";

    private static void escreverArquivo(int[] v) throws IOException {
        File f = new File(NOME_ARQUIVO);
        if (f.exists()) {
            f.delete();
        }
        FileOutputStream fos = new FileOutputStream(NOME_ARQUIVO);
        DataOutputStream dos = new DataOutputStream(fos);
        dos.writeInt(v.length);
        for (int element : v) {
            dos.writeInt(element);
        }
        fos.close();
        long length = new File(NOME_ARQUIVO).length();
        System.out.println("Arquivo gerado: " + length + " bytes");
    }

    public static int[] lerArquivo(String nomeArquivo) throws IOException {
        FileInputStream fis = new FileInputStream(nomeArquivo);
        DataInputStream dis = new DataInputStream(fis);
        int size = dis.readInt();
        int[] v = new int[size];
        for (int i = 0; i < size; i++) {
            v[i] = dis.readInt();
        }
        fis.close();
        System.out.println("Arquivo lido: " + size + " números");
        return v;
    }

    private static int[] gerarVetor(int tamanho, int limite) {
        int[] v = new int[tamanho];
        Random r = new Random(System.currentTimeMillis());
        for (int i = 0; i < tamanho; i++) {
            v[i] = Math.abs((r.nextInt() % limite)) + 1;
        }
        return v;
    }

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {

        int tamanho = 100000;
        int limite = 200000;
        int[] v = gerarVetor(tamanho, limite);
        System.out.println(v.length);
        escreverArquivo(v);
        v = lerArquivo(NOME_ARQUIVO);
        System.out.println(v.length);
    }

}

2014/2: Algoritmos e Lógica de Programação: Notas de Aula 24/09/2014

Trabalho Prático 1

1) Calcular a diferença entre o ano
- Positivo
2) Calcular a diferença entre o mês
- Positivo: OK
- Negativo:
  - Ano: subtrair 1 do ano
  - Mês: adicionar 12 ao valor calculado

  d1: 23/08/2014
  d2: 29/09/2010

  dx = d1 - d2
  dxa = d1a - d2a
      = 2014 - 2010 = 4
  dxa = 4 - 1 = 3

  dxm = d1m - d2m
      = 8   -  9  = -1
  dxm = 12 - 1 = 11

3) Calcular a diferença entre o dia
- Positivo: OK
- Negativo:
  - Mes: subtrair 1 do mes
  - dia: somar 30

  dxd = d1d - d2d
         23 - 29 = -6
  dxd = 30 - 6 = 24

Planos de teste
- Plano 1: datas 23/09/2014 e 10/05/2010
- Plano 2: datas com diferenca entre o mês negativa
- Plano 3: datas com diferença entre o dia negativa
- Plano 4: valores invalidos (numeros negativos, zero)



Exercícios em Sala:

Problema 1:
Entrada: um numero inteiro digitado pelo usuário (N)
Saída: exibir na tela a taboada de N

Descrição textual
1) Ler o numero do usuário
2) Para cada numero de zero a 10 (de 1 em 1)
2.1) Calcular a multiplicacao de N pelo numero
2.2) Exibir o resultado do calculo

Algoritmo estruturado
Var N, C, R: inteiro
Inicio
  Escrever "Digite um numero inteiro:"
  Ler N
  Para C De 0 Até 10 Passo 1 Faça
    R <- N * C
Escrever N " x " C "=" R
  Fim Para
Fim

Código fonte
#include <iostream>

int main(){
  int n, c, r;
  cout << "Digite um numero inteiro:";
  cin >> n;
  for (c = 0; c<=10; c++){
    r = n * c;
cout << n << " x " << c << "=" << r << endl;
  }
  return 0;
}


Problema 2
Entrada: número inteiro informado pelo usuário (N)
Saída: Apresentar todos os números divisíveis por 4
       entre zero e N

Descricao textual 1
1) Ler o numero inteiro do usuário
2) Para cada numero entre zero e N (de 1 em 1)
2.1) dividir o numero por 4
2.2) calcular o resto da divisao por 4
2.3) se o resto for zero
2.3.1) exibir o numero

Algoritmo estruturado 1
Var N, C, R: inteiro
Inicio
  Escrever "Digite um numero inteiro:"
  Ler N
  Para C De 0 Até N Passo 1 Faça
    R <- C % 4 // modulo resto da divisao
Se (R == 0) Então
 Escrever C
Fim Se
  Fim Para
Fim


Descricao textual 2
1) Ler o numero inteiro do usuário
2) Para cada numero entre zero e N (de 4 em 4)
2.1) exibir o numero


Problema 3
Entrada: letra digitada pelo usuário (a-z)
Saída: exibir a letra na tela enquanto ela for vogal,
       sair se for diferente de letra (a-z)

Descrição textual
1) Ler do usuário um caractere (a-z)
2) Enquanto o caractere for uma letra (a-z)
2.1) Se o caractere for uma vogal (a-e-i-o-u)
2.1.1) Exibir o caractere na tela
2.2) Ler do usuário um caractere (a-z)

Algoritmo Estruturado
Var C: caractere
Inicio
  Escrever "Digite um caractere: "
  Ler C
  Enquanto ((C >='A' E C <='Z') OU
(C >='a' E C <='z')) Faça
    Se (C == 'A' OU C == 'E' OU C == 'I' OU C == 'O' OU
C == 'U') Então
 Escrever C
Fim Se
    Escrever "Digite um caractere: "
    Ler C
  Fim Enquanto
Fim











quinta-feira, 4 de setembro de 2014

2014-2-AED2: Leitura de arquivo texto em Java

package br.edu.pitagoras.aed2.arquivo;

import java.io.FileInputStream;
import java.util.NoSuchElementException;
import java.util.Scanner;

public class LerArquivoTeste {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String nomeArquivo = "arq-texto.txt";

        try {
            Scanner sc = new Scanner(new FileInputStream(nomeArquivo));
            String s = sc.next();
            while (s != null) {
                s = s.replace(".", "");
                s = s.replace(",", "");
                System.out.println(s);
                s = sc.next();
            }
            sc.close();
        } catch (NoSuchElementException e) {
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

segunda-feira, 1 de setembro de 2014

2014-2-OdA: Listador de Diretórios em Java

import java.io.File;


public class ListadorArquivosDiretorio {

/**
* @param args
*/
public static void main(String[] args) {

// listar arquivos de um determinado diretorio

// 1) obter/ler o caminho absoluto do diretorio
String nomeArquivo = "c:/temp/java.rar";
File f = new File(nomeArquivo);
// 2) Se o caminho não existir
if (!f.exists()){
// 2.1) informar um erro caminho nao existe
System.out.println("ERRO: caminho não existe");
} // 3) Se o caminho nao for um diretorio (arquivo)
else if (!f.isDirectory()){
// 3.1) informar um erro caminho nao eh diretorio
System.out.println("ERRO: caminho nao eh diretorio");
} else {// 4) Caso contrário
// 4.1) Criar um objeto do tipo arquivo (File)
// 4.2) obter a listagem dos arquivos do arquivo acima
File[] lista = f.listFiles();
// 4.3) Para cada arquivo na lista
System.out.println("Listando arquivos em " + f.getAbsolutePath());
for (File a: lista){
// 4.3.1) exibir o nome do arquivo na lista
System.out.println(a.getName());
}
}//

}

}