Utilización de la clase math

1. Utilización de la clase Math
Se puede usar la clase java.lang.Math para ejecutar muchas operaciones Matemáticas.
Las constantes y métodos de la clase son:
double E: El número 'e' (2.7 1828 18284590452354)
double PI: La constante pi (3.14159265358979323846)
double sin(doub1e a): Seno
doublecos(doub1e a): Coseno
double tan(doub1e a): Tangente
doubleasin(doub1e a): Arcoseno
doubleacos(doub1e a): Arcocoseno
double atan(doub1e a): Arcotangente
doubleatan2(double a): Arcotangente (versión 2 del operando)
doubleexp(doub1e a): Eleva el número 'e' a la potencia 'a'
double log(doub1e a): Logaritmo del valor 'a'
doublesqrt(doub1e a): Raíz cuadrada del valor 'a'
doublepow(doub1e a, double b): Elevar el valor 'a' a la potencia 'b'
doublecell(doub1e a): Método ceiling:Devuelve el número entero más pequeño mayor o igual que el número especificado
doublefloor(doub1e a): Métodofloores el entero mayor o igual al mismo numero
doublerint(doub1e a): Enteroaleatorio
int round(doub1e a): Redondea un double
long round(float a): Redondeaunfloat
doublerandom( ): Número aleatorio
intabs(int a): Valor absoluto de un entero
longabs(1ong a): Valor absoluto de un long
floatabs(float a): Valor absoluto de unfloat
doubleabs(doub1e a): Valor absoluto de un double
int min(int a, int b): Mínimo de los dos enteros
long min(1ong a, long b): Mínimo de dos long
float min(floata,floatb): Mínimo de dosfloat
double min(doub1e a, double b): Mínimo de dos double
intmax(int a, int b): Máximo de dos enteros
longmax(1ong a, long b): Máximo de dos long
floatmax(floata,float b): Máximo de dosfloat
doublemax(doub1e a, double b): Máximo de dos doublé
int a=9.55;
S.O.P(Math.round(a));
::::::::::::::::::::::
double base =5;
double exponente=3;
double potencia =0;
potencia = Math.pow(base, exponente);
System.out.println("potencia =" +potencia);
Math.___(variable)
C. Entrada/Salida por archivo

2. a.) Tipos de archivos
En Java es posible utilizar dos tipos de archivos (de texto o binarios) y dos tipos de acceso a los archivos (secuencial o
aleatorio).
Los archivos de texto están compuestos de caracteres legibles, mientras que los binarios pueden almacenar cualquier
tipo de datos (int, float, boolean,...).
Una lectura secuencial implica tener que acceder a un elemento antes de acceder al siguiente, es decir, de una
manera lineal (sin saltos). Sin embargo los archivos de acceso aleatorio permiten acceder a sus datos de una forma
aleatoria, esto es indicando una determinada posición desde la que leer/escribir.
b.) Clases a estudiar
En el paquete java.io existen varias clases de las cuales podemos crear instancias de clases para tratar todo tipo de
archivos.
En este tutorial sólo vamos a trata las tres principales:
FileOutputStream: Archivo de salida de texto. Representa archivos de texto para escritura a los que se accede de
forma secuencial.
FileInputStream: Archivo de entrada de texto. Representa archivos de texto de sólo lectura a los que se accede de
forma secuencial.
RandomAccessFile: Archivo de entrada o salida binario con acceso aleatorio. Es la base para crear los objetos de tipo
archivo de acceso aleatorio. Estos archivos permiten multitud de operaciones; saltar hacia delante y hacia atrás para
leer la información que necesitemos en cada momento, e incluso leer o escribir partes del archivo sin necesidad de
cerrarlo y volverlo a abrir en un modo distinto.
c.) Generalidades
Para tratar con un archivo siempre hay que actuar de la misma manera:
1. Se abre el archivo.
Para ello hay que crear un objeto de la clase correspondiente al tipo de archivo que vamos a manejar, y el tipo de
acceso que vamos a utilizar:
TipoDeArchivoobj = new TipoDeArchivo( ruta );
Donde ruta es la ruta de disco en que se encuentra el archivo o un descriptor de archivo válido.
Este formato es válido, excepto para los objetos de la clase RandomAccessFile (acceso aleatorio), para los que se ha
de instanciar de la siguiente forma:
RandomAccessFileobj = new RandomAccessFile(ruta, modo );
Donde modo es una cadena de texto que indica el modo en que se desea abrir el archivo; "r" para sólo lectura o "rw"
para lectura y escritura.
2. Se utiliza el archivo.
Para ello cada clase presenta diferentes métodos de acceso para escribir o leer en el archivo.

