investigación y complemento del compilador

2

Lenguajes y Autómatas I

74

INGENIERÍA EN SISTEMAS COMPUTACIONALES

UNIDAD 2 EVIDENCIA #1

Investigación y Complemento del Compilador

INTEGRANTES DEL EQUIPO:

Ana Karen Hernández Cruz.

Tania Hernández Martínez.

Adriana Morales Antonio.

César Manuel Reyes.

Gerardo Reyes Chavero.

MATERIA:


CATEDRÁTICO:

Ing. José Gregorio Márquez Vega

SEMESTRE: 6 TURNO: Matutino 1

Fecha de Entrega: 02 de Marzo del 2015.


3

FUNCIONES LÉXICAS DEFINICION EJEMPLO

Ana Karen

print( ) Imprime el argumento parado a la

salida estándar (normalmente la

consola).

public void print(String s)

public void print(Boolean b)

public void print(Char c)

println( ) Es similar al método print( )

excepto un carácter fin de línea o

secuencia se añade al final.

System.out.println(“x es “ + x + “, y es “ + y);

System.out.println(“x - y = “ + (x - y));

System.out.println(“x * y = “ + (x * y));

System.out.println(“x / y = “ + (x / y));

paint() Es un método vacío. public void paint(Graphics g) {

g.setFont(f);

g.setColor(Color.red);

g.drawString(“Hello again!”, 5, 25); }

do-while Se utiliza para repetir la ejecución

de sentencias y se ejecuta al

menos una vez.

int x = 1;

do {

System.out.println("Lazo, vuelta " + x);

x++;

} while (x <= 10);

try-catch captura de excepciones try

bloqueAIntentar //aunque sea una única


4

sentencia ésta irá entre {}

catch (tipoExcepcion1 identificador1)

boqueSentencias1

[catch (tipoExcepcion2 identificador2)

boqueSentencias2]

[finally

boqueSentenciasN]

o bien

try

bloqueAIntentar

finally

boqueSentenciasN

abstract Declara clases o métodos

abstractos

abstract tipo nombre (lista de parámetros)

double Tipo de Dato primitivo de punto

flotante por defecto (32 bits).

class caja{

double anchura;

double altura;

//calculo y devuelve el volumen

double volumen(){

return anchura *altura *profundidad; }

}


5

int Tipo de Dato primitivo entero por

defecto (32 bits).

int a=1, b=2; int c= a + b;

short s= 1; int d= s + c; // s seconvierte a int

strictfp Especifica bajo que standard se

calcularán las operaciones con

datos de punto flotante, para

determinar el grado de precisión

de los resultados.

strictfp class StrictFPClass {

double num1 = 10e+102;

double num2 = 6e+08;

double calculate() {

return num1 + num2;

}

}

boolean Tipo de Dato primitivo booleano

(true o false).

