Cursos de java con GIDCO

Ejercicios Primer Modulo y Algunas cosillas

JAVA PRIMER MODULO

Primer Ejercicio
/*se pide resolver una ecuacion de segundo grado , es decir:
a*x2 +b*x+c=0
donde:
x=-b+(b2-4*a*c)
2*a
a,b,c valores ingresados por teclado
*/

//***********************************************************

//declaramos el paquete de entrada y salida

import java.io.*;

class Ecuacion{
//funcion principal
public static void main(String arg[])
{
//declaramos las variables de los coeficientes
int a=0;
int b=0;
int c=0;
//declaramos los valores de los resultados y la raiz a obtenerse
double x1,x2,valor,aux;
//abrimos el flujo de entrada y salida
DataInputStream f=new DataInputStream(System.in);
System.out.println("ingresa los coeficientes de la ecuacion (a,b,c)");
//tratamos la exepcion es decir el posible error en la entrada
try{
a=Integer.parseInt(f.readLine());
b=Integer.parseInt(f.readLine());
c=Integer.parseInt(f.readLine());

}catch(IOException e)
{ System.out.println("los valores no son los correctos");}

//utilizamos los metodos del clase Math

aux=Math.pow(b,2)-(4*a*c);
if(aux>0){
valor=Math.sqrt(aux);
//obtenemos las raices
x1=(-b+valor)/2*a;
x2=(-b-valor)/2*a;

//mostramos los resultados

System.out.println("***** Resolucion de una ecuacion de segundo grado *****");
System.out.println("Valor de la primera Raiz: "+x1);
System.out.println("Valor de la segunda Raiz: "+x2);
System.out.println("*******************************************************");

Grupo M4 : Jorge Ayaviri Martinez

E-MAIL: coco_marti@hotmail.com
Web : http://www.alpha-omega.losrecursos.com
Cursos de java con GIDCO
Ejercicios Primer Modulo y Algunas cosillas
else{
System.out.println("***** Resolucion de una ecuacion de segundo grado *****");
System.out.println("los resultados son imaginarios ");
System.out.println("*******************************************************");
}

}//fin funcion principal

}//fin Ecuacion

//***********************************************************

Segundo ejercicio
/*verificar si una cadena es pálindrome es decir:
ORURO es palindrome porque si se da la vuelta tiene el mismo significado
*/
//***********************************************************

//declaramos el paquete de entrada y salida

import java.io.*;

class Palindrome{
//funcion principal
public static void main(String arg[])
{
//declaramos las variables
String ori=new String();
String nueva=new String();
char aux;
int tam;
//abrimos el flujo de entrada y salida
DataInputStream f=new DataInputStream(System.in);
System.out.println("ingresa la palabra que verificaras");
//tratamos la exepcion es decir el posible error en la entrada
try{
ori=f.readLine();

}catch(IOException e)
{ System.out.println("el valor no es el correcto");}

//obtenemos el tamaño de la cadena

tam=ori.length();
//damos la vuelta la cadena original iniciando un ciclo en tamaño-1
for(int i=(tam-1);i>=0;i--)
{
//recibimos un caracter en la posicion i de la cadena original
//el metodo charAt(int) devuelve una caracter
aux=ori.charAt(i);
//concatenamos el caracter aux,pero volviendolo a String con el metodo
//vauleOf() para evitar posibles errores
nueva=nueva+String.valueOf(aux);
}
System.out.println("***************** Palindrome ******************");
//verificamos la nueva cadena con la original para ver si es palindrome

Grupo M4 : Jorge Ayaviri Martinez

E-MAIL: coco_marti@hotmail.com
Web : http://www.alpha-omega.losrecursos.com
Cursos de java con GIDCO
Ejercicios Primer Modulo y Algunas cosillas
if(ori.equals(nueva))
{ System.out.println("la palabra "+ori+" es palindrome");}
else
{ System.out.println("La palabra "+ori+" no es palindrome");}
System.out.println("***********************************************");

}//fin funcion principal

}//fin Palindrome

//***********************************************************

Tercer ejercicio
/*Realizar operaciones con matrices. Llenado , recorrido, insercion y eliminacion
*/
//***********************************************************

//declaramos el paquete de entrada y salida

import java.io.*;

class Matriz{
//funcion principal
public static void main(String arg[]) throws IOException
{
//creamos una matriz de 5x5
int matriz[][]=new int[5][5];
int valor,opc=0,x,y;

//abrimos el flujo de entrada y salida

DataInputStream f=new DataInputStream(System.in);

//Esta secion llena la matriz con los valores ingresados por el susuario
//como el mismo es muy pesado se lo realizara Randomicamente
/*
System.out.println("ingresa los valores de tu matriz");
for(int i=0;i<5;i++)
{for(int j=0;j<5;j++)
{
valor=Integer.parseInt(f.readLine());
matriz[i][j]=valor;
}
}
*/
//llenamos la matriz con valores enteros de forma randomica
//con el metodo random() del paquete Math (random devuelve valores de tipo float)
for(int i=0;i<5;i++)
{for(int j=0;j<5;j++)
{
//hacemos un casting para transformar el valor double que devuelve
//random()*100
valor=(int)(Math.random()*100);
matriz[i][j]=valor;

Grupo M4 : Jorge Ayaviri Martinez

E-MAIL: coco_marti@hotmail.com
Web : http://www.alpha-omega.losrecursos.com
Cursos de java con GIDCO
Ejercicios Primer Modulo y Algunas cosillas
}
}
//menu
System.out.println("********** Matriz *********");
System.out.println("Selecciona el siguiente menu");
System.out.println("<1> para el recorrido ");
System.out.println("<2> para insertar y eliminar ");
System.out.println("<0> para salir ");
System.out.println("**************************");

//creamos un ciclo infinito para manejar el menu "0" para salir

while(true)
{
//recibimos la opcion del menu
opc=Integer.parseInt(f.readLine());
//si nuestra opcion es cero rompemos el ciclo infinito
//y salimos del programa
if(opc==0)
{break;}
else{
//utilizamos la variable reservada switch para poder manejar
//el menu
switch(opc)
{
case 1:
System.out.println("los elementos de la matriz son");
for(int k=0;k<5;k++)
{for(int l=0;l<5;l++)
{
//utilizamos un truco para poder mostrar la matriz
//en roma ordenada es decir filas y columnas
if(l==4)
{ System.out.println(matriz[k][l]+" "); }
else
{System.out.print(" "+matriz[k][l]+" ");}
}
}
break; //fin caso 1
case 2:
System.out.print("Ingresa el nuevo valor y la posicion ");
System.out.println("ej:45(nuevo valor) ,3(x) , 2(y)");
valor=Integer.parseInt(f.readLine());
x=Integer.parseInt(f.readLine());
y=Integer.parseInt(f.readLine());
if((x>5) || (y>5))
{System.out.print("las coordenadas que ingresaste no ");
System.out.println("estan en el rango de la matriz");}
else{
System.out.println("el valor eliminado fue: "+matriz[x-1][y-1]);
matriz[x-1][y-1]=valor;
}
break; //fin caso 2
default:{System.out.println("ingresa uno de los valores del menu ");}

Grupo M4 : Jorge Ayaviri Martinez

E-MAIL: coco_marti@hotmail.com
Web : http://www.alpha-omega.losrecursos.com
Cursos de java con GIDCO
Ejercicios Primer Modulo y Algunas cosillas
} //fin switch

}//fin else

}//fin while

}//fin funcion principal

}//fin Matriz

Algunas Clases de interes

LA CLASE Math
La clase Math representa la librería matemática de Java. Las funciones que contiene son las de todos los
lenguajes, parece que se han metido en una clase solamente a propósito de agrupación, por eso se encapsulan
en Math, y lo mismo sucede con las demás clases que corresponden a objetos que tienen un tipo equivalente
(Character, Float, etc.). El constructor de la clase es privado, por los que no se pueden crear instancias de la
clase. Sin embargo, Math es public para que se pueda llamar desde cualquier sitio y static para que no haya
que inicializarla.
Funciones matemáticas
Si se importa la clase, se tiene acceso al conjunto de funciones matemáticas estándar:

Math.abs( x )          para int, long, float y double

Math.sin( double )
Math.cos( double )
Math.tan( double )
Math.asin( double )
Math.acos( double )
Math.atan( double )
Math.atan2( double,double )
Math.exp( double )
Math.log( double )
Math.sqrt( double )
Math.ceil( double )
Math.floor( double )
Math.rint( double )
Math.pow( a,b )
Math.round( x )       para double y float
Math.random()         devuelve un double
Math.max( a,b )       para int, long, float y double
Math.min( a,b )       para int, long, float y double
Math.E                para la base exponencial
Math.PI               para PI

He aquí un ejemplo que hace uso de algunas funciones de la clase Math:

class Mates {
public static void main( String args[] ) {
int x;
double rand,y,z;
float max;

rand = Math.random();
Grupo M4 : Jorge Ayaviri Martinez
E-MAIL: coco_marti@hotmail.com
Web : http://www.alpha-omega.losrecursos.com
Cursos de java con GIDCO
Ejercicios Primer Modulo y Algunas cosillas
x = Math.abs( -123 );
y = Math.round( 123.567 );
z = Math.pow( 2,4 );
max = Math.max( (float)1e10,(float)3e9 );

System.out.println( rand );
System.out.println( x );
System.out.println( y );
System.out.println( z );
System.out.println( max );
}
}

LA CLASE String
Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer. Un objeto
String representa una cadena alfanumérica de un valor constante que no puede ser cambiada después de haber
sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño puede variar(esto se vera
posteriromente).
Los Strings son objetos constantes y por lo tanto muy baratos para el sistema. La mayoría de las funciones
relacionadas con cadenas esperan valores String como argumentos y devuelven valores String.
Hay que tener en cuenta que las funciones estáticas no consumen memoria del objeto, con lo cual es más
conveniente usar Character que char. No obstante, char se usa, por ejemplo, para leer ficheros que están
escritos desde otro lenguaje.
Existen muchos constructores para crear nuevas cadenas:
String();
String( String str );
String( char val[] );
String( char val[],int offset,int count );
String( byte val[],int hibyte );
String( byte val[],int hibyte,int offset,int count );
Tal como uno puede imaginarse, las cadenas pueden ser muy complejas, existiendo muchas funciones muy
útiles para trabajar con ellas y, afortunadamente, la mayoría están codificadas en la clase String.

Funciones Básicas
La primera devuelve la longitud de la cadena y la segunda devuelve el carácter que se encuentra en la
posición que se indica en indice:
int length();
char charAt( int indice );

Funciones de Comparación de Strings

boolean equals( Object obj );
boolean equalsIgnoreCase( Object obj );
Lo mismo que equals() pero no tiene en cuenta mayúsculas o minúsculas.
int compareTo( String str2 );
Devuelve un entero menor que cero si la cadena es léxicamente menor que str2. Devuelve cero si las dos
cadenas son léxicamente iguales y un entero mayor que cero si la cadena es léxicamente mayor que str2.

Funciones de Comparación de Subcadenas

boolean regionMatch( int thisoffset,String s2,int s2offset,int len );
boolean regionMatch( boolean ignoreCase,int thisoffset,String s2,
int s2offset,int 1 );
Comprueba si una región de esta cadena es igual a una región de otra cadena.
boolean startsWith( String prefix );
boolean startsWith( String prefix,int offset );

Grupo M4 : Jorge Ayaviri Martinez

E-MAIL: coco_marti@hotmail.com
Web : http://www.alpha-omega.losrecursos.com
Cursos de java con GIDCO
Ejercicios Primer Modulo y Algunas cosillas
boolean endsWith( String suffix );
Devuelve si esta cadena comienza o termina con un cierto prefijo o sufijo comenzando en un determinado
desplazamiento.
int indexOf( int ch );
int indexOf( int ch,int fromindex );
int lastIndexOf( int ch );
int lastIndexOf( int ch,int fromindex );
int indexOf( String str );
int indexOf( String str,int fromindex );
int lastIndexOf( String str );
int lastIndexOf( String str,int fromindex );
Devuelve el primer/último índice de un carácter/cadena empezando la búsqueda a partir de un determinado
desplazamiento.
String substring( int beginindex );
String substring( int beginindex,int endindex );
String concat( String str );
String replace( char oldchar,char newchar );
String toLowerCase();
String toUpperCase();
String trim();
Ajusta los espacios en blanco al comienzo y al final de la cadena.
void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin );
void getBytes( int srcBegin,int srcEnd,byte dst[],int dstBegin );
String toString();
char toCharArray();
int hashCode();

Funciones ValueOf
La clase String posee numerosas funciones para transformar valores de otros tipos de datos a su
representación como cadena. Todas estas funciones tienen el nombre de valueOf, estando el método
sobrecargado para todos los tipos de datos básicos.
Veamos un ejemplo de su utilización:
String Uno = new String( "Hola Mundo" );
float f = 3.141592;

String PI = Uno.valueOf( f );
String PI = String.valueOf( f ); // Mucho más correcto

Funciones de Conversión
String valueOf( boolean b );
String valueOf( int i );
String valueOf( long l );
String valueOf( float f );
String valueOf( double d );
String valueOf( Object obj );
String valueOf( char data[] );
String valueOf( char data[],int offset,int count );
Usa arrays de caracteres para la cadena.
String copyValueOf( char data[] );
String copyValueOf( char data[],int offset,int count );
Crea un nuevo array equivalente para la cadena.

Grupo M4 : Jorge Ayaviri Martinez

E-MAIL: coco_marti@hotmail.com
Web : http://www.alpha-omega.losrecursos.com