3. 3. Gestión de excepciones (opcional, pero recomendada)
Se puede observar que todos los métodos que utilicen clases de este paquete deben tener en su definición una
cláusula throwsIOException. Los métodos de estas clases pueden lanzar excepciones de esta clase (o sus hijas) en el
transcurso de su ejecución, y dichas excepciones deben de ser capturadas y debidamente gestionadas para evitar
problemas.
4. Se cierra el archivo y se destruye el objeto.
Para cerrar un archivo lo que hay que hacer es destruir el objeto. Esto se puede realizar de dos formas, dejando que
sea el recolector de basura de Java el que lo destruya cuando no lo necesite (no se recomienda) o destruyendo el
objeto explícitamente mediante el uso del procedimiento close() del objeto:
obj.close()
d.) La clase FileOutputStream
Mediante los objetos de esta clase escribimos en archivos de texto de forma secuencial.
Presenta el método write() para la escritura en el archivo. Presenta varios formatos:
intwrite( int c ): Escribe el carácter en el archivo.
intwrite( byte a[] ): Escribe el contenido del vector en el archivo.
intwrite( byte a[], int off, intlen ): Escribe len caracteres del vector a en el archivo, comenzando desde la posición off.
El siguiente ejemplo crea el archivo de texto "/carta.txt" a partir de un texto que se le introduce por teclado:
importjava.io.*;
classCreaCarta {
public static void main(String args[]) throws IOException{
int c;
FileOutputStream f=new FileOutputStream("/carta.txt");
while( ( c=System.in.read() ) != -1 )
f.write( (char)c );
f.close();
}

4. }
e.) La clase FileInputStream
Mediante los objetos de esta clase leemos de archivos de texto de forma secuencial.
Presenta el método read() para la lectura del archivo. Este método se puede invocar de varias formas.
intread(): Devuelve el siguiente carácter del archivo.
intread( byte a[] ): Llena el vector a con los caracteres leídos del archivo. Devuelve la longitud del vector que se ha
llenado si se realizó con éxito o –1 si no había suficientes caracteres en el archivo para llenar el vector.
intread( byte a[], int off, intlen ): Lee len caracteres del archivo, insertándolos en el vector a.
Todos ellos devuelven -1 si se ha llegado al final del archivo (momento de cerrarle).
El siguiente ejemplo muestra el archivo de texto "/carta.txt" en pantalla:
importjava.io.*;
classMuestraCarta {
public static void main(String args[]) throws IOException {
int c;
FileInputStream f=new FileInputStream("/carta.txt");
while( ( c=f.read() ) != -1 )
System.out.print( (char)c );
f.close();
}
}
f.) La clase RandomAccessFile
Mediante los objetos de esta clase utilizamos archivos binarios mediante un acceso aleatorio, tanto para lectura como
para escritura. En estos archivos hay un índice que nos dice en qué posición del archivo nos encontramos, y con el que
se puede trabajar para posicionarse en el archivo.