clase pública JavaBooleanExample{

public static void main (String [] args)

/ / Crear un objeto utilizando un booleano

eldado por debajo de los medios //1. Crear

unobjeto booleano de valor booleano

BooleanblnObj1 = new Boolean ( true ) ;

else Evaluación de la condición

lógicamente opuesta a un if o else

if.

int puntuacion;

String nota;

if (puntuacion >= 90) {

nota = "Sobresaliente";

} else (puntuacion >= 80)

{ nota = "Notable";


6


{ nota = "Bien";


{ nota = "Suficiente";

} else {

nota = "Insuficiente";}

interface Declara interfases. public interface NombreInterfaz

{

public abstract tipoDeResultado

nombreMétodo();

//otras declaraciones de métodos vacíos.

}

super Hace referencia a la clase padre o

al constructor de la clase padre

del objeto actual.

void myMethod (String a, String b) {

// colocar código aquí

super.myMethod(a,b);

// colocar más código

}

break Rompe el flujo normal del bloque

de código actual.

switch (oper) {

case '+':

addargs(arg1, arg2);

break;


7

case '-':

subargs(arg1, arg2);

break;

case '*':

multargs(arg1, arg2);

extends Indica que una clase o interfase

hereda de otra clase o interfase.

class Empleado extends Persona

{

public static final cantidad = 50;

//declaración de variables

//declaraciones de métodos

}

long Tipo de Dato primitivo entero (64

bits).

Int num1=100;

Long num2=num1;

switch Estructura de control condicional

múltiple.

switch (oper) {

case '+':

addargs(arg1, arg2);

break;

case '-':

subargs(arg1, arg2);

break;

case '*':


8

multargs(arg1, arg2);

byte Tipo de Dato primitivo entero (8

bits).

int a;

byte n1, n2;

short x;

final Declara la clase, método o

variable como "definitiva".

public class AnotherFinalClass {

public static final int aConstantInt = 123;

public final String aConstatString = “Hello

world!”);

}

native Indica que el método va a ser

especificado en un lenguaje

diferente a Java.

class HolaMundo {

public native void presentaSaludo();

static {

System.loadLibrary( "hola" );

}

}

synchronized Indica que el método, o bloque de

código deberá prevenir que no

sean cambiados los objectos a

afectar dentro del bloque o

método.

public void metodo() {

synchronized(this) {

// codigo del metodo aca

}

}

case Verifica cada valor evaluado en switch (x) {


9

una sentencia switch. case 2:

case 4:

case 6:

case 8:

System.out.println("x es un número par.");

break;

default: System.out.println("x es un número

impar.");

finally Determina el bloque de código

que se ejecutará siempre luego de

un try asi sea que se capture o no

una excepción.

finally{

código;

{

new Solicita al cargador de

clases correspondiente, un objeto

de esa clase.

new Animator();new Box(Color.black,

Color.red, 20, 25, 30, 15);

this Hace referencia el objeto actual o

al constructor del objeto actual.

class punto

int x,y;

punto(int x,int y){

this.x=x;

this.y=y;

}


10

int leer x(){

return x;

}

int leer y(){

return y;

}

}

catch Atrapa excepciones dentro de un

bloque try.

public void metodo() {

try{

}

catch(tipoExcepcion e){

try{

}

catch(tipoExcepcion e1){

}

}

float Tipo de Dato primitivo de punto

flotante (64 bits).

public static void main(String[] args) {

float a;

float b;

float c;

a = (float) 0.6917;


11

b = (float) 0.6911;

c = a-b;

System.out.println(c);

return;

}

package Especifica el paquete al que

pertenece esa clase o interfase.

Package nombrepaquete;

Package Mipaquete ;// crea un paquete

Mipaquete }

throw Lanza una excepción mediante

código.

try

bloqueAIntentar

catch(NumberFormatException identificador)

{

//...

throw (identificador);

}

char 30 Tipo de Dato primitivo que

almacena hasta un caracter

UNICODE (16 bits).

Char miCharacter=’n’; char mi Character1=110;

Tania

for Estructura de control cíclica. for (inicialización; test; incremento) {

sentencias;


12

}

private Modificador de visibilidad de

atributos y métodos limitándolos a

la propia clase.

private static class MiClase extiende java.util.

ArrayList

private final Object ocl = new Object ( ) ; final

privado Objeto OCL = new Object ();

}

}

throws Especifica la(s) excepcione(es)

que podría lanzar el método.

[modificadoresDeMétodos] tipoDeResultado

nombreMétodo

([tipoParámetro1 parámetro1

[,tipoParámetro2 parámetro2[, ...]]])

[throws Excepción1[,

Excepción2[,...]]]

{

//cuerpo del método que no trata la excepción

}

class Declara clases public class Persona {

private String nombre;

private String apellidos;

private in edad;

protected Modificador de visibilidad de public class AProtectedClass {


13

atributos y métodos limitándolos a

la propia clase, paquete e hijo(s).

private protected int aProtectedInt = 4;

private protected String aProtectedString =

“and a 3 and a “;

private protected float aProtectedMethod() {

. . . .

}

}

transient Indica que el objeto no se debe

serializar.

class TransientExample {

transient int hobo;

. . .

}

If Estructura de control condicional. // Respuesta dependiente del botón quehaya

pulsado el usuario

// OK o Cancel

if (respuesta == OK) {

// Código para la acción OK

} else {

// código para la acción Cancel

}

public Modificador de visibilidad de

clases, interfaces, atributos y

public class InstanceDemo {

public static void main(String[] args){


14

métodos haciéndolo visible al

universo.

MyClass cl1 = new MyClass();

MyClass cl2 = new MyClass();

System.out.println(cl1.ocl==cl2.ocl && cl1!=cl2);

}

try Declara un bloque de código que

posiblemente lanzará una

excepción.

public void metodo(){

try{

try{

}

catch(tipoExcepcion e){

}

}

catch(tipoExcepcion e) {

}

}

continue Rompe el flujo normal del bloque

de código actual.for(int j = 0; j<10; j++){

sentencia 1;

sentencia 2;

sentencia 3;

continue;

sentencia 4;


15

};

implements Indica que una clase implementa a

una (o varias) interfase(s).

public class Implementa [extends Padre]

implements NombreInterfaz

{

public tipoDeResultado nombreMétodo()

{

//...

return Retorna (normalmente un valor)

desde el método actual.

If(error==true)return ERROR;

void Indica que el método no retornará

valor alguno.

public class perro{

public void ladrar () {

sistem.out.printlin("wouf wouf");

}

public void morder(){

...

}

}

default Modificador de visibilidad de

clases, interfaces, atributos y

métodos limitándolos a la clase y

switch ( op ) {


16

paquete.default :

System.out.println("error");

break;

case '+':

System.out.println( a + b );

break;

import Indica la(s) ruta(s) en la que se

encuentran las clases y/o

interfases usadas en el código

import nombrePaquete.*;

import nombrePaquete.NombreClase;

import nombrePaquete.NombreInterfaz;

short Tipo de Dato primitivo entero (16

bits).

int a=1, b=2; int c= a + b;

short s= 1; int d= s + c; // s se convierte a int

float f= 1.0 + a; // a se convierte a float

volatile Indica que a la referencia de la

variable siempre se debería leer

sin aplicar ningún tipo de

optimizaciones ya que el dato

almacenado tiene alta

probabilidad de cambiar

muy frecuentemente.

volatile int contador;

Public void aumentar() {

Contador++;

}

do Estructura de control cíclica salida("Tercer iterador");


17

do {

salida("x es " + x--);

} while ( x > 0 );

System.exit(0);

}

instanceof Operador que determina si un

objeto es una instancia de una

clase.

if (profesor43 instanceof ProfesorInterino) {…}

else { …}

static Indica que el método, variable o

atributo pertenece a la clase y no

a la instancia (objeto).

class FamilyMember {

static String surname = “Johnson”;

String name;

int age; }

while Estructura de control cíclica. while (System.in.read() != -1) {

contador++;

System.out.println("Se ha leido el carácter =" +

contador);

}

null Se puede usar para declarar

cadenas vacías.

public static Empleado read (BufferedReader

br) throws Exception{

String nombre, tarifaStr;

int tarifa;


18

nombre = br.readLine();

if (nombre == null) return null;

tarifaStr = br.readLine();

if (tarifaStr == null) return null;

tarifa = Integer.parseInt(tarifaStr);

return new Empleado(nombre, tarifa);

}

true El valor verdadero de los datos

booleanos.

class Bool {

public static void main ( String argumentos[] ) {

boolean a=true;boolean b=true;

false boolean encontrado=false;

{...}

encontrado=true;

flush() Envía todo el buffer. salida.flush();

}

catch(FileNotFoundExceptione) {

}

close() Cierra el flujo de datos System.out.prinln(e.getMessage()); }

finally {

salida close();

}


19

}

arrayList Implementa una lista de

elementos mediante un array de

tamaño variable. Conforme se

añaden elementos el tamaño del

array irá creciendo si es

necesario. El array tendrá una

capacidad inicial, y en el momento

en el que se rebase dicha

capacidad, se aumentará el

tamaño del array.

// Vector de cadenas

ArrayList<String> a= new ArrayList<String>();

a.add("Hola");

String s = a.get(0);

a.add(new Integer(20)); // Daría error!!

// HashMap con claves enteras y valores de

vectores

HashMap <Integer, ArrayList>hm = new

HashMap();

hm.put(1, a);

ArrayList a2 = hm.get(1);

vector El Vector es una implementación

similar al ArrayList, con la

diferencia de que el Vector si que

está sincronizado. Este es un caso

especial, ya que la

implementación básica del resto

de tipos de datos no está

sincronizada

String

s1=”elemento”,s2=”elemento”,s3=”elemento”;

String []array={s1,s2,s3};

Vector v=new Vector();

v.addElement(s1); v.addElement(s2);

v.addElement(s3);

System.out.println(“Las componentes del array

son:”);

for (int i=0; i<3; i++)


20

{System.out.println(array[i]);}

StringBuffer Representa una cadena cuyo

tamaño puede variar.

StringBuffer(); StringBuffer( int len );

StringBuffer( String str );

binarySearch Permite buscar un elemento de

forma ultrarrapida en un array

ordenado (en un array

desprdenado sus resultado son

imprescindibles). Devuelve el

índice en el que está colocado el

elemento.

Int x[]={1,2,3,4,5,6,7,8,9,10,11,12};

Array.sort(x);

System.out.println(Array.binarySearch(x,8));

Adriana

System.arraysCopy La clase System también posee

un método relacionado con los

arrays, dicho método permite

copiar un array en otro. Recibe

cinco argumentos: el array que se

copia, el índice desde que se

empieza a copiar en el origen, el

array destino de la copia, el índice

desde el que se copia en el

destino, y el tamaño de la copia

Int uno[]={1,1,2};

Int dos[]={3,3,3,3,3,3,3,3,3};

System.arraycopy(uno,0,dos,0,uno.length);

For (int i=0,i<=8,i++){

System.out.print(dos[i]+ “ “);

}


21

(número de elementos de la

copia).

String.valueOf Este método pertenece no solo a

la clase String, sino a otras y

siempre es un método que

convierte valores de una clase a

otra. Permite convertir valores que

no son cadena a forma de cadena.

String numero= String.valueOf(1234);

String fecha= String.valueOf(new Date());

sort Permite ordenar un array en orden

ascendente. Se puede ordenar

solo una serie de elementos

desde un determinado pnto hasta

un determinado punto.

Int x[]={4,5,2,3,7,8,2,3,9,5};

Array.sort(x);//Estara ordenado

Array.sort(x,2,5);//Ordena del 20 al 40

elemento

length Permite devolver la longitud de

una cadena(el número de

caracteres de la cadena)

String texto1= “Prueba”;

System.out.println(texto1.length());

charAt Devuelve un carácter de la

cadena. El carácter a devolver se

indica por su posición (el primer

caracter es la posición 0). Si la

posición es negativa o sobrepasa

String s1= “Prueba”;

Char c1=s1.charAt(2);


22

el tamaño de la cadena, ocurre un

error de ejecución, una excepción

tipo IndexOutOfBounds-Exception.

substring Da como resultado una porción

del texto de la cadena. La porción

se toma desde una posición final

(sin incluir esa posición final). Si

las posiciones indicadas no son

validas ocurre una excepción de

tipo IndexOutOfBounds-Exception.

Se empieza a contar desde la

posición.

String s1=”Buenos Días”;

String s2=s1.substring(7,10);//s2= Días

indexOf Devuelve la primera posición en la

que aparece un determinado texto

en la cadena buscada no se

encuentra, devuelve -1. El texto a

buscar puede ser har o String.

String s1=”Quería decirte que quiero que te

vayas”;

System.out.println(s1.indexOf(“que”));// Da 15

lastIndexOf Devuelve la última posición en la

que aparece un determinado texto

en la cadena. Es casi idéntica a la

anterior, solo que busca desde el


vayas”;

System.out.println(s1.lasIndexOf(“que”));// Da

26


23

final.

endsWith Devuelve true si la cadena termina

con un determinado texto.


vayas”;

System.out.println(s1.endsWith(“vayas”));// Da

true

replace Cambia todas las apariciones de

un caracter por otro en el texto

que se indique y lo almacene

como resultado. El texto original

no se cambia, por lo que hay que

asignar el resultado de replace a

un String para almacenar el texto

cambiado.

String s1= “Mariposa”

System.out.println(s1.replace(‘a’,’e’)); Da

Meripose

System.out.println(s1);//Sigue valiendo

Mariposa

replaceAll Modifica en un texto cada entrada

de una cadena por otra y devuelve

el resultado. El primer parámetro

es el texto que se busca (que

puede ser una expresión regular),

el segundo parámetro es el texto

con el que se remplaza el

buscado. La cadena original no se

String s1= “Cazar armadillos”;

System.out.println(s1.replace(‘ar’,’er’)); Da

Cazer ermedillos

System.out.println(s1);//Sigue valiendo Cazar

armadilos


24

modifica.

finalize Es un método que es llamado

antes de eliminar definitivamente

al objeto para hacer limpieza final.

Un uso puede ser eliminar los

objetos creados en la clase para

eliminar referencias circulares. Es

un método de tipo protected

heredado por todas las clases ya

que está definido en la clase raíz

Object.

Class uno {

dos d;

uno(){

d=new dos();

}

Protected void finalize(){

d=null;//Se elimina d por lo que pudiera pasar

}

}

printf(boolean b) Imprime una variable booleana float x = 0

long y = 5;

int *iptr = 0;

if (x == false) printf("x falso"); // Error.

if (y == truee) printf("y cierto"); // Error.

if (iptr == false) printf("Puntero nulo"); // Error.

if ((bool) x == false) printf("x falso"); // Ok.

if ((bool) y == true) printf("y cierto"); // Ok.

if ((bool) iptr == false) printf("Puntero nulo"); //

Ok.


25

printf(char c) Imprime un caracter. Locale.setDefault(Locale.US);

Scanner lectura = newScanner(System.in);

char a;

a='\u2299';

System.out.printf("%c%n",a);

}

print(char[] s) Imprime un arreglo de caracteres. Printf (char arregloCadena[] = "buenas");

printf(double d) Imprime un número de tipo

double.

double n = 123.4567;

System.out.printf("El cuadrado de %.2f es %.2f\

n", n, n*n);

print(float f) Imprime un número de punto

flotante.

Public class tipoDecimales

{

Public static void main(String[]arg)

{

Float valor;

Valor=2.6;

System.out.println(“Valor de dato=”+valor);

}

}

print(int i) Imprime un entero.int main(void)


26

{

printf("¡Hola, mundo!\n");

return 0; }

print(long l) Imprime un largo enteroLong enteroGrande;

System.out.println(“Entero grande”);

EnteroGrande=lectura.nextLong();

print(Object obj) Imprime un objeto, invocando su

función toString()

Public boolean equals (Object obj) {

If (obj instanceof Persona){

Persona tmpPersona=(Persona)obj;

print(String s) Imprime un objeto de tipo String String nombre1, nombre2;

Int edad1, edad2;

System.out.print(“Ingrese el nombre”);

println() Imprime un separador de nueva

línea.System.out.println("3 x 1 = 3");

System.out.println("3 x 2 = 6");

println(boolean x) Imprime un valor booleano y

termina la línea.

public static boolean esPositivo(int x) {

if (x<0) return false;

else return true;


27

}

}

println(char x) Imprime un caracter y termina la

línea.

public class Main {


int N = 5;

double A = 4.56;

char C = 'a';

System.out.println("Variable N = " + N);

System.out.println("Variable A = " + A);

System.out.println("Variable C = " + C);

System.out.println(N + " + " + A + " = " +(N+A));

System.out.println(A + " - " + N + " = " + (A-N));

System.out.println("Valor numérico del carácter

" + C + " = " + (int)C);

}

}

println(char[] x) Imprime un arreglo de caracteres

y termina la línea.

int edades[];

char codigo[];

edades = new int [5];

codigos = new char[5];

println(double x) Imprime un número de precisión double x;


28

doble y termina la línea. system.out.println(“Introduzca número de tipo

double: ”);

x=sc nextDouble();

println(float x) Imprime un número de punto

flotante y termina la línea.

publicclass DivCeroFloat{

publicstaticvoid main(String[] args){

float x = 5.0f;

float y = 0.0f;

float z = x/y;

System.out.println(z);

}

}

println(int x) Imprime un entero y termina la

línea.

publicclass IntGrande{

publicstaticvoid main(String[] args){

int j = 2147483647;

int i = j + 1;

System.out.println("El valor obtenido es " + i);

}

}

println(long x) Imprime un entero largo y termina

la línea.

public class Factorial {

public static void main(String args[]) {

long n = Long.parseLong(args[0]);


29

System.out.println("El factorial de " + n + " es: "

+ Factorial(n)); }

println(Object x) Imprime un objeto invocando su

método toString() y termina la

línea.

import java.io.*;

public class PrintStreamDemo {


Object c = 15;

// create printstream object

PrintStream ps = new

PrintStream(System.out);

// print an object and change line

ps.println(c);

ps.print("New Line");

// flush the stream

ps.flush();

}

}

César

println(String x) Imprime un trozo de texto y

termina la línea.

import java.io.*;

public class Main {


String c = "from java2s.com";


30

PrintStream ps = new

PrintStream(System.out);

// print a string and change line

ps.println(c);

ps.print("from java2s.com");

// flush the stream

ps.flush();

}

}

available() Devuelve la cantidad de bytes que

se pueden leer (o pasar por alto)

desde esta entrada sin bloquear la

próxima llamada a lectura.

mport java.io.IOException;

import java.io.InputStream;

public class TiposEntradaEstandarPipe

{

public static void main(String[] args)

{

InputStream entrada = System.in;

int leido = 0;

try

{

if(entrada.available()>0)

{


31

while((leido = entrada.read()) != -1)

System.out.print((char)leido);

}

else

System.out.print("No se han encontrado datos

en la entrada Estandar");

}catch (IOException e)

{

System.out.print("Ha ocurrido un Error al leer la

entrada Estandar");

System.out.print(e.getMessage());

}

}

}

close() Cierra esta entrada de datos y

libera todos los recursos

asociados.

public class createfile {

private Formatter x;

public void openFile(){

try{

x = new

Formatter("supermanvsbatman.txt");

}


32

catch(Exception e){

System.out.println("you have an error");

}

}

public void addRecords(){

x.format("%s%s%s","20 ", "Bruce ",

"Wayne ");

}

public void closeFile(){

x.close();

}

}

read() Lee el próximo byte de datos

desde la entrada, espera por los

datos.

import java.io.IOException;

public class MainClass {


int inChar;

System.out.println("Enter a Character:");

try {

inChar = System.in.read();

System.out.print("You entered ");

System.out.println(inChar);


33

}

catch (IOException e){

System.out.println("Error reading from

user");

}

}

}

read(byte[] b) Lee de la entrada los bytes que

llenan el arreglo b, devuelve la

cantidad de bytes que se

almacenaron.


import java.io.FileInputStream;

public class FileInputStreamDemo {

public static void main(String[] args) throws

IOException {

FileInputStream fis = null;

int i = 0;

char c;

byte[] bs = new byte[4];

try{

// create new file input stream

fis = new FileInputStream("C://test.txt");

// read bytes to the buffer

i=fis.read(bs);


34

// prints

System.out.println("Number of bytes read: "+i);

System.out.print("Bytes read: ");

// for each byte in buffer

for(byte b:bs)

{

// converts byte to character

c=(char)b;

// print

System.out.print(c);

}

}catch(Exception ex){

// if any error occurs

ex.printStackTrace();

}finally{

// releases all system resources from the

streams

if(fis!=null)

fis.close();

}

}


35

}

read(byte[] b, int off, int len) Lee hasta en bytes de datos

adentro del arreglo de bytes b

empezando en off.

import java.io.BufferedInputStream;

import java.io.FileInputStream;


public class BufferedInputStreamDemo {


Exception {

InputStream inStream = null;

BufferedInputStream bis = null;

try{

// open input stream test.txt for reading

purpose.

inStream = new

FileInputStream("c:/test.txt");

// input stream is converted to buffered

input stream

bis = new

BufferedInputStream(inStream);

// read number of bytes available

int numByte = bis.available();

// byte array declared


36

byte[] buf = new byte[numByte];

// read byte into buf , starts at offset 2, 3

bytes to read

bis.read(buf, 2, 3);

// for each byte in buf

for (byte b : buf) {

System.out.println((char)b+": " + b);

}

}catch(Exception e){

e.printStackTrace();

}finally{

// releases any system resources

associated with the stream

if(inStream!=null)

inStream.close();

if(bis!=null)

bis.close();

}

}

}

skip(long n) Salta y destruye los n caracteres import java.io.BufferedInputStream;


37

de datos. import java.io.FileInputStream;

import java.io.FilterInputStream;



public class FilterInputStreamDemo {


Exception {

InputStream is = null;

FilterInputStream fis = null;

int i=0;

char c;

try{

// create input streams

is = new FileInputStream("C://test.txt");

fis = new BufferedInputStream(is);

while((i=fis.read())!=-1)

{

// converts integer to character

c=(char)i;

// skips 3 bytes

fis.skip(3);


38

// print

System.out.println("Character read: "+c);

}

}catch(IOException e){

// if any I/O error occurs

e.printStackTrace();

}final{

// releases any system resources

associated with the stream

if(is!=null)

is.close();

if(fis!=null)

fis.close();

}

}

}

abs(double a) Devuelve el valor absoluto de un

valor double.

import java.lang.Math;

public class MathDemo {


// get some doubles to find their absolute

values


39

double x = 4876.1874d;

double y = -0.0d;

// get and print their absolute values

System.out.println("Math.abs(" + x + ")=" +

Math.abs(x));

System.out.println("Math.abs(" + y + ")=" +

Math.abs(y));

System.out.println("Math.abs(-9999.555d)="

+ Math.abs(-9999.555d));

}

}

abs(float a) Devuelve el valor absoluto de un

valor float.

import java.lang.*;



// get some floats to find their absolute values

float x = 1.2345f;

float y = -857.54f;



Math.abs(x));



40

Math.abs(y));

System.out.println("Math.abs(-145.0f)=" +

Math.abs(-145.0f));

}

}

abs(int a) Devuelve el valor absoluto de un

valor int.

int absoluto(int x){

int abs;

if(x>0) abs=x;

else abs=-x;

return abs;

}

abs(long a) Devuelve el valor absoluto de un

valor long.

import java.lang.*;



// get some longs to find their absolute values

long x = 76487687634l;

long y = -1876487618764l;



Math.abs(x));



41

Math.abs(y));

System.out.println("Math.abs(-

18885785959l)=" + Math.abs(-18885785959l));

}

}

acos(double a)90 Devuelve el arcocoseno de un

ángulo, en el rango de 0.0 hasta

pi.

public class calc{

private double x;

private double y;

public calc(double x,double y){

this.x=x;

this.y=y;

}

public void print(double theta){

x = x*Math.cos(theta);

y = y*Math.sin(theta);

System.out.println("cos 90 : "+x);

System.out.println("sin 90 : "+y);

}

public static void main(String[]args){

calc p = new calc(3,4);

p.print(Math.toRadians(90));


42

}

asin(double a) Devuelve el arcoseno de un

ángulo, en el rango de -pi/2 hasta

pi/2.

public class bloqueStatic {

static double tablaSeno[] = new double[360];

static {

for(int i = 0; i < 360; i++)

tablaSeno[i] = Math.sin(Math.PI*i/180.0);

}

public static void main (String args[]) {

for(int i = 0; i < 360; i++)

System.out.println("Angulo: "+i+" Seno=

"+tablaSeno[i]);

}

}

atan(double a) Devuelve el arcotangente de un

ángulo, en el rango de -pi/2 hasta

pi/2.

import java.lang.*;



// get a variable x which is equal to PI/2

double x = Math.PI / 2;

// convert x to radians

x = Math.toRadians(x);


43

// get the arc tangent of x

System.out.println("Math.atan(" + x + ")" +

Math.atan(x));

}

}

atan2(double y, double x) Convierte coordenadas

rectangulares (x, y) a polares (r,

theta).

import java.lang.*;



// get a variable x which is equal to PI/2

double x = Math.PI / 2;

// get a variable y which is equal to PI/3

double y = Math.PI / 3;

// convert x and y to degrees

x = Math.toDegrees(x);

y = Math.toDegrees(y);

// get the polar coordinates

System.out.println("Math.atan2(" + x + "," +

y + ")=" + Math.atan2(x, y));

}

}

