Return to Snippet

Revision: 55876
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
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
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