Revision: 55876
Updated Code
at February 27, 2012 18:51 by N-genhocas
Updated Code
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.util.StringTokenizer;
public class FileTools {
/** Metodo que remove letras de um texto
*
* @param orders Ficheiro que contem as letras a remover
* @param in Ficheiro a ser editado
* @param out Ficheiro de Saida
* @throws IOException File not Found se o ficheiro de entrada nao existir
*/
static void removeLetters( BufferedReader orders, BufferedReader in,
BufferedWriter out ) throws IOException{
String orderRemove, input; //Vao guardar respectivamente as letras a remover, a frase actual
StringBuilder sb = new StringBuilder(); //Vai permitir transpor as letras todas a remover do ficheiro
//Para uma string
StringBuilder sbout = new StringBuilder(); //Vai conter o texto final para ser escrito em ficheiro
while((orderRemove = orders.readLine()) != null){
sb.append(orderRemove);
}
orderRemove = sb.toString();
//Este ciclo corre o ficheiro de entrada ate ao fim
while((input = in.readLine()) != null){
//Este ciclo corre todos os carateres da linha actual do ficheiro de entrada
for(int i = 0; i < input.length(); i++){
int flag = 0;
//Corre o ficheiro de ordens para cada letra do de entrada
for(int j = 0; j < orderRemove.length() ; j++){
//Se a letra do ficheiro de entrada na posicao j
//corresponder a uma letra existente no ficheiro
//de orders incrementa-se a flag
if(input.charAt(i) == orderRemove.charAt(j) ){
flag++;
}
}
//Se a flag for zero, significa que a letra nao estava no
//ficheiro, logo adiciona-se ao SB
if(flag == 0){
sbout.append(input.charAt(i));
}
}
sbout.append("\n"); //Dá o paragrafo
}
//Escreve tudo para o ficheiro
out.write(sbout.toString());
//System.out.print(sbout.toString());
}
/** Metodo que capitaliza o texto de entrada de acordo com as ordens fornecidas num ficheiro orders
*
* @param orders Ficheiro que contem a ordem de capitalizacao
* @param in Ficheiro de entrada
* @param out Ficheiro editado
* @throws IOException File not Found se não existir o ficheiro de entrada pedido
*/
static void capitalize( BufferedReader orders, BufferedReader in,
BufferedWriter out ) throws IOException{
String input,output = "";
int orderCapitalize;
StringBuilder sb = new StringBuilder();
StringBuilder sbout = new StringBuilder();
sb.append(orders.readLine());
orderCapitalize = Integer.parseInt(sb.toString());
if(orderCapitalize == 0){
//Tudo em minusculas
while((input = in.readLine()) != null){
//System.out.print(output.concat(input.toLowerCase()+"\n"));
out.write(output.concat(input.toLowerCase()+"\n"));
}
}
if(orderCapitalize == 1){
//Tudo em maiusculas
while((input = in.readLine()) != null){
//System.out.print(output.concat(input.toUpperCase()+"\n"));
out.write(output.concat(input.toUpperCase()+"\n"));
}
}
if(orderCapitalize == 2){
//A primeira letra de Cada frase e maiuscula
while((input = in.readLine()) != null){
//ciclo que percorre cada caracter por linha
int posix=0;
for(int i = 0; i < input.length(); i++){
//Se o caracter nao for um .
if(input.charAt(i) != '.'){
//Se diferente de posix manter a capitalizacao minuscula
if(i != posix)
sbout.append(input.charAt(i));
//Adiciona a primeira letra da linha
if(i==0)
sbout.append(input.toUpperCase().charAt(i));
//Se for um ponto
}else{
//Guarda a posicao da letra certa a capitalizar
posix = i+2;
//Adicioma o espaço
sbout.append(input.charAt(i));
}
//Quando o i chega a posicao posix capitaliza a letra
if( i == posix && i != 0){
sbout.append(input.toUpperCase().charAt(i));
}
}
//Dá o pararagrafo a cada linha do ficheiro (senao fica tdo em frente)
sbout.append("\n");
}
}
//System.out.println(sbout.toString()); //Linha de codigo para debugging
out.write(sbout.toString());
}
/** Metodo que conta o numero de ocorrencias de todas as palavras e ordena-as por ordem decrescente
*
* @param in Ficheiro de entrada
* @param out Ficheiro com o histograma
* @throws IOException File not Found se o ficheiro de entrada não existir
*/
static void histogram( BufferedReader in, BufferedWriter out ) throws IOException{
int[]frequencia = new int[1000]; //Conta a frequencia das palavras
String[]linha = new String[1000]; //Stores the words already without repetition (filtered)
String input, temp; //input recebe linha do ficheiro, temp serve para analise de length
StringBuilder sb = new StringBuilder();
//Coloca as frases do ficheironum stringbuilder formatadas para n ter maisculas
while((input = in.readLine()) != null){
sb.append(input.toLowerCase().replaceAll("[^a-z]", "\n"));
}
//Permite contar com facilidade o numero de palavras por linha [xx.countTokens();]
StringTokenizer st = new StringTokenizer(sb.toString());
//Cria um array de strings com a quantidade de palavras certa por linha
String[]inputText = new String[st.countTokens()];
//Coloca as palavras do ficheiro num vector
for(int i = 0; i < inputText.length; i++){
//guarda o token corrente para se poder efectuar ops sobre ele caso contrario st.nextToken()
//invoca o promixo e nao se pode retirar por exemplo o tamanho do actual
temp = st.nextToken();
//Se essa palavra tiver comprimento maior que um agrega ao array
if(temp.length() > 1){
inputText[i] = temp;
//Caso contrario Guarda NODATA no array para nao ficar null
}else{
inputText[i] = "NODATA";
}
}
//Este ciclo corre o vector onde vao ser armazenadas as palavras
for(int j=0; j < linha.length; j++){
//Este ciclo percorre o vector de TODAS AS PALAVRAS
for (int i = 0; i < inputText.length; i++) {
//Procura a proxima pos no vector que nao esteja a branco
if(inputText[i]!="NODATA"){
//Atribui a proxima palavra localizada a posicao actual do vector
linha[j]= inputText[i];
break;
}
}
if(linha[j] != null){
//Guarda a frequencia da palavra no respectivo lugar
frequencia[j] = contaPalavra(inputText, linha[j]);
//Apaga essa palavra do array
apagaPalavra(inputText, linha[j]);
}
}
//Imprime no ficheiro as cenas todas ordenadinhas
out.write(buildHistogram(frequencia, linha).toString());
}
/** Metodo que conta a ocorrencia de uma determinada palavra
*
* @param arrayString Array de Strings
* @param palavra Palavra a verificar ocorrencia
* @return Quantidade de vezes que ocorre a palavra no vector
*/
private static int contaPalavra(String[] arrayString, String palavra){
int quantidade=0;
for (int k = 0; k < arrayString.length; k++) {
if(palavra.contentEquals(arrayString[k])){
quantidade++;
}
}
return quantidade;
}
/** Metodo que apaga todas as ocorrencias de uma palavra num vector
*
* @param arrayString Array com todas as palavras
* @param palavra Palavra a eliminar
*/
private static void apagaPalavra(String[] arrayString, String palavra){
for (int l = 0; l < arrayString.length; l++) {
if(palavra.contentEquals(arrayString[l])){
arrayString[l]="NODATA";
}
}
}
/** Metodo que imprime que constroi o histograma ordenado
*
* @param array Array de inteiros correspondente às frequencias
* @param linha Array que contem as palavras
* @return Um objecto do tipo StringBuilder com o histograma ordenado e pronto a imprimir
*/
public static StringBuilder buildHistogram(int[] array, String[] linha){
StringBuilder sbout = new StringBuilder();
int[]pos = new int [array.length]; //Guarda a posicao relativa do valor da freq de uma certa palavra
int temp, posTemp;
for (int k = 0; k < pos.length; k++) {
pos[k]=k;
}
for (int j = 0; j < array.length; j++) {
for (int i = 1; i < array.length; i++){
if(array[i] > array[i-1]){
//Ordena as frequencias por ordem decrescente
temp = array[i-1];
array[i-1] = array[i];
array[i] = temp;
//Mantém o valor do index ordenado para que a frequencia certa
//condiga com a palavra certa
posTemp = pos[i-1];
pos[i-1] = pos[i];
pos[i] = posTemp;
}
}
}
//Ciclo que imprime as palavras + a sua frequencia
for (int i = 0; i < pos.length; i++) {
//Impede que apareca escrito null no ficheiro e zeros
if(linha [i] != null && array[i] != 0){
sbout.append(linha[pos[i]]+":"+array[i]+"\n");
//System.out.println(linha[pos[i]]+":"+array[i]);
//out.write(linha[pos[i]]+":"+array[i]+"\n");
}
}
return sbout;
}
}
Revision: 55875
Updated Code
at February 27, 2012 01:46 by N-genhocas
Updated Code
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.util.StringTokenizer;
public class FileTools {
/** Metodo que remove letras de um texto
*
* @param orders Ficheiro que contem as letras a remover
* @param in Ficheiro a ser editado
* @param out Ficheiro de Saida
* @throws IOException File not Found se o ficheiro de entrada nao existir
*/
static void removeLetters( BufferedReader orders, BufferedReader in,
BufferedWriter out ) throws IOException{
String orderRemove, input; //Vao guardar respectivamente as letras a remover, a frase actual
StringBuilder sb = new StringBuilder(); //Vai permitir transpor as letras todas a remover do ficheiro
//Para uma string
StringBuilder sbout = new StringBuilder(); //Vai conter o texto final para ser escrito em ficheiro
while((orderRemove = orders.readLine()) != null){
sb.append(orderRemove);
}
orderRemove = sb.toString();
//Este ciclo corre o ficheiro de entrada ate ao fim
while((input = in.readLine()) != null){
//Este ciclo corre todos os carateres da linha actual do ficheiro de entrada
for(int i = 0; i < input.length(); i++){
int flag = 0;
//Corre o ficheiro de ordens para cada letra do de entrada
for(int j = 0; j < orderRemove.length() ; j++){
//Se a letra do ficheiro de entrada na posicao j corresponder a uma letra existente no ficheiro
//de orders incrementa-se a flag
if(input.charAt(i) == orderRemove.charAt(j) ){
flag++;
}
}
//Se a flag for zero, significa que a letra nao estava no ficheiro, logo adiciona-se ao SB
if(flag == 0){
sbout.append(input.charAt(i));
}
}
sbout.append("\n"); //Dá o paragrafo
}
//Escreve tudo para o ficheiro
out.write(sbout.toString());
//System.out.print(sbout.toString());
}
/** Metodo que capitaliza o texto de entrada de acordo com as ordens fornecidas num ficheiro orders
*
* @param orders Ficheiro que contem a ordem de capitalizacao
* @param in Ficheiro de entrada
* @param out Ficheiro editado
* @throws IOException File not Found se não existir o ficheiro de entrada pedido
*/
static void capitalize( BufferedReader orders, BufferedReader in,
BufferedWriter out ) throws IOException{
String input,output = "";
int orderCapitalize;
StringBuilder sb = new StringBuilder();
StringBuilder sbout = new StringBuilder();
sb.append(orders.readLine());
orderCapitalize = Integer.parseInt(sb.toString());
if(orderCapitalize == 0){
//Tudo em maiusculas
while((input = in.readLine()) != null){
//System.out.print(output.concat(input.toLowerCase()+"\n"));
out.write(output.concat(input.toLowerCase()+"\n"));
}
}
if(orderCapitalize == 1){
//Tudo em minusculas
while((input = in.readLine()) != null){
//System.out.print(output.concat(input.toUpperCase()+"\n"));
out.write(output.concat(input.toUpperCase()+"\n"));
}
}
if(orderCapitalize == 2){
//A primeira letra de Cada frase e maiuscula
while((input = in.readLine()) != null){
//ciclo que percorre cada caracter por linha
int posix=0;
for(int i = 0; i < input.length(); i++){
//Se o caracter nao for um .
if(input.charAt(i) != '.'){
//Se diferente de posix manter a capitalizacao minuscula
if(i != posix)
sbout.append(input.charAt(i));
//Adiciona a primeira letra da linha
if(i==0)
sbout.append(input.toUpperCase().charAt(i));
//Se for um ponto
}else{
//Guarda a posicao da letra certa a capitalizar
posix = i+2;
//Adicioma o espaço
sbout.append(input.charAt(i));
}
//Quando o i chega a posicao posix capitaliza a letra
if( i == posix && i != 0){
sbout.append(input.toUpperCase().charAt(i));
}
}
//Dá o pararagrafo a cada linha do ficheiro (senao fica tdo em frente)
sbout.append("\n");
}
}
//System.out.println(sbout.toString()); //Linha de codigo para debugging
out.write(sbout.toString());
}
/** Metodo que conta o numero de ocorrencias de todas as palavras e ordena-as por ordem decrescente
*
* @param in Ficheiro de entrada
* @param out Ficheiro com o histograma
* @throws IOException File not Found se o ficheiro de entrada não existir
*/
static void histogram( BufferedReader in, BufferedWriter out ) throws IOException{
int[]frequencia = new int[1000]; //Conta a frequencia das palavras
String[]linha = new String[1000]; //Stores the words already without repetition (filtered)
String input, temp; //input recebe linha do ficheiro, temp serve para analise de length
StringBuilder sb = new StringBuilder();
//Coloca as frases do ficheironum stringbuilder formatadas para n ter maisculas
while((input = in.readLine()) != null){
sb.append(input.toLowerCase().replaceAll("[^a-z]", "\n"));
}
//Permite contar com facilidade o numero de palavras por linha [xx.countTokens();]
StringTokenizer st = new StringTokenizer(sb.toString());
//Cria um array de strings com a quantidade de palavras certa por linha
String[]inputText = new String[st.countTokens()];
//Coloca as palavras do ficheiro num vector
for(int i = 0; i < inputText.length; i++){
//guarda o token corrente para se poder efectuar ops sobre ele caso contrario st.nextToken()
//invoca o promixo e nao se pode retirar por exemplo o tamanho do actual
temp = st.nextToken();
//Se essa palavra tiver comprimento maior que um agrega ao array
if(temp.length() > 1){
inputText[i] = temp;
//Caso contrario Guarda NODATA no array para nao ficar null
}else{
inputText[i] = "NODATA";
}
}
//Este ciclo corre o vector onde vao ser armazenadas as palavras
for(int j=0; j < linha.length; j++){
//Este ciclo percorre o vector de TODAS AS PALAVRAS
for (int i = 0; i < inputText.length; i++) {
//Procura a proxima pos no vector que nao esteja a branco
if(inputText[i]!="NODATA"){
//Atribui a proxima palavra localizada a posicao actual do vector
linha[j]= inputText[i];
break;
}
}
if(linha[j] != null){
//Guarda a frequencia da palavra no respectivo lugar
frequencia[j] = contaPalavra(inputText, linha[j]);
//Apaga essa palavra do array
apagaPalavra(inputText, linha[j]);
}
}
//Imprime no ficheiro as cenas todas ordenadinhas
out.write(buildHistogram(frequencia, linha).toString());
}
/** Metodo que conta a ocorrencia de uma determinada palavra
*
* @param arrayString Array de Strings
* @param palavra Palavra a verificar ocorrencia
* @return Quantidade de vezes que ocorre a palavra no vector
*/
private static int contaPalavra(String[] arrayString, String palavra){
int quantidade=0;
for (int k = 0; k < arrayString.length; k++) {
if(palavra.contentEquals(arrayString[k])){
quantidade++;
}
}
return quantidade;
}
/** Metodo que apaga todas as ocorrencias de uma palavra num vector
*
* @param arrayString Array com todas as palavras
* @param palavra Palavra a eliminar
*/
private static void apagaPalavra(String[] arrayString, String palavra){
for (int l = 0; l < arrayString.length; l++) {
if(palavra.contentEquals(arrayString[l])){
arrayString[l]="NODATA";
}
}
}
/** Metodo que imprime que constroi o histograma ordenado
*
* @param array Array de inteiros correspondente às frequencias
* @param linha Array que contem as palavras
* @return Um objecto do tipo StringBuilder com o histograma ordenado e pronto a imprimir
*/
public static StringBuilder buildHistogram(int[] array, String[] linha){
StringBuilder sbout = new StringBuilder();
int[]pos = new int [array.length]; //Guarda a posicao relativa do valor da freq de uma certa palavra
int temp, posTemp;
for (int k = 0; k < pos.length; k++) {
pos[k]=k;
}
for (int j = 0; j < array.length; j++) {
for (int i = 1; i < array.length; i++){
if(array[i] > array[i-1]){
//Ordena as frequencias por ordem decrescente
temp = array[i-1];
array[i-1] = array[i];
array[i] = temp;
//Mantém o valor do index ordenado para que a frequencia certa
//condiga com a palavra certa
posTemp = pos[i-1];
pos[i-1] = pos[i];
pos[i] = posTemp;
}
}
}
//Ciclo que imprime as palavras + a sua frequencia
for (int i = 0; i < pos.length; i++) {
//Impede que apareca escrito null no ficheiro e zeros
if(linha [i] != null && array[i] != 0){
sbout.append(linha[pos[i]]+":"+array[i]+"\n");
//System.out.println(linha[pos[i]]+":"+array[i]);
//out.write(linha[pos[i]]+":"+array[i]+"\n");
}
}
return sbout;
}
}
Revision: 55874
Initial Code
Initial URL
Initial Description
Initial Title
Initial Tags
Initial Language
at February 26, 2012 01:43 by N-genhocas
Initial Code
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.util.StringTokenizer;
public class FileTools {
static void removeLetters( BufferedReader orders, BufferedReader in,
BufferedWriter out ) throws IOException{
String orderRemove, input;
StringBuilder sb = new StringBuilder();
StringBuilder sbout = new StringBuilder();
while((orderRemove = orders.readLine()) != null){
sb.append(orderRemove);
}
orderRemove = sb.toString();
//Este ciclo corre o ficheiro de entrada ate ao fim
while((input = in.readLine()) != null){
//Este ciclo corre todos os carateres da linha actual do ficheiro de entrada
for(int i = 0; i < input.length(); i++){
int flag = 0;
//Corre o ficheiro de ordens para cada letra do de entrada
for(int j = 0; j < orderRemove.length() ; j++){
//Se a letra do ficheiro de entrada na posicao j corresponder a uma letra existente no ficheiro
//de orders incrementa-se a flag
if(input.charAt(i) == orderRemove.charAt(j) ){
flag++;
}
}
//Se a flag for zero, significa que a letra nao estava no ficheiro, logo adiciona-se ao SB
if(flag == 0){
sbout.append(input.charAt(i));
}
}
sbout.append("\n"); //Dá o paragrafo
}
//Escreve tudo para o ficheiro
out.write(sbout.toString());
//System.out.print(sbout.toString());
}
/**
*
* @param orders
* @param in
* @param out
* @throws IOException
*/
static void capitalize( BufferedReader orders, BufferedReader in,
BufferedWriter out ) throws IOException{
String input,output = "";
int orderCapitalize;
StringBuilder sb = new StringBuilder();
StringBuilder sbout = new StringBuilder();
sb.append(orders.readLine());
orderCapitalize = Integer.parseInt(sb.toString());
if(orderCapitalize == 0){
//Tudo em maiusculas
while((input = in.readLine()) != null){
//System.out.print(output.concat(input.toLowerCase()+"\n"));
out.write(output.concat(input.toLowerCase()+"\n"));
}
}
if(orderCapitalize == 1){
//Tudo em minusculas
while((input = in.readLine()) != null){
//System.out.print(output.concat(input.toUpperCase()+"\n"));
out.write(output.concat(input.toUpperCase()+"\n"));
}
}
if(orderCapitalize == 2){
//A primeira letra de Cada frase e maiuscula
while((input = in.readLine()) != null){
//ciclo que percorre cada caracter por linha
int posix=0;
for(int i = 0; i < input.length(); i++){
//Se o caracter nao for um .
if(input.charAt(i) != '.'){
//Se diferente de posix manter a capitalizacao minuscula
if(i != posix)
sbout.append(input.charAt(i));
//Adiciona a primeira letra da linha
if(i==0)
sbout.append(input.toUpperCase().charAt(i));
//Se for um ponto
}else{
//Guarda a posicao da letra a capitalizar
posix = i+2;
//Adicioma o espaço
sbout.append(input.charAt(i));
}
//Quando o i chega a posicao posix capitaliza a letra
if( i == posix && i != 0){
sbout.append(input.toUpperCase().charAt(i));
}
}
//Dá o pararagrafo a cada linha do ficheiro (senao fica tdo em frente
sbout.append("\n");
}
}
System.out.println(sbout.toString());
out.write(sbout.toString());
}
/**
*
* @param in
* @param out
* @throws IOException
*/
static void histogram( BufferedReader in, BufferedWriter out ) throws IOException{
int[]frequencia = new int[1000]; //Conta a frequencia das palavras
int[]rank = new int[1000]; //Serve para fazer o ranking das palavras 0 valor 1 pos no vector
int[]pos = new int[1000]; //Guarda a posicao correspondente do valor de rank à palavra
String[]linha = new String[1000]; //Stores the words already without repetition (filtered)
String input, temp; //input recebe linha do ficheiro, temp serve para analise de length
StringBuilder sb = new StringBuilder();
//Coloca as frases do ficheironum stringbuilder formatadas para n ter maisculas
while((input = in.readLine()) != null){
sb.append(input.toLowerCase().replaceAll("[^a-z]", "\n"));
}
StringTokenizer st = new StringTokenizer(sb.toString());
String[]inputText = new String[st.countTokens()];
//Coloca as palavras do ficheiro num vector
for(int i = 0; i < inputText.length; i++){
//guarda o token corrente para se poder efectuar ops sobre ele caso contrario st.nextToken()
//invoca o promixo e nao se pode retirar por exemplo o tamanho do actual
temp = st.nextToken();
if(temp.length() > 1){
inputText[i] = temp;
}else{
inputText[i] = "NODATA";
}
}
//Este ciclo corre o vector onde vao ser armazenadas as palavras
for(int j=0; j < linha.length; j++){
//Este ciclo percorre o vector de TODAS AS PALAVRAS
for (int i = 0; i < inputText.length; i++) {
//Procura a proxima pos no vector que nao esteja a branco
if(inputText[i]!="NODATA"){
//Atribui a proxima palavra localizada a posicao actual do vector
linha[j]= inputText[i];
break;
}
}
if(linha[j] != null){
//Guarda a frequencia da palavra no respectivo lugar
frequencia[j] = contaPalavra(inputText, linha[j]);
//Apaga essa palavra do array
apagaPalavra(inputText, linha[j]);
}
}
for(int i=0; i < linha.length; i++){
if(linha[i] != null)
//System.out.println(linha[i]+":"+frequencia[i]);
out.write((linha[i]+":"+frequencia[i]+"\n"));
}
//printWords(frequencia, rank, pos); //Arruma as palavras
}
/** Metodo que conta a ocorrencia de uma determinada palavra
*
* @param arrayString Array de Strings
* @param palavra Palavra a verificar ocorrencia
* @return Quantidade de vezes que ocorre a palavra no vector
*/
private static int contaPalavra(String[] arrayString, String palavra){
int quantidade=0;
for (int k = 0; k < arrayString.length; k++) {
if(palavra.contentEquals(arrayString[k])){
quantidade++;
}
}
return quantidade;
}
/** Metodo que apaga todas as ocorrencias de uma palavra num vector
*
* @param arrayString Array com todas as palavras
* @param palavra Palavra a eliminar
*/
private static void apagaPalavra(String[] arrayString, String palavra){
for (int l = 0; l < arrayString.length; l++) {
if(palavra.contentEquals(arrayString[l])){
arrayString[l]="NODATA";
}
}
}
/*
private static void printWords(int[]vector, int[]rank, int[]pos){
Arrays.sort(vector);
for (int i = vector.length; i == 0; i--) {
System.out.println(vector[i]);
}
//rank[i] = maximo;
//pos[i] = position;
}
//System.out.println(maximo);
*/
}
Initial URL
Initial Description
Projecto de LabP01 que consiste na criação de uma classe que permite efectuar operações sobre ficheiros de texto.
Initial Title
LabP Project 01 [COMPLETO]
Initial Tags
file, java, text
Initial Language
Java