cbrt(double a) Devuelve la raíz cuadrada de un import java.lang.*;


44

valor double. public class MathDemo {


// get two double numbers

double x = 125;

double y = 10;

// print the cube roots of three numbers

System.out.println("Math.cbrt(" + x + ")=" +

Math.cbrt(x));

System.out.println("Math.cbrt(" + y + ")=" +

Math.cbrt(y));

System.out.println("Math.cbrt(-27)=" +

Math.cbrt(-27));

}

}

ceil(double a) Devuleve el más pequeño

(cercano al infinito negativo) valor

double que es más grande o igual

al argumento a y es igual a un

entero matemático.

import java.lang.*;




double x = 125.9;

double y = 0.4873;

// call ceal for these these numbers


45

System.out.println("Math.ceil(" + x + ")=" +

Math.ceil(x));

System.out.println("Math.ceil(" + y + ")=" +

Math.ceil(y));

System.out.println("Math.ceil(-0.65)=" +

Math.ceil(-0.65));

}

}

cos(double a) Devuelve el coseno trigonométrico

de un ángulo.

import java.lang.*;




double x = 45.0;

double y = 180.0;

// convert them to radians


y = Math.toRadians(y);

// print their cosine

System.out.println("Math.cos(" + x + ")=" +

Math.cos(x));

