sábado, 16 de noviembre de 2013

Contar palabras terminadas en -cion

En esta entrada del blog os presento un código para contar las palabras terminadas en -cion, aunque se podría modificar para encontrar las palabras que contienen ese patrón de letras.
CONTAR PALABRAS QUE CONTIENEN UN PATRÓN DE LETRAS.
------------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


public class cion {

/**
         * @author Alberto García
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
File archivo = new File("./ejemplo.txt");//"ejemplo.txt" es el archivo que va a leer
String linea;
FileReader fr = new FileReader (archivo);
BufferedReader br = new BufferedReader(fr);
int cont = 0;

//Mediante el siguiente bucle, vamos leyendo línea a línea, comprobando la condición que queremos buscar
while(((linea=br.readLine())!=null)){
int indice = 0;
while((indice = linea.indexOf("cion",indice))!=-1){
                                     //Mediante la vble indice vamos recorriendo de cuatro en cuatro, para no leer siempre el mismo numero de caracteres
indice+=4;
cont++;
}
while((indice = linea.indexOf("ción",indice))!=-1){
indice+=4;
cont++;
}
                               //Tenemos dos bucles internos para comprobar las dos posibilidades, cion con y sin tilde
}

System.out.println("el número de palabras terminadas en cion: "+ cont);

fr.close();
}

}
------------------------------------------------------------------------------------------
Con eso, ya podremos contar las palabras que contienen o terminan en -cion; 
Aunque siempre y cuando cambiemos la cadena de String dentro del indexOf, podremos tener una amplia variedad de resultados.

Espero que esto les sirva de ayuda.

¿Como contar las líneas de un fichero con Java?

El siguiente código lo usaremos para contar la líneas de un fichero de texto; Este ejercicio esta relacionado con el tratamiento de ficheros de texto en Java.
CONTADOR DE LÍNEAS DE UN FICHERO DE TEXTO.
-------------------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


public class quijote4 {

/**
* @author Alberto Garcia
* @param args
*/
public static void main(String[] args) {
//Indicamos que fichero va a leer el programa, por lo que es un fichero por defecto.
               //En la vble siguiente definimos la ruta en la cual se encuentra el fichero
String nombreFich = ".\ejemplo.txt";

File fichero = new File(nombreFich);
try {
BufferedReader fich = new BufferedReader(new FileReader(nombreFich));
//Usamos la clase BufferReadeader para tener acceso a un metodo propio (readLine()) y asi mediante un contador contar las lineas.
int contadorL = 0;
String linea;
try {
//En este caso la condicion final del while corresponde a null, para indicar el final de linea
while((linea = fich.readLine()) != null){
contadorL++;
}
System.out.println("El número de líneas :" + contadorL);
} catch (IOException e) {
// TODO Bloque catch generado automáticamente
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
-------------------------------------------------------------------------------------------------
Como podemos ver el código, es bien sencillo y lo podemos probar mediante cualquier IDE, por ejemplo Eclipse.

Tras la ejecución del programa el resultado aparecerá por la consola de la siguiente forma: El número de líneas : X

martes, 5 de marzo de 2013

Programación.

Por el momento los programas mostrados no están orientados a objetos, y por el momento va a seguir siendo así, no obstante, publicaré algunos orientados a objetos.
Pero por lo general no estarán orientados.
Un Saludo.

Ordenación de vectores por el método de la burbuja.

En esta entrada expondremos un ejemplo de ordenación de vectores mediante el método de la burbuja. En programa consta de una petición inicial del número de salarios (números de elementos a comparar) y posteriormente los valores de esos salarios (en este caso). La ordenación se realizará de mayor a menor.

Código:


import java.util.Scanner;

public class Vector_2 {

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

// Variable para guardar el numero de sueldos a ordenar
int cantSalarios;

Scanner sc = new Scanner(System.in);

// Pedimos el numero de sueldos
System.out.println("Introduce el numero de salarios a ordenar: ");
cantSalarios = sc.nextInt();

// Declaramos el array de sueldos con la cantidad de sueldos que hemos pedido
int [] salario = new int[cantSalarios];

// Hacemos un for para pedir los sueldos
for(int c = 0; c < cantSalarios; c++)
{
System.out.println("Ves introduciendo los salarios, por favor: ");
salario[c] = sc.nextInt();
}

int aux;

// Para ordenar los vectores usamos el método de la burbuja
for (int k=1; k<cantSalarios; k++)
{
for (int f=0; f<cantSalarios-k; f++)
{
//Comprobamos si el primer salario es mayor que el segundo
if (salario[f] > salario[f+1])
{
// Si es mayor, es deci, valor true: No hace nada por que ya esta ordenado
}
// Pero si es menor es falso por lo tanto tenemos que ordenarlo.
//Guardamos el primer vector en AUX. Guardamos el segundo en la  posicion del primero.
// Y el segundo vector [j+1] lo guardamos en aux
else
{
aux = salario[f];
salario[f] = salario[f+1];
salario[f+1] = aux;
}
}
}

// imprimimos por pantalla la cantidad de sueldos.  Ordenados de Mayor a Menor
System.out.println("Salarios, de mayor a menor:  ");

for (int i=0; i<cantSalarios; i++)
System.out.println(" "+ salario[i]);
}
}

Espero que les sea de utilidad, ya que es un método de ordenación bastante útil.

Matriz Unidad.

En esta entrada expondremos como imprimir por pantalla la matriz unidad, mediante bucles anidados for.



public class MatrizUnidadAPP {
/**
* @author Garcy16
*/
public static void main (String[] args) {
double[][] mUnidad= new double[4][4];
for (int i=0; i < mUnidad.length; i++) {
for (int j=0; j < mUnidad[i].length; j++) {
if (i == j) {
mUnidad[i][j]=1.0;
}else {
mUnidad[i][j] = 0.0;
}
}
}
for (int i=0; i < mUnidad.length; i++) {
for (int j=0; j < mUnidad[i].length; j++) {
System.out.print(mUnidad[i][j]+"\t");
}
System.out.println("");
}
try{
//espera la pulsación de una tecla y luego RETORNO
System.in.read();
}catch (Exception ex) { }
}
}

El resultado sería el siguiente:

Para concluir, decir que no se si esto os será útil pero como curiosidad esta bien. Y sobre todo para comprender como funcionan los bucles for.

lunes, 11 de febrero de 2013

CALCULADORA JAVA

En la entrada de hoy os mostraré en código para realizar una calculador en java con "switch".
CALCULADORA:


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Calculador_switch {

/**
* @author Garcy
* @param args
* @throws IOException 
*/
public static void main(String[] args) throws IOException {
String numero1;
String numero2;
int opcion = 0;
 
//Instrucción para introducir por teclado
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
System.out.println("Introduzca primer número: ");
numero1 = br.readLine();
System.out.println("Introduzca segundo número: ");
numero2 = br.readLine();

//Transformación del tipo String a double(para admitir decimales)
double variable1 = Double.parseDouble(numero1);
double variable2 = Double.parseDouble(numero2);

System.out.println("Introduzca la operacion que dese:");
char operacion = ( char ) br.read();


//sentencia de control switch
switch (operacion){
case '+':
System.out.println(variable1 + variable2);
break;
case '-':
System.out.println(variable1 - variable2);
break;
case '*': 
System.out.println(variable1 * variable2);
break;
case '/':
System.out.println(variable1 / variable2);
break;
default: 
System.out.println("Operación no válida");

}

}
 
}

Todo lo mostrado anteriormente es el código para realizar una calculadora simple en java con la sentencia de control switch. Espero que os sirva de ayuda.
*Nota: La calculadora carece de interfaz gráfico.

domingo, 3 de febrero de 2013

HOLA MUNDO

Para comenzar de nuevo con el blog, la primera entrada será el conocidísimo programa "Hola Mundo". Programado en Java.
Código:


public class HolaMundo {

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

// En java el primer programa, consta de una línea de código
System.out.println("¡HolaMundo!");
}

}


Y ya está, el primer programa y más sencillo ya está hecho.

Volvemos a empezar.

Volvemos con la re-apertura del blog, tan un tiempo sin actividad. En esta etapa, el blog seguirá mostrando noticias de actualidad de carácter miscelanea pero nos centraremos en la programación, la informática y las nuevas tecnologías.
En cuanto a la programación, será en java mediante el entorno de desarrollo Eclipse o NetBeans.
También tocaremos aspectos de la creación de paginas con HTML y XML.

Gracias.