Posted By

N-genhocas on 02/26/12


Tagged

edit project file java text operations labp 01 N-genhocas fcul


Versions (?)

LabP Project 01 [COMPLETO]


 / Published in: Java
 

Projecto de LabP01 que consiste na criação de uma classe que permite efectuar operações sobre ficheiros de texto.

  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.IOException;
  4. import java.util.StringTokenizer;
  5.  
  6. public class FileTools {
  7.  
  8.  
  9. /** Metodo que remove letras de um texto
  10. *
  11. * @param orders Ficheiro que contem as letras a remover
  12. * @param in Ficheiro a ser editado
  13. * @param out Ficheiro de Saida
  14. * @throws IOException File not Found se o ficheiro de entrada nao existir
  15. */
  16. static void removeLetters( BufferedReader orders, BufferedReader in,
  17.  
  18. String orderRemove, input; //Vao guardar respectivamente as letras a remover, a frase actual
  19. StringBuilder sb = new StringBuilder(); //Vai permitir transpor as letras todas a remover do ficheiro
  20. //Para uma string
  21. StringBuilder sbout = new StringBuilder(); //Vai conter o texto final para ser escrito em ficheiro
  22.  
  23. while((orderRemove = orders.readLine()) != null){
  24.  
  25. sb.append(orderRemove);
  26.  
  27. }
  28.  
  29. orderRemove = sb.toString();
  30.  
  31. //Este ciclo corre o ficheiro de entrada ate ao fim
  32. while((input = in.readLine()) != null){
  33. //Este ciclo corre todos os carateres da linha actual do ficheiro de entrada
  34. for(int i = 0; i < input.length(); i++){
  35.  
  36. int flag = 0;
  37. //Corre o ficheiro de ordens para cada letra do de entrada
  38. for(int j = 0; j < orderRemove.length() ; j++){
  39. //Se a letra do ficheiro de entrada na posicao j
  40. //corresponder a uma letra existente no ficheiro
  41. //de orders incrementa-se a flag
  42. if(input.charAt(i) == orderRemove.charAt(j) ){
  43.  
  44. flag++;
  45. }
  46. }
  47. //Se a flag for zero, significa que a letra nao estava no
  48. //ficheiro, logo adiciona-se ao SB
  49. if(flag == 0){
  50. sbout.append(input.charAt(i));
  51. }
  52. }
  53. sbout.append("\n"); //Dá o paragrafo
  54.  
  55. }
  56. //Escreve tudo para o ficheiro
  57. out.write(sbout.toString());
  58. //System.out.print(sbout.toString());
  59.  
  60. }
  61.  
  62. /** Metodo que capitaliza o texto de entrada de acordo com as ordens fornecidas num ficheiro orders
  63. *
  64. * @param orders Ficheiro que contem a ordem de capitalizacao
  65. * @param in Ficheiro de entrada
  66. * @param out Ficheiro editado
  67. * @throws IOException File not Found se não existir o ficheiro de entrada pedido
  68. */
  69. static void capitalize( BufferedReader orders, BufferedReader in,
  70.  
  71. String input,output = "";
  72. int orderCapitalize;
  73.  
  74. StringBuilder sb = new StringBuilder();
  75. StringBuilder sbout = new StringBuilder();
  76.  
  77. sb.append(orders.readLine());
  78. orderCapitalize = Integer.parseInt(sb.toString());
  79.  
  80. if(orderCapitalize == 0){
  81. //Tudo em minusculas
  82. while((input = in.readLine()) != null){
  83.  
  84. //System.out.print(output.concat(input.toLowerCase()+"\n"));
  85. out.write(output.concat(input.toLowerCase()+"\n"));
  86. }
  87. }
  88.  
  89. if(orderCapitalize == 1){
  90. //Tudo em maiusculas
  91. while((input = in.readLine()) != null){
  92.  
  93. //System.out.print(output.concat(input.toUpperCase()+"\n"));
  94. out.write(output.concat(input.toUpperCase()+"\n"));
  95.  
  96. }
  97. }
  98.  
  99. if(orderCapitalize == 2){
  100. //A primeira letra de Cada frase e maiuscula
  101. while((input = in.readLine()) != null){
  102. //ciclo que percorre cada caracter por linha
  103.  
  104. int posix=0;
  105. for(int i = 0; i < input.length(); i++){
  106.  
  107. //Se o caracter nao for um .
  108. if(input.charAt(i) != '.'){
  109.  
  110. //Se diferente de posix manter a capitalizacao minuscula
  111. if(i != posix)
  112. sbout.append(input.charAt(i));
  113. //Adiciona a primeira letra da linha
  114. if(i==0)
  115. sbout.append(input.toUpperCase().charAt(i));
  116.  
  117. //Se for um ponto
  118. }else{
  119. //Guarda a posicao da letra certa a capitalizar
  120. posix = i+2;
  121.  
  122. //Adicioma o espaço
  123. sbout.append(input.charAt(i));
  124.  
  125. }
  126.  
  127. //Quando o i chega a posicao posix capitaliza a letra
  128. if( i == posix && i != 0){
  129.  
  130. sbout.append(input.toUpperCase().charAt(i));
  131. }
  132.  
  133. }
  134. //Dá o pararagrafo a cada linha do ficheiro (senao fica tdo em frente)
  135. sbout.append("\n");
  136. }
  137.  
  138. }
  139. //System.out.println(sbout.toString()); //Linha de codigo para debugging
  140. out.write(sbout.toString());
  141. }
  142.  
  143. /** Metodo que conta o numero de ocorrencias de todas as palavras e ordena-as por ordem decrescente
  144. *
  145. * @param in Ficheiro de entrada
  146. * @param out Ficheiro com o histograma
  147. * @throws IOException File not Found se o ficheiro de entrada não existir
  148. */
  149. static void histogram( BufferedReader in, BufferedWriter out ) throws IOException{
  150.  
  151.  
  152. int[]frequencia = new int[1000]; //Conta a frequencia das palavras
  153. String[]linha = new String[1000]; //Stores the words already without repetition (filtered)
  154. String input, temp; //input recebe linha do ficheiro, temp serve para analise de length
  155.  
  156. StringBuilder sb = new StringBuilder();
  157.  
  158. //Coloca as frases do ficheironum stringbuilder formatadas para n ter maisculas
  159. while((input = in.readLine()) != null){
  160.  
  161. sb.append(input.toLowerCase().replaceAll("[^a-z]", "\n"));
  162.  
  163. }
  164. //Permite contar com facilidade o numero de palavras por linha [xx.countTokens();]
  165. StringTokenizer st = new StringTokenizer(sb.toString());
  166.  
  167. //Cria um array de strings com a quantidade de palavras certa por linha
  168. String[]inputText = new String[st.countTokens()];
  169.  
  170. //Coloca as palavras do ficheiro num vector
  171. for(int i = 0; i < inputText.length; i++){
  172.  
  173. //guarda o token corrente para se poder efectuar ops sobre ele caso contrario st.nextToken()
  174. //invoca o promixo e nao se pode retirar por exemplo o tamanho do actual
  175. temp = st.nextToken();
  176.  
  177. //Se essa palavra tiver comprimento maior que um agrega ao array
  178. if(temp.length() > 1){
  179. inputText[i] = temp;
  180. //Caso contrario Guarda NODATA no array para nao ficar null
  181. }else{
  182. inputText[i] = "NODATA";
  183. }
  184. }
  185.  
  186. //Este ciclo corre o vector onde vao ser armazenadas as palavras
  187. for(int j=0; j < linha.length; j++){
  188.  
  189. //Este ciclo percorre o vector de TODAS AS PALAVRAS
  190. for (int i = 0; i < inputText.length; i++) {
  191.  
  192. //Procura a proxima pos no vector que nao esteja a branco
  193. if(inputText[i]!="NODATA"){
  194.  
  195. //Atribui a proxima palavra localizada a posicao actual do vector
  196. linha[j]= inputText[i];
  197.  
  198. break;
  199. }
  200.  
  201. }
  202.  
  203. if(linha[j] != null){
  204.  
  205. //Guarda a frequencia da palavra no respectivo lugar
  206. frequencia[j] = contaPalavra(inputText, linha[j]);
  207.  
  208. //Apaga essa palavra do array
  209. apagaPalavra(inputText, linha[j]);
  210. }
  211. }
  212.  
  213. //Imprime no ficheiro as cenas todas ordenadinhas
  214. out.write(buildHistogram(frequencia, linha).toString());
  215.  
  216. }
  217.  
  218. /** Metodo que conta a ocorrencia de uma determinada palavra
  219. *
  220. * @param arrayString Array de Strings
  221. * @param palavra Palavra a verificar ocorrencia
  222. * @return Quantidade de vezes que ocorre a palavra no vector
  223. */
  224. private static int contaPalavra(String[] arrayString, String palavra){
  225.  
  226. int quantidade=0;
  227.  
  228. for (int k = 0; k < arrayString.length; k++) {
  229.  
  230. if(palavra.contentEquals(arrayString[k])){
  231. quantidade++;
  232. }
  233. }
  234.  
  235. return quantidade;
  236. }
  237.  
  238. /** Metodo que apaga todas as ocorrencias de uma palavra num vector
  239. *
  240. * @param arrayString Array com todas as palavras
  241. * @param palavra Palavra a eliminar
  242. */
  243. private static void apagaPalavra(String[] arrayString, String palavra){
  244.  
  245. for (int l = 0; l < arrayString.length; l++) {
  246.  
  247. if(palavra.contentEquals(arrayString[l])){
  248. arrayString[l]="NODATA";
  249. }
  250.  
  251. }
  252. }
  253.  
  254. /** Metodo que imprime que constroi o histograma ordenado
  255. *
  256. * @param array Array de inteiros correspondente às frequencias
  257. * @param linha Array que contem as palavras
  258. * @return Um objecto do tipo StringBuilder com o histograma ordenado e pronto a imprimir
  259. */
  260. public static StringBuilder buildHistogram(int[] array, String[] linha){
  261.  
  262. StringBuilder sbout = new StringBuilder();
  263. int[]pos = new int [array.length]; //Guarda a posicao relativa do valor da freq de uma certa palavra
  264. int temp, posTemp;
  265.  
  266. for (int k = 0; k < pos.length; k++) {
  267.  
  268. pos[k]=k;
  269. }
  270.  
  271. for (int j = 0; j < array.length; j++) {
  272.  
  273. for (int i = 1; i < array.length; i++){
  274.  
  275. if(array[i] > array[i-1]){
  276.  
  277. //Ordena as frequencias por ordem decrescente
  278. temp = array[i-1];
  279. array[i-1] = array[i];
  280. array[i] = temp;
  281.  
  282. //Mantém o valor do index ordenado para que a frequencia certa
  283. //condiga com a palavra certa
  284. posTemp = pos[i-1];
  285. pos[i-1] = pos[i];
  286. pos[i] = posTemp;
  287. }
  288.  
  289. }
  290. }
  291.  
  292. //Ciclo que imprime as palavras + a sua frequencia
  293. for (int i = 0; i < pos.length; i++) {
  294.  
  295. //Impede que apareca escrito null no ficheiro e zeros
  296. if(linha [i] != null && array[i] != 0){
  297.  
  298. sbout.append(linha[pos[i]]+":"+array[i]+"\n");
  299. //System.out.println(linha[pos[i]]+":"+array[i]);
  300. //out.write(linha[pos[i]]+":"+array[i]+"\n");
  301. }
  302. }
  303. return sbout;
  304.  
  305.  
  306.  
  307. }
  308.  
  309. }

Report this snippet  

You need to login to post a comment.