LabP Project 01 [COMPLETO]


/ Published in: Java
Save to your folder(s)

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


Copy this code and paste it in your HTML
  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


Comments

RSS Icon Subscribe to comments

You need to login to post a comment.