System.out.println("Math.cos(" + y + ")=" +


46

Math.cos(y));

}

}

cosh(double x) Devuelve el coseno hiperbólico de

un valor value.

import java.lang.*;




double x = 45.0;

double y = 180.0;




// print their hyperbolic cosine

System.out.println("Math.cosh(" + x + ")=" +

Math.cosh(x));

System.out.println("Math.cosh(" + y + ")=" +

Math.cosh(y));

}

}

exp(double a) Devuelve el valor e de Euler

elevado a la potencia del valor

import java.lang.*;



47

double a. public static void main(String[] args) {


double x = 5;

double y = 0.5;

// print e raised at x and y

System.out.println("Math.exp(" + x + ")=" +

Math.exp(x));

System.out.println("Math.exp(" + y + ")=" +

Math.exp(y)); }

}

expm1(double x) Devuelve ex−1 . import java.lang.*;




double x = 5;

double y = 0.5;

// call expm1 for both numbers and print the

result

System.out.println("Math.expm1(" + x + ")="

+ Math.expm1(x));

System.out.println("Math.expm1(" + y + ")="


48

+ Math.expm1(y));

}

}

floor(double a) Devuelve el más largo (cercano al

positivo infinito) valor double que

es menor o igual al argumento a y

es igual a un entero matemático.

import java.lang.*;




double x = 60984.1;

double y = -497.99;

// call floor and print the result

System.out.println("Math.floor(" + x + ")=" +

Math.floor(x));

System.out.println("Math.floor(" + y + ")=" +

Math.floor(y));

System.out.println("Math.floor(0)=" +

Math.floor(0));

}

}

hypot(double x, double y)Devuelve sqrt(x2+ y2) sin el

overflow o underflow intermedio.

import java.lang.*;




49


double x = 60984.1;

double y = -497.99;

// call hypot and print the result

System.out.println("Math.hypot(" + x + "," +

y + ")=" + Math.hypot(x, y)); }

}

IEEEremainder(double f1,

double f2)

Computa la operación prescripta

por el estándar IEEE 754 entre los

dos argumentos f1 y f2.

import java.lang.*;




double x = 60984.1;

double y = -497.99;

// get the remainder when x/y

System.out.println("Math.IEEEremainder("

+ x + "," + y + ")="

+ Math.IEEEremainder(x, y));

// get the remainder when y/x

System.out.println("Math.IEEEremainder("

+ y + "," + x + ")="

+ Math.IEEEremainder(y, x));


50

}

}

log(double a) Devuelve el logaritmo natural

(base e) de un valor double.

import java.lang.*;




double x = 60984.1;

double y = -497.99;

// get the natural logarithm for x

System.out.println("Math.log(" + x + ")=" +

Math.log(x));

// get the natural logarithm for y

System.out.println("Math.log(" + y + ")=" +

Math.log(y));

}

}

log10(double a) Devuelve el logaritmo en base 10

de un valor double.

import java.lang.*;




double x = 60984.1;


51

double y = 1000;

// get the base 10 logarithm for x

System.out.println("Math.log10(" + x + ")="

+ Math.log10(x));

// get the base 10 logarithm for y

System.out.println("Math.log10(" + y + ")="

+ Math.log10(y));

}

}

log1p(double x) Devuelve ex+1 . import java.lang.*;




double x = 60984.1;

double y = 1000;

// call log1p and print the result

System.out.println("Math.log1p(" + x + ")="

+ Math.log1p(x));

// call log1p and print the result

System.out.println("Math.log1p(" + y + ")="

+ Math.log1p(y));


52

}

}

max(double a, double b) Devuelve el más grande de los

dos valores double a y b.

import java.lang.*;




double x = 60984.1;

double y = 1000;

// print the larger number between x and y

System.out.println("Math.max(" + x + "," + y

+ ")=" + Math.max(x, y));

}

}

max(float a, float b) Devuelve el más grande de los

dos valores float a y b.

import java.lang.*;



// get two float numbers

float x = 60984.1f;

float y = 1000f;




53

+ ")=" + Math.max(x, y));

}

}

max(int a, int b) Devuelve el más grande de los

dos valores int a y b.

import java.lang.*;



// get two integer numbers

int x = 60984;

int y = 1000;



+ ")=" + Math.max(x, y));

}

}

Gerardo Chavero

max(long a, long b) Devuelve el más grande de los

dos valores long a y b.

import java.lang.*;



// get two long numbers

long x = 6098499785l;

long y = 1000087898745l;


54



+ ")=" + Math.max(x, y)); }

}

min(double a, double b) Devuelve el más pequeño de los

dos valores double a y b.

import java.lang.*;




double x = 9875.875;

double y = 154.134;

// print the smaller number between x and y

System.out.println("Math.min(" + x + "," + y

+ ")=" + Math.min(x, y));

}

}

min(float a, float b) Devuelve el más pequeño de los

dos valores float a y b.

import java.lang.*;




float x = 9875.875f;

float y = 154.134f;


55



+ ")=" + Math.min(x, y));

}

}

min(int a, int b) Devuelve el más pequeño de los

dos valores int a y b.

import java.lang.*;



// get two int numbers

int x = 9875;

int y = 154;



+ ")=" + Math.min(x, y));

}

}

min(long a, long b) Devuelve el más pequeño de los

dos valores long a y b.

import java.lang.*;



// get two long numbers

long x = 98759765l;


56

long y = 15428764l;



+ ")=" + Math.min(x, y));

}

}

pow(double a, double b) Devuelve el valor del argumento a

elevado a la potencia de b : ab.

import java.lang.*;




double x = 2.0;

double y = 5.4;

// print x raised by y and then y raised by x

System.out.println("Math.pow(" + x + "," + y

+ ")=" + Math.pow(x, y));

System.out.println("Math.pow(" + y + "," + x

+ ")=" + Math.pow(y, x));

}

}

random() Devuelve un valor de tipo double

con signo positivo, mayor o igual

import java.util.Random;

public class Programa {


57

que cero y menor que uno 1.0. public static void main(String arg[ ]) {

Random rnd = new Random();

System.out.println("Número aleatorio

real entre [0,1[ : "+rnd.nextDouble());

}

}

rint(double a) Devuelve el valor double que es

más cercano al valor a y es igual a

un entero matemático.

import java.lang.*;




double x = 1654.9874;

double y = -9765.134;

// find the closest integers for these double

numbers

System.out.println("Math.rint(" + x + ")=" +

Math.rint(x));

System.out.println("Math.rint(" + y + ")=" +

Math.rint(y));

}

}

round(double a) Devuelve el valor long más public static double round(double value, int


58

cercano al argumento. places) {

if (places < 0) throw new

IllegalArgumentException();

long factor = (long) Math.pow(10, places);

value = value * factor;

long tmp = Math.round(value);

return (double) tmp / factor;

}

round(float a) Devuelve el valor int más cercano

al argumento.

public static BigDecimal round(float d, int

decimalPlace) {

BigDecimal bd = new

BigDecimal(Float.toString(d));

bd = bd.setScale(decimalPlace,

BigDecimal.ROUND_HALF_UP);

return bd;

}

signum(double d) La función signo, cero si el

argumento es cero, 1.0 si el

argumento es mayor que cero y -

1.0 si el argumento es menor que

cero.

import java.lang.*;




double x = 50.14;


59

double y = -4;

// call signum for both doubles and print the

result

System.out.println("Math.signum(" + x +

")=" + Math.signum(x));

System.out.println("Math.signum(" + y +

")=" + Math.signum(y));

}

}

signum(float f)120 La función signo, cero si el

argumento es cero, 1.0 si el

argumento es mayor que cero y -

1.0 si el argumento es menor que

cero.

import java.lang.*;




float x = 50.14f;

float y = -4f;

// call signum for both floats and print the result

System.out.println("Math.signum(" + x +

")=" + Math.signum(x));

System.out.println("Math.signum(" + y +

")=" + Math.signum(y));

}


60

}

sin(double a) Devuelve el seno trigonométrico

de un ángulo.

import java.lang.*;



// get two double numbers numbers

double x = 45;

double y = -180;




// print the trigonometric sine for these

doubles

System.out.println("Math.sin(" + x + ")=" +

Math.sin(x));

System.out.println("Math.sin(" + y + ")=" +

Math.sin(y)); }

}

sinh(double x) Devuelve el seno hiperbólico de

un valor double.

import java.lang.*;





61

double x = 45;

double y = -180;




// print the hyperbolic sine for these doubles

System.out.println("sinh(" + x + ")=" +

Math.sinh(x));

System.out.println("sinh(" + y + ")=" +

Math.sinh(y));

}

}

sqrt(double a) Devuelve la raíz cuadrada positiva

redondeada de un valor double.

import java.lang.*;




double x = 9;

double y = 25;

// print the square root of these doubles

System.out.println("Math.sqrt(" + x + ")=" +

Math.sqrt(x));


62

System.out.println("Math.sqrt(" + y + ")=" +

Math.sqrt(y));

}

}

tan(double a) Devuelve la tangente

trigonométrica de un ángulo.

import java.lang.*;




double x = 45;

double y = -180;

// convert them in radians



// print the tangent of these doubles

System.out.println("Math.tan(" + x + ")=" +

Math.tan(x));

System.out.println("Math.tan(" + y + ")=" +

Math.tan(y));

}

}

tanh(double x) Devuelve la tangente hiperbólica import java.lang.*;


63

de un valor double. public class MathDemo {



double x = 45;

double y = -180;




// print the hyperbolic tangent of these doubles

System.out.println("Math.tanh(" + x + ")=" +

Math.tanh(x));

System.out.println("Math.tanh(" + y + ")=" +

Math.tanh(y));

}

}

toDegrees(double angrad) Convierte un ángulo medido en

radianes al aproximado en grados.

import java.lang.*;




double x = 45;

double y = -180;


64

// convert them in degrees

x = Math.toDegrees(x);

y = Math.toDegrees(y);

// print the hyperbolic tangent of these

doubles


Math.tanh(x));


Math.tanh(y));

}

}

toRadians(double angdeg) Convierte un ángulo medido en

grados al aproximado en radianes.

import java.lang.*;




double x = 45;

double y = -180;




// print the hyperbolic tangent of these doubles


65


Math.tanh(x));


Math.tanh(y));

}

}

ulp(double d) Ver definición en la

documentación completa.

import java.lang.*;




double x = 956.294;

double y = 123.1;

// print the ulp of these doubles

System.out.println("Math.ulp(" + x + ")=" +

Math.ulp(x));

System.out.println("Math.ulp(" + y + ")=" +

Math.ulp(y));

}

}

ulp(float f) Ver definición en la import java.lang.*;


66

documentación completa. public class MathDemo {


// get two double float numbers

float x = 956.294f;

float y = 123.1f;

// print the ulp of these floats

System.out.println("Math.ulp(" + x + ")=" +

Math.ulp(x));

System.out.println("Math.ulp(" + y + ")=" +

Math.ulp(y));

}

}

Array Objeto contenedor que almacena

una secuencia indexada de los

mismos tipos de datos.

Normalmente los elementos

individuales se referencian por

el valor de un índice.

public class Array

{

public static void main(String arg[])

{

int [] losValores = null;

losValores[4] = 100;

System.out.println(losValores[4]); }

}

Int hashCode() Este método devuelve un código import java.lang.*;


67

hash de este objeto Boolean. public class BooleanDemo {


// create 2 Boolean objects b1, b2

Boolean b1, b2;

// assign values to b1, b2

b1 = new Boolean(true);

b2 = new Boolean(false);

// create 2 int primitives

int i1, i2;

// assign the hash code of b1, b2 to i1, i2

i1 = b1.hashCode();

i2 = b2.hashCode();

String str1 = "Hash code of " + b1 + " is " +i1;

String str2 = "Hash code of " + b2 + " is " +i2;

// print i1, i2 values

System.out.println( str1 );


}

}

In compareTo(Boolean b) Este método compara esta import java.lang.*;


68

instancia de Boole con otro. public class BooleanDemo {


// create 2 Boolean objects b1, b2

Boolean b1, b2;


b1 = new Boolean(true);

b2 = new Boolean(false);

// create an int res

int res;

// compare b1 with b2

res = b1.compareTo(b2);

String str1 = "Both values are equal ";

String str2 = "Object value is true";

String str3 = "Argument value is true";

if( res == 0 ){


}

else if( res > 0 ){


}

else if( res < 0 ){


69


}

}

}

Byte byteValue() Este método devuelve el valor de

este byte como un byte.

import java.lang.*;

public class ByteDemo {


// create a Byte object b

Byte b;

// assign value to b

b = new Byte("100");

// create a byte primitive bt

byte bt;

// assign primitive value of b to bt

bt = b.byteValue();

String str = "Primitive byte value of Byte

object " + b + " is " + bt;

// print bt value

System.out.println( str ); }

}

Int compareTo(Byter Este método compara dos objetos import java.lang.*;


70

anotherByte) Byte numéricamente. public class ByteDemo {


// create 2 Byte objects b1, b2

Byte b1, b2;


b1 = new Byte("-100");

b2 = new Byte("10");

// create an int res

int res;

// compare b1 with b2 and assign result to res

res = b1.compareTo(b2);

String str1 = "Both values are equal ";

String str2 = "First value is greater";

String str3 = "Second value is greater";

if( res == 0 ){


}

else if( res > 0 ){


}

else if( res < 0 ){


71


}

}

}

Static byte decode(String nm) Este método decodifica una

cadena en un byte.

import java.lang.*;



// create 4 Byte objects

Byte b1, b2, b3, b4;

/**

* static methods are called using class name.

* decimal value is decoded and assigned

to Byte object b1 */

b1 = Byte.decode("100");

// hexadecimal values are decoded and

assigned to Byte objects b2, b3

b2 = Byte.decode("0x6b");

b3 = Byte.decode("-#4c");

// octal value is decoded and assigned to

Byte object b4

b4 = Byte.decode("0127");


72

String str1 = "Byte value of decimal 100

is " + b1;

String str2 = "Byte value of hexadecimal 6b

is " + b2;

String str3 = "Byte value of hexadecimal -4c

is " + b3;

String str4 = "Byte value of octal 127 is " +

b4;

// print b1, b2, b3, b4 values





}

}

Double doubleValue() Este método devuelve el valor de

este byte como un doble.

import java.lang.*;




Byte b1, b2;

// create 2 double primitives d1, d2


73

double d1, d2;


b1 = new Byte("100");

b2 = new Byte("-10");

// assign double values of b1, b2 to d1, d2

d1 = b1.doubleValue();

d2 = b2.doubleValue();

String str1 = "double value of Byte " + b1 + "

is " + d1;

String str2 = "double value of Byte " + b2 + "

is " + d2;

// print d1, d2 values



}

}

Boolean equals(Object obj) Este método compara este objeto

para el objeto especificado.

import java.lang.*;




Byte b1, b2;


74

// create 2 boolean primitives bool1, bool2

boolean bool1, bool2;


b1 = new Byte("100");

b2 = new Byte("100");

// compare b1 and b2 and assign result to

bool1

bool1 = b1.equals(b2);

/**

* compare b1 with object 100 and assign

result to bool2, it

* returns false as 100 is not a Byte object

*/

bool2 = b1.equals("100")

String str1 = b1 + " equals " + b2 + " is " +

bool1;

String str2 = b1 + " equals object value 100

is " + bool2;

// print bool1, bool2 values


System.out.println( str2 ); }


75

}

Float floatValue() Este método devuelve el valor de

este byte como un flotador.

import java.lang.*;




Byte b1, b2;

// create 2 float primitives f1, f2

float f1, f2;


b1 = new Byte("100");

b2 = new Byte("-10");

// assign float values of b1, b2 to f1, f2

f1 = b1.floatValue();

f2 = b2.floatValue();

String str1 = "float value of Byte " + b1 + " is

" + f1;

String str2 = "float value of Byte " + b2 + " is

" + f2;

// print f1, f2 values


System.out.println( str2 ); }


76

}

investigación y complemento del compilador

Documents