5. Métodos de desplazamiento
Cuenta con una serie de funciones para realizar el desplazamiento del puntero del archivo. Hay que tener en cuenta
que cualquier lectura o escritura de datos se realizará a partir de la posición actual del puntero del archivo.
longgetFilePointer();Devuelve la posición actual del puntero del archivo.
voidseek( long l ); Coloca el puntero del archivo en la posición indicada por l. Un archivo siempre empieza en la
posición 0.
intskipBytes( int n ); Intenta saltar n bytes desde la posición actual.
longlength(); Devuelve la longitud del archivo.
voidsetLength( long l); Establece a l el tamaño de este archivo.
FileDescriptorgetFD(); Devuelve el descriptor de este archivo.
Métodos de escritura
La escritura del archivo se realiza con una función que depende el tipo de datos que se desee escribir.
voidwrite( byte b[], intini, intlen ); Escribe len caracteres del vector b.
voidwrite( int i ); Escribe la parte baja de i (un byte) en el flujo.
voidwriteBoolean( boolean b ); Escribe el boolean b como un byte.
voidwriteByte( int i ); Escribe i como un byte.
voidwriteBytes( String s ); Escribe la cadena s tratada como bytes, no caracteres.
voidwriteChar( int i ); Escribe i como 1 byte.
voidwriteChars( String s ); Escribe la cadena s.
voidwriteDouble( double d ); Convierte d a long y le escribe como 8 bytes.
voidwriteFloat( float f ); Convierte f a entero y le escribe como 4 bytes.
voidwriteInt( int i ); Escribe i como 4 bytes.
voidwriteLong( long v ); Escribe v como 8 bytes.
voidwriteShort( int i ); Escribe i como 2 bytes.
voidwriteUTF( String s ); Escribe la cadena s utilizando la codificación UTF-8.
Los métodos que escriben números de más de un byte escriben el primero su parte alta.
Métodos de lectura
La lectura del archivo se realiza con una función que depende del tipo de datos que queremos leer.
booleanreadBoolean(); Lee un byte y devuelve false si vale 0 o true sino.
bytereadByte(); Lee y devuelve un byte.
charreadChar(); Lee y devuelve un caracter.
doublereadDouble(); Lee 8 bytes, y devuelve un double.
floatreadFloat(); Lee 4 bytes, y devuelve un float.
voidreadFully( byte b[] ); Lee bytes del archivo y los almacena en un vector b.
voidreadFully( byte b[], intini, intlen ); Lee len bytes del archivo y los almacena en un vector b.
intreadInt(); Lee 4 bytes, y devuelve un int.
longreadLong(); Lee 8 bytes, y devuelve un long.
shortreadShort(); Lee 2 bytes, y devuelve un short.
intreadUnsignedByte(); Lee 1 byte, y devuelve un valor de 0 a 255.
intreadUnsignedShort(); Lee 2 bytes, y devuelve un valor de 0 a 65535.
StringreadUTF(); Lee una cadena codificada con el formato UTF-8.
intskipBytes(int n); Salta n bytes del archivo.
Si no es posible la lectura devuelven –1.
Ejemplo

6. Vamos a crear un pequeño programa que cree y acceda a un archivo binario, mediante acceso aleatorio.
El siguiente ejemplo crear un archivo binario que contiene los 100 primeros números (en orden):
// Crea un archivo binario con los 100 primeros numeros
static void creaFichBin( String ruta ) throws IOException {
RandomAccessFile f=new RandomAccessFile(ruta,"rw"); // E/S
for ( int i=1; i <= 100 ; i++ )
{
try{
f.writeByte( i );
} catch(IOException e){
// Gestion de excepcion de ejemplo
break; // No se puede seguir escribiendo
}
f.close();
}
}
El siguiente método accede al elemento cual de un archivo binario, imprimiendo la longitud del archivo, el elemento
cual y su 10 veces siguiente elemento:
static void imprimeEltoN(String ruta, long cual)
throwsIOException{

7. RandomAccessFile f=new RandomAccessFile(ruta,"r"); // E/
System.out.print( "El archivo " + ruta );
System.out.println( " ocupa " + f.length() + " bytes." );
f.seek( cual-1 ); // Me posiciono (-1 porque empieza en 0)
System.out.print(" En la posicion " + f.getFilePointer() );
System.out.println(" esta el numero " + f.readByte() );
f.skipBytes( 9 ); // Salto 9 => Elemento 10 masalla
System.out.print(" 10 elementos más allá, esta el ");
System.out.println(f.readByte() );
f.close();
}
Si incluimos ambos métodos en una clase, y les llamamos con el siguiente programa principal (main()):
public static void main(String args[]) throws IOException {
String ruta="numeros.dat"; // Archivo
creaFichBin( ruta ); // Se crea
imprimeEltoN( ruta, 14 ); // Accedo al elemento 14.
}
Obtendremos la siguiente salida:

8. El archivonumeros.dat ocupa 100 bytes.
En la posicion 13 esta el numero 14
10 elementos más allá, esta el 24