GUIA DE JAVA

PARA COMPETENCIAS ICPC

JOSE GONZALO ESPEJO CUBA

TIPOS DE DATOS

Palabra Tamaño Rango

TIPO
reservada en bits Min Max
Lógico bool false true
Caractér char 16 bits '\u0000 ' '\uFFFF '
Entero byte byte 8 bits -128 127
Entero short short 16 bits -32768 32767
Entero int int 32 bits -2147483648 2147483647
Entero long long 64 bits -9223372036854775808 9223372036854775807
–3.4028234663852886E+38 a 1.40129846432481707e–45 a
Real float float 32 bits
–1.40129846432481707e–45 3.4028234663852886E+38
–1.7976931348623157E+308 a 4.94065645841246544e–324 a
Real double double 64 bits
–4.94065645841246544e–324 1.7976931348623157E+308
Cadena String
2 José Gonzalo Espejo Cuba
GUIA DE JAVA

CONTENIDO
1 ENTRADA Y SALIDA DE DATOS EN JAVA 5
1.1 ENTRADA Y SALIDA POR FLUJOS (JAVA.UTIL.SCANNER) 5
1.2 LECTURA DE LINEAS JAVA.UTIL.SCANNER 5
1.3 MANEJO DE LA LECTURA DE LINEAS (JAVA.UTIL.SCANNER) 6
1.4 ENTRADA DE DATOS HASTA EL FIN DE ARCHIVO (JAVA.UTIL.SCANNER) 6
1.5 IMPRESIÓN DE NUMEROS ENTEROS CON PRINTF 7
1.6 MANIPULACION DE LA COMA FLOTANTE CON PRINTF 7
1.7 PRECISION DE COMA FLOTANTE CON PRINTF 7
1.8 CAMPO DE IMPRESION Y ALINEACION CON PRINTF 8
1.9 IMPRESIÓN DE CADENAS Y CARACTERES CON PRINTF 8
1.10 LECTURA DE DATOS MEDIANTE BUFFEREDREADER 8
1.11 LECTURA Y ESCRITURA DE ARCHIVOS 9

2 LIBRERIAS DE MATEMATICAS 10
2.1 FUNCIONES DE JAVA.LANG.MATH 10
2.1.1 FUNCIONES TRIGONOMETRICAS 10
2.1.2 FUNCIONES HIPERBOLICAS 10
2.1.3 FUNCIONES EXPONENCIALES Y LOGARITMICAS 10
2.1.4 FUNCIONES DE POTENCIA 11
2.1.5 FUNCIONES DE REDONDEO 11
2.1.6 FUNCIONES DE VALOR ABSOLUTO 11
2.1.7 NUMEROS ALEATORIOS 11
2.1.8 MIN Y MAX 11
2.2 JAVA BIGINTEGER 12
2.2.1 CONSTRUCTORES Y ASIGNACION DE BIGINTEGER 12
2.2.2 OPERACIONES ARITMETICAS 12
2.2.3 OPERACIONES A NIVEL DE BITS 14
2.2.4 COMPARACION DE BIGINTEGERS 15
2.2.5 VALORES MAXIMOS Y MINIMOS 15
2.2.6 TRANSFORMACION DE BIGINTEGERS A VALORES NUMERICOS Y CADENAS 16
2.2.7 FIBONACCI Y FACTORIAL 16
2.3 JAVA BIGDECIMAL 17
2.3.1 CONSTRUCTORES Y ASIGNACION DE BIGINTEGER 17
2.3.2 OPERACIONES ARITMETICAS 18
2.3.3 OPERACIONES DE COMA FLOTANTE 20
2.3.4 COMPARACION DE BIGDECIMALS 21
2.3.5 VALORES MAXIMOS Y MINIMOS 21
2.3.6 TRANSFORMACION DE BIGDECIMALS A VALORES NUMERICOS Y CADENAS 22
2.3.7 HERRAMIENTAS DE MATHCONTEXT 23

3 CADENAS Y CARACTERES 24
3.1 LA CLASE STRING 24
3.1.1 CONSTRUCTORES DE STRING 24
3.1.2 CONCATENACION Y ASIGNACION DE CADENAS 24
3.1.3 REEMPLAZO DE CADENAS 24
3.1.4 LONGITUD DE CADENAS 25
3.1.5 SUBCADENAS 25
3.1.6 LOCALIZACION DE SECUENCIAS DE CARACTERES 26
3.1.7 COMPARACION DE STRINGS 26
3.2 CLASE STRING BUILDER 27
3.2.1 CONSTTRUCTORES 27
3.2.2 CONCATENACION DE CADENAS 27
3.2.3 INSERCCION Y ELIMINACION DE CARACTERES 28
3.2.4 REEMPLAZO DE SECUENCIA DE CARACTERES 29
3.2.5 LONGITUD DE CADENAS 29
3.2.6 SUBCADENAS 29
3.2.7 LOCALIZACION DE SECUENCIAS DE CARACTERES Y METODO REVERSE 30
3.2.8 COMPARACION DE STRINGBUILDER 30
3.3 CARACTERES 31
3.3.1 OBTENCION DE UN CHAR [] A PARTIR DE UNA CADENA 31
3.3.2 OBTENCION DE CARACTERES 31
3.3.3 CLASIFICACION DE CARACTERES 32
3.3.4 CONVERSIONES DE CARACTERES DE MAYUSCULA A MINUSCULA 33
3.4 CONVERSION DE CADENAS 33
 José Gonzalo Espejo Cuba 3
GUIA DE JAVA

3.4.1 CONVERSION A MAYUSCULAS Y MINUSCULAS 33

3.4.2 CONVERSION DE CADENAS A NUMEROS 33
3.4.3 CONVERSION DE NUMEROS A CADENAS 34
3.5 JAVA STRINGTOKENIZER 34

4 VECTORES Y MATRICES 36
4.1 CREACION DE VECTORES Y MATRICES 36
4.1.1 CREACION DE VECTORES 36
4.1.2 CREACION DE MATRICES 36
4.2 METODOS GENERICOS 37

5 PROGRAMACION ORIENTADA A OBJETOS 39

5.1 DEFINICION DE CLASES Y CONSTRUCTORES 39
5.1.1 DEFINIENDO UNA CLASE 39
5.1.2 CONSTRUCTORES 39
5.2 FUNCIONES Y METODOS MIEMBROS DE UNA CLASE 40
5.2.1 EMPLEO DE LAS METODOS MIEMBRO 40
5.2.2 SOBRECARGA DE METODOS 41
5.3 ACCESO A LOS DATOS DE UNA CLASE 42
5.3.1 METODOS GET Y SET (DATOS DE TIPO PRIVADO ENCAPSULADOS) 42
5.3.2 ACCESO A DATOS DIRECTAMENTE (SIN ENCAPSULACION) 43
5.4 HERENCIA 44
5.5 COMPOSICION 45
5.5.1 EJEMPLO SIMPLE 45

6 CONTENEDORES DE JAVA 46
6.1 VECTORS (VECTORES) 46
6.1.1 INSERCCION DE ELEMENTOS 46
6.1.2 ELIMINACION DE DATOS DEL VECTOR 47
6.1.3 REEMPLAZO DE DATOS EN UN VECTOR 48
6.1.4 CAPACIDAD Y TAMAÑO DEL VECTOR 48
6.1.5 ELEMENTOS DEL VECTOR 49
6.1.6 COMPARACION Y BUSQUEDA DE SECUENCIA DE DATOS 50
6.2 STACKS (PILAS) 51
6.3 QUEUES (COLAS) 51
6.4 COLA DE PRIORIDADES 52
6.4.1 COLA DE PRIORIDADES DE DATOS PRIMITIVOS 52
6.4.2 COLA DE PRIORIDADES DE CLASES 52
6.5 DEQUES (BICOLAS) 54
6.6 LISTAS 56
6.6.1 INSERCCION DE DATOS EN LAS LISTAS 56
6.6.2 ELIMINACION DE DATOS DE LA LISTA 56
6.6.3 REEMPLAZO DE DATOS EN LA LISTA 57
6.6.4 CAPACIDAD Y TAMAÑO DE LA LISTA 58
6.6.5 ELEMENTOS DE LA LISTA 58
6.6.6 BUSQUEDA Y COMPARACION DE SECUENCIA DE DATOS 59
6.7 CONJUNTOS 60
6.7.1 INSERCCION DE DATOS 60
6.7.2 ELIMINACION DE DATOS 61
6.7.3 CAPACIDAD Y TAMAÑO DEL CONJUNTO 62
6.7.4 BUSQUEDA Y COMPARACION DE SECUENCIA DE DATOS 62
6.8 MAPAS 63
6.8.1 INSERCCION DE DATOS 63
6.8.2 ELIMINACION DE DATOS 64
6.8.3 CAPACIDAD Y TAMAÑO DEL MAPA 65
6.8.4 BUSQUEDA DE DATOS 65

7 ALGORITMOS DE JAVA 67
7.1 ALGORITMO ADDALL 67
7.2 ALGORITMO DE BUSQUEDA BINARIA (BINARY SEARCH) 67
7.2.1 BYNARY SEARCH DE LA CLASE ARRAY 67
7.2.2 BYNARY SEARCH DE LA CLASE COLLECTIONS 68
7.3 ALGORITMOS DE COPIA 68
7.3.1 ALGORITMOS COPY EN LA CLASE COLLECTIONS 68
7.3.2 ALGORITMOS COPY EN LA CLASE ARRAYS 69
7.4 ALGORITMO DISJOINT 69
4 José Gonzalo Espejo Cuba
GUIA DE JAVA

7.5 ALGORITMO DE COMPARACION EQUALS PARA ARRAYS 70

7.6 ALGORITMOS FILL 70
7.6.1 ALGORITMO FILL PARA LA CLASE COLLECTIONS 70
7.6.2 ALGORITMO FILL PARA LA CLASE ARRAYS 71
7.7 ALGORITMO FREQUENCY 71
7.8 ALGORITMOS MAX Y MIN 71
7.9 ALGORITMOS REPLACEALL 71
7.10 ALGORITMO REVERSE 72
7.11 ALGORITMO ROTATE 72
7.12 ALGORITMOS DE ORDENAMIENTO 73
7.12.1 ALGORITMO SORT DE LA CLASE COLECTIONS 73
7.12.2 ALGORITMO SORT DE LA CLASE ARRAY 73
7.13 ALGORITMO SHUFFLE 74
7.14 ALGORITMO SWAP 74
7.15 ALGORITMO TOSTRING 74
7.16 UTILIZANDO COMPARADORES EN SORT, BINARY SEARCH, MAX Y MIN 75
7.16.1 COMPARADORES CON COLLECTIONS 75
7.16.2 COMPARADORES CON ARRAYS 76

8 MISCELANEA 78
8.1 SECUENCIA FOR MEJORADA 78
8.1.1 FOR DE ARRAYS 78
8.1.2 FOR DE COLLECTIONS 78
8.2 EXCEPCIONES 78
8.2.1 EXCEPCION EN LA LECTURA DE ENTEROS 78
8.2.2 EXCEPCION EN DIVISION ENTRE CERO 78
8.2.3 ESTRUCTURA GENERAL DE UN PROGRAMA CON EXCEPCION 79
8.3 MANEJO DEL TIEMPO EN JAVA 79
8.3.1 JAVA DATE 79
8.3.2 JAVA CALENDAR 81
8.3.3 GREGORIAN CALENDAR 83
8.4 OTROS METODOS DE REDONDEO 83
8.4.1 DECIMAL FORMAT 83
8.4.2 REDONDEO CON BIGDECIMAL 83
8.4.3 REDONDEO CON JAVA.LANG.MATH 84
8.5 LIMITES DE TIPOS DE DATOS PRIMITIVOS 84
8.6 TRANSFORMACION DE DATOS PRIMITIVOS A BINARIO, OCTAL Y HEXADECIMAL 84
8.7 OPERACIONES DE BITS 85
8.8 PLANTILLA PARA COMPETENCIAS 85
 José Gonzalo Espejo Cuba 5
GUIA DE JAVA

1 ENTRADA Y SALIDA DE DATOS EN JAVA

1.1 ENTRADA Y SALIDA POR FLUJOS (JAVA.UTIL.SCANNER)

import java.util.Scanner;//Libreria para la entrada y salida de datos desde teclado

public class entrada_simple {
public static void main(String[] args) {
//Creamos un objeto scanner para la entrada y salida de datos
Scanner leer=new Scanner(System.in);

//DECLARANDO VARIABLES
//NUMEROS ENTEROS
byte num1;//Numero entero byte
short num2;//Numero entero short
int num3;//Numero entero int
long num4;//Numero entergo long
//NUMEROS REALES
float realf;
double reald;
//CADENAS
String cadena;

//LECTURA DE DATOS
System.out.println("Introduzca cuatro numeros enteros");//Impresion de mensaje
num1=leer.nextByte();//Lectura de un numero de tipo byte
num2=leer.nextShort();//Lectura de un numero de tipo short
num3=leer.nextInt();//Lectura de un numero de tipo int
num4=leer.nextLong();//Lectura de un numero de tipo long
System.out.println("Introduzca dos numeros reales");//Impresion de mensaje
realf=leer.nextFloat();//Lectura de un numero de tipo float
reald=leer.nextDouble();//Lectura de un numero de tipo double
System.out.println("Introduzca una cadena");//Impresion de mensaje
cadena=leer.next();//Lectura de una cadena

//MOSTRANDO LOS DATOS

System.out.println("El dato entero muy pequeño introducido es: "+num1);
System.out.println("El dato entero pequeño introducido es: "+num2);
System.out.println("El dato entero introducido es: "+num3);
System.out.println("El dato entero grande introducido es: "+num4);
System.out.println("El dato real float introducido es: "+realf);
System.out.println("El dato real double introducido es: "+reald);
System.out.println("La cadena introducida es: "+cadena);
}
}

1.2 LECTURA DE LINEAS JAVA.UTIL.SCANNER

import java.util.Scanner;//Libreria para la entrada y salida de datos desde teclado

public class lectura_lineas {
public static void main(String[] args) {
Scanner leer=new Scanner(System.in);
String linea;
linea=leer.nextLine();//Lectura de una linea
System.out.println("La linea leida es: "+linea);
}
}
6 José Gonzalo Espejo Cuba
GUIA DE JAVA

1.3 MANEJO DE LA LECTURA DE LINEAS (JAVA.UTIL.SCANNER)

import java.util.Scanner;//Libreria para la entrada y salida de datos desde teclado

public class manejo_lineas1 {
/*Programa que lee primero un numero entero n y despues lee n lineas*/
public static void main(String[] args) {
Scanner leer=new Scanner(System.in);
int n=leer.nextInt();
String linea;
for(int i=0;i<=n;i++){
linea=leer.nextLine();//Lectura de una linea
if(i>0)
System.out.println("La linea leida "+i+" es: "+linea);
}
}
}
import java.util.Scanner; //Libreria para la entrada y salida de datos desde teclado
public class manejo_lineas2 {
/*Programa que lee primero un numero entero n y despues lee n lineas*/
public static void main(String args[]){
Scanner leer=new Scanner(System.in);
int n=leer.nextInt();
String linea;
leer.nextLine();//Interrumpimos el flujo de entrada
for(int i=1;i<=n;i++){
linea=leer.nextLine();//Lectura de una linea
System.out.println("La linea leida "+i+" es: "+linea);
}
}
}
import java.util.Scanner; //Libreria para la entrada y salida de datos desde teclado
public class manejo_lineas3 {
//Lectura de una linea seguida de una lectura de dos enteros
//Se imprime la linea leida y la suma de dos enteros
public static void main(String args[]){
Scanner leer=new Scanner(System.in);
int a,b;
String linea;
while(leer.hasNextLine()){
a=leer.nextInt();
b=leer.nextInt();
leer.nextLine();//Interrumpimos el flujo de entrada
linea=leer.nextLine();
System.out.println(linea+" | "+(a+b));
}
}
}

1.4 ENTRADA DE DATOS HASTA EL FIN DE ARCHIVO (JAVA.UTIL.SCANNER)

while(leer.hasNextByte()){//Lectura de datos tipo byte

//CODIGO
}
while(leer.hasNextShort()){//Lectura de datos tipo short
//CODIGO
}
while(leer.hasNextInt()){//Lectura de datos tipo int
//CODIGO
}
 José Gonzalo Espejo Cuba 7
GUIA DE JAVA

while(leer.hasNextLong()){//Lectura de datos tipo long

//CODIGO
}
while(leer.hasNextFloat()){//Lectura de datos tipo float
//CODIGO
}
while(leer.hasNextDouble()){//Lectura de datos tipo double
//CODIGO
}
while(leer.hasNext()){//Lectura de datos tipo string
//CODIGO
}
while(leer.hasNextLine()){//Lectura de líneas de cadenas
//CODIGO
}

1.5 IMPRESIÓN DE NUMEROS ENTEROS CON PRINTF

public class impresion_enteros {

public static void main(String[] args) {
int num=27;
System.out.printf("Base 10: %d\n",num);//Imprime: Base 10: 27
System.out.printf("Base 8: %o\n",num);//Imprime: Base 8: 33
System.out.printf("Base 16: %x\n",num);//Imprime: Base 16: 1b
System.out.printf("Base 16: %X\n",num);//Imprime: Base 16: 1B
}
}

1.6 MANIPULACION DE LA COMA FLOTANTE CON PRINTF

public class manipulacion_coma_flotante {

public static void main(String[] args) {
double num=(double)Math.sqrt(2);
System.out.printf("%f\n",num);//Imprime: 1,414214
System.out.printf("%e\n",num);//Imprime: 1,414214e+00
System.out.printf("%E\n",num);//Imprime: 1,414214E+00
System.out.printf("%g\n",num);//Imprime: 1,41421
System.out.printf("%G\n",num);//Imprime: 1,41421
}
}

1.7 PRECISION DE COMA FLOTANTE CON PRINTF

public class precision {

public static void main(String[] args) {
double num=(double)Math.sqrt(2.0);
//Redondeando el numero a 4 decimales
System.out.printf("%.4f\n",num);//Imprime: 1,4142
//Redondeando el numero a 7 decimales
System.out.printf("%.7f\n",num);//Imprime: 1,4142136
num=num*1000;
System.out.printf("%.4f\n",num);//Imprime: 1414,2136
System.out.printf("%,.4f\n",num);//Imprime: 1.414,2136
}
}
8 José Gonzalo Espejo Cuba
GUIA DE JAVA

1.8 CAMPO DE IMPRESION Y ALINEACION CON PRINTF

public class campo_impresion_alineacion {

public static void main(String args[]){
int n=128;
System.out.println("Alineacion a la derecha");
System.out.println("Campo de impresion de tamaño 7");
System.out.printf("%7d\n",n);//Imprime: ' 128'
System.out.println("\nAlineacion a la izquierda");
System.out.println("Campo de impresion de tamaño 7");
System.out.printf("%-7d\n",n);//Imprime: '128 '
System.out.println("\nColocando ceros a la izquierda de un numero entero");
System.out.println("Campo de impresion de tamaño 7");
System.out.printf("%07d\n",n);//Imprime: '0000128'
System.out.println("\nUn espacio en blanco antes de imprimir un entero");
System.out.printf("% d\n",n);//Imprime: ' 128'
System.out.println("\nMostrando el signo positivo");
System.out.printf("%+d\n",n);//Imprime: '+128'
}
}

1.9 IMPRESIÓN DE CADENAS Y CARACTERES CON PRINTF

public class impresion_cadenas_caracteres {

public static void main(String[] args) {
char caracter= 'a'; // inicializa el char
String cadena = "Esta tambien es una cadena"; // objeto String
Integer entero = 1234; // inicializa el entero (autoboxing)
System.out.printf("%c\n", caracter);//Imprime: a
System.out.printf("%C\n", caracter);//Imprime: A
System.out.printf("%s\n", "Esta es una cadena");//Imprime: Esta es una cadena
System.out.printf("%s\n", cadena);//Imprime: Esta tambien es una cadena
System.out.printf("%S\n", cadena);//Imprime: ESTA TAMBIEN ES UNA CADENA
System.out.printf("%s\n", entero);//llamada implícita a toString Imprime: 1234
}
}

1.10 LECTURA DE DATOS MEDIANTE BUFFEREDREADER

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class BR {
/*PROGRAMA QUE LEE TRES NUMEROS ENTEROS Y LOS SUMA*/
static String leerdato(){
BufferedReader entrada=new BufferedReader(new InputStreamReader(System.in));
String dato="";
try{
dato=entrada.readLine();
}
catch(IOException e){};
return dato;
}
public static void main(String args[]){
BR lectura=new BR();
int a,b,c;
a=Integer.parseInt(lectura.leerdato());//Transformamos a entero
b=Integer.parseInt(lectura.leerdato());//Transformamos a entero
c=Integer.parseInt(lectura.leerdato());//Transformamos a entero
System.out.println("La suma es: "+(a+b+c));
 José Gonzalo Espejo Cuba 9
GUIA DE JAVA

}
}

Precaución, la lectura de los datos de este programa, es un dato por linea. Tener cuidado cuando se trata de leer dos o mas
datos en un sola línea.

1.11 LECTURA Y ESCRITURA DE ARCHIVOS

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
public class Lectura_escritura_archivos {
/**
Programa que lee un archivo de entrada, este archivo tiene en cada linea dos
enteros; Despues de leer los enteros suma los dos numeros y almacena la suma en un
archivo de salida
*/
static Scanner entrada;//Objeto para leer el archivo de entrada
static DataOutputStream salida;//Objeto para escribir el archivo de salida
//Metodo para leer el archivo de entrada
static void LeerArchivo(){
try{//Busca el archivo y lo lee
entrada=new Scanner(new File("F:/input.txt"));
}
catch(FileNotFoundException file){
System.err.println("Error al abrir el archivo");
System.exit(1);
}
}
//Metodo para escribir el archivo de entrada
static void EscribirArchivo(String cad){
try{
salida=new DataOutputStream(new FileOutputStream("F:/output.txt"));
salida.writeBytes(cad);
}
catch(IOException e){
System.out.println("Error al escribir en el archivo");
}
}
public static void main(String[] args) {
int a,b;
LeerArchivo();
String respuesta="";
while(entrada.hasNext()){
a=entrada.nextInt();
b=entrada.nextInt();
//Almacenamos las respuestas en una cadena
respuesta=respuesta+Integer.toString(a+b)+"\n";
}
EscribirArchivo(respuesta);//La cadena estara escrita en el archivo de salida
}
}
10 José Gonzalo Espejo Cuba
GUIA DE JAVA

2 LIBRERIAS DE MATEMATICAS

2.1 FUNCIONES DE JAVA.LANG.MATH

2.1.1 FUNCIONES TRIGONOMETRICAS

public class funciones_trigonometricas {

public static void main(String args[]){
double num=45;
double pi=Math.PI;//Esta funcion obtiene el PI

System.out.println("FUNCION COSENO");
System.out.printf("coseno en grados: %.5f\n",Math.cos(num*pi/180));//0,70711
System.out.printf("coseno en radianes: %.5f\n",Math.cos(num));//0,52532

System.out.println("\nFUNCION SENO");
System.out.printf("seno en grados: %.5f\n",Math.sin(num*pi/180));//0,70711
System.out.printf("seno en radianes: %.5f\n",Math.sin(num));//0,85090

System.out.println("\nFUNCION TANGENTE");
System.out.printf("tangente en grados: %.5f\n",Math.tan(num*pi/180));//1,00000
System.out.printf("tangente en radianes: %.5f\n",Math.tan(num));//1,61978

num=0.1224;
System.out.println("\nFUNCION ARCO COSENO");
System.out.printf("arco-coseno en grados: %.5f\n",Math.acos(num)*180/pi);//82,96937
System.out.printf("arco-coseno en radianes: %.5f\n",Math.acos(num));//1,44809

System.out.println("\nFUNCION ARCO SENO");

System.out.printf("arco-seno en grados: %.5f\n",Math.asin(num)*180/pi);//7.030634
System.out.printf("arco-seno en radianes: %.5f\n",Math.asin(num));// 0,12271

System.out.println("\nFUNCION ARCO TANGENTE");

System.out.printf("arco-tan en grados: %.5f\n",Math.atan(num)*180/pi);// 6,97829
System.out.printf("arco-tan en radianes: %.5f\n",Math.atan(num));// 0,12179
}
}

2.1.2 FUNCIONES HIPERBOLICAS

public class funciones_hiperbolicas {

public static void main(String args[]){
double num=0.45;
System.out.printf("coseno hiperbolico: %.5f\n",Math.cosh(num));//1,10297
System.out.printf("seno hiperbolico: %.5f\n",Math.sinh(num));//0,46534
System.out.printf("tangente hiperbolico: %.5f\n",Math.tanh(num));//0,42190
}
}

2.1.3 FUNCIONES EXPONENCIALES Y LOGARITMICAS

public class Funciones_exponenciales_logaritmicas {

public static void main(String[] args) {
System.out.println("BASE PARA LOGARITMOS NATURALES");
System.out.printf("e: %.5f\n",Math.E);//2,71828

System.out.println("\nFUNCION EXP");
System.out.printf("Exponencial de %d: %.5f\n",8,Math.exp(8));//2980,95799

System.out.println("\nFUNCION GETEXP");
 José Gonzalo Espejo Cuba 11
GUIA DE JAVA

System.out.printf("2^%d=%d\n",Math.getExponent(8),8);//2^3=8
System.out.printf("2^%d=%d\n",Math.getExponent(17),17);//2^4=17
System.out.printf("2^%d=%d\n",Math.getExponent(32),32);//2^5=32

System.out.println("\nFUNCION LOG");
System.out.printf("Logaritmo natural de %d: %.5f\n",8,Math.log(8));//2,07994

System.out.println("\nFUNCION LOG10");
System.out.printf("Logaritmo en base 10 de %d: %.5f\n",8,Math.log10(8));//0,90309
}
}

2.1.4 FUNCIONES DE POTENCIA

public class Funciones_potencia {

public static void main(String[] args) {
System.out.println("3^4 = "+(int)Math.pow(3, 4));//Imprime: 3^4 = 81
System.out.println("Raiz cuadrada de 9: "+(int)Math.sqrt(9));// 3
System.out.printf("Raiz cuarta de 9: %.5f\n",Math.pow(9, 1/4.0));// 1,73205
}
}

2.1.5 FUNCIONES DE REDONDEO

public class Funciones_redondeo {

public static void main(String[] args) {
double num=12/5.0;
System.out.println("El dato original: "+num);//2.4
System.out.println("Redondeando al primer numero entero mas grande: "+(int)Math.ceil(num));//3
System.out.println("Redondeando al primer numero entero mas pequeño: "+(int)Math.floor(num));//2
}
}

2.1.6 FUNCIONES DE VALOR ABSOLUTO

public class Funciones_valor_absoluto {

public static void main(String[] args) {
System.out.println("Valor absoluto entre 5 y 7: "+Math.abs(5-7));//2
}
}

2.1.7 NUMEROS ALEATORIOS

public class Funciones_valor_absoluto {

public static void main(String[] args) {
System.out.println("Numero aleatorio del 1 al 10: "+(int)(Math.random()*10));
System.out.println("Numero aleatorio del 1 al 100: "+(int)(Math.random()*100));
System.out.println("Numero aleatorio del 1 al 1000: "+(int)(Math.random()*1000));
}
}

2.1.8 MIN Y MAX

public class Min_max {

public static void main(String[] args) {
System.out.println("MAX");
12 José Gonzalo Espejo Cuba
GUIA DE JAVA

System.out.println("El mayor de 5 y 7 es: "+Math.max(5, 7));// 7

System.out.println("El mayor de 2.56 y 2.55 es: "+Math.max(2.56, 2.55));// 2.56

System.out.println("\nMIN");
System.out.println("El menor de 5 y 7 es: "+Math.min(5, 7));// 5
System.out.println("El menor de 2.56 y 2.55 es: "+Math.min(2.56, 2.55));// 2.55
}
}

2.2 JAVA BIGINTEGER

2.2.1 CONSTRUCTORES Y ASIGNACION DE BIGINTEGER

import java.math.BigInteger;//Libreria para JAVA BigInteger

public class biginteger_constructors {
public static void main(String args[]){
//DECLARACION DE OBJETOS BIGINTEGER
BigInteger b1, b2, b3, b4, b5,b6;

//CREACION DE BIGINTEGER
b1=new BigInteger("39992278782225436547665732323554656");
b3=b4=b5=b6=new BigInteger("0");

//ASIGNACION DR BIGINTEGER
b2=b1;//Asignando b1 a biginteger b2;
b3=b3.valueOf(24354);//Asignado un numero entero a b3
b4=b4.ZERO;//Asignado 0 a b4
b5=b5.ONE;//Asignado 1 a b5
b6=b6.TEN;//Asignado 10 a b6

//MOSTRANDO DATOS
System.out.println(b1);//Muestra: 39992278782225436547665732323554656
System.out.println(b2);//Muestra: 39992278782225436547665732323554656
System.out.println(b3);//Muestra: 24354
System.out.println(b4);//Muestra: 0
System.out.println(b5);//Muestra: 1
System.out.println(b6);//Muestra: 10
}
}
BigInteger b Declara un objeto BigInteger b.
b=new BigInteger("554656") Crea un objeto BigInteger b que contiene un valor numérico, su constructor recibe
un parámetro de cadena numérica para inicializar el BigInteger b.
B1=B2 Donde B1 y B2 son objetos BigInteger, el operador de asignación = asigna el valor
de B2 a B1.
valueOf(num) Donde num es un número entero. La función valueOf retorna un BigInteger que
tiene el valor de num.
ZERO Retorna un BigInteger que tiene el valor de 0.
ONE Retorna un BigInteger que tiene el valor de 1.
TEN Retorna un BigInteger que tiene el valor de 10.

2.2.2 OPERACIONES ARITMETICAS

import java.math.BigInteger; //Libreria para JAVA BigInteger

public class biginteger_opertaciones_aritmeticas {
public static void main(String[] args) {
BigInteger b1,b2,b3,suma,resta,va,producto,division,gcd,residuo,potencia,negativo;
 José Gonzalo Espejo Cuba 13
GUIA DE JAVA

b1=new BigInteger("48");
b2=new BigInteger("56");
b3=new BigInteger("23");

//SUMA DE BIGINTEGER
suma=b1.add(b2);
//RESTA DE BIGINTEGER
resta=b1.subtract(b2);
//VALOR ABSOLUTO
va=resta.abs();
//PRODUCTO
producto=b1.multiply(b2);
//DIVISION
division=b2.divide(b1);
//MODULO
residuo=b2.mod(b1);//tambien b2.remainder(b1)
//MAXIMO COMUN DIVISOR
gcd=b2.gcd(b1);
//POTENCIA
potencia=b1.pow(3);//Elevando b1 a 3
//VALOR NEGATIVO
negativo=b1.negate();

System.out.println(suma);//Muestra: 104
System.out.println(resta);//Muestra: -8
System.out.println(va);//Muestra: 8
System.out.println(producto);//Muestra: 2688
System.out.println(division);//Muestra: 1
System.out.println(residuo);//Muestra: 8
System.out.println(gcd);//Muestra: 8
System.out.println(potencia);//Muestra: 110592
System.out.println(negativo);//Muestra: -48

//ANALISIS DE NUMEROS PRIMOS

if(b3.isProbablePrime(100))//Es primo b3? (certeza de 100%)
System.out.println("YES");
else
System.out.println("NO");
//Muestra: YES
}
}
B1.add(B2) Donde B1 y B2 son objetos BigInteger, la función add devuelve un BigInteger que es la
suma: B1 + B2.
B1.substract(B2) Donde B1 y B2 son objetos BigInteger, la función substract devuelve un BigInteger que es la
resta: B1 - B2.
B.abs() Donde B es un objeto BigInteger, la función abs devuelve un BigInteger que es el valor
absoluto de B.
B1.multiply(B2) Donde B1 y B2 son objetos BigInteger, la función multiply devuelve un BigInteger que es el
producto: B1 * B2.
B1.divide(B2) Donde B1 y B2 son objetos BigInteger, la función divide devuelve un BigInteger que es la
división: B1 / B2.
B1.mod(B2) Donde B1 y B2 son objetos BigInteger, la función mod devuelve un BigInteger que es el
residuo: B1 % B2.
B1.remainder(B2) Donde B1 y B2 son objetos BigInteger, la función remainder devuelve un BigInteger que es
el residuo: B1 % B2.
B1.modInverse(B2) Donde B1 y B2 son objetos BigInteger, la función modInverse devuelve un BigInteger que
es el residuo: B2 % B1.
14 José Gonzalo Espejo Cuba
GUIA DE JAVA

B1.gcd(B2) Donde B1 y B2 son objetos BigInteger, la función gcd devuelve un BigInteger que es el
máximo común divisor.
B.pow(n) Donde B es un objeto BigInteger y n es un numero entero, la función pow devuelve un
BigInteger que es la potencia: B ^ n.
B.negate() Donde B es un objeto BigInteger, la función negate devuelve un BigInteger que es el valor
negativo de B.
isProbablePrime(cert) Donde cert es la certeza, la función isProbablePrime devuelve true (verdadero) si el
BigInteger es primo, caso contrario devuelve false (falso), cuando cert es menor o igual a 0,
la respuesta será true.

2.2.3 OPERACIONES A NIVEL DE BITS

import java.math.BigInteger; //Libreria para JAVA BigInteger

public class biginteger_operaciones_bits {
public static void main(String[] args) {
BigInteger b1,b2;
b1=new BigInteger("48");//Valor en bits: 110000
b2=new BigInteger("57");//Valor en bits: 111001
System.out.println("48 and 57 = "+b1.and(b2));//48
System.out.println("48 and ~57 = "+b1.andNot(b2));//0
System.out.println("48 or 57 = "+b1.or(b2));//57
System.out.println("48 xor 57 = "+b1.xor(b2));//9
System.out.println("48 << 3 = "+b1.shiftLeft(3));//384
System.out.println("48 >> 3 = "+b1.shiftRight(3));//6
System.out.println("~48 = "+b1.not());//-49
System.out.println("57 - 2^0 = "+b2.clearBit(0));//56
System.out.println("57 - 2^4 = "+b2.clearBit(4));//41
System.out.println("57 - 2^5 = "+b2.clearBit(5));//25
System.out.println("flip bit 0 de 57: "+b2.flipBit(0));//56
System.out.println("flip bit 1 de 57: "+b2.flipBit(1));//59
System.out.println("flip bit 5 de 57: "+b2.flipBit(5));//25
System.out.println("Numeros de bits encendidos en 48: "+b1.bitCount());//2
System.out.println("Numeros de bits encendidos en 57: "+b2.bitCount());//4
System.out.println("Longitud de bits en 48: "+b1.bitLength());//6
System.out.println("Longitud de bits en 57: "+b2.bitLength());//6
if(b1.signum()==1)
System.out.println("El biginteger b1 es mayor a 0");
else{
if(b1.signum()==-1)
System.out.println("El biginteger b1 es menor a 0");
else
System.out.println("El biginteger b1 es igual a 0");
}
//Muestra: El biginteger b1 es mayor a 0
}
}
B1.and(B2) Donde B1 y B2 son objetos BigInteger, la función and devuelve un BigInteger que es la
operación and entre B1 y B2.
B1.andNot(B2) Donde B1 y B2 son objetos BigInteger, la función andNot devuelve un BigInteger que es la
operación and entre B1 y ~B2.
B1.or(B2) Donde B1 y B2 son objetos BigInteger, la función and devuelve un BigInteger que es la
operación or entre B1 y B2.
B1.xor(B2) Donde B1 y B2 son objetos BigInteger, la función and devuelve un BigInteger que es la
operación xor entre B1 y B2.
B.shiftLeft(n) Donde B es un objeto BigInteger y n es un entero no negativo, la función shiftLeft devuelve un
 José Gonzalo Espejo Cuba 15
GUIA DE JAVA

BigInteger que recorre n bits a la izquierda de B.

B.shiftRight(n) Donde B es un objeto BigInteger y n es un entero no negativo, la función shiftRight devuelve
un BigInteger que recorre n bits a la derecha de B.
B.not() Donde B es un objeto BigInteger, la función not devuelve un BigInteger que es la operación
not de B.
B.clearBit(n) Donde B es un objeto BigInteger y n es un entero no negativo, la función clearBit devuelve un
BigInteger que apaga el bit en la posición n de B.
B.flipBit(n) Donde B es un objeto BigInteger y n es un entero no negativo, la función flipBit devuelve un
BigInteger que cambia el valor del bit en la posición n de B. Es decir que si el bit en la posición
n está apagado (0), entonces se encenderá (1), si el bit esta encendido (1) el bit se apagara (0).
bitCount() Devuelve un entero que representa el número de bits encendidos.
bitLength() Devuelve un entero que representa el número de bits de un BigInteger.
signum() Devuelve un número entero: 1, 0 o -1.
1: Si el BigInteger es mayor a cero
0: Si el BigInteger es igual a cero
-1: Si el BigInteger es menor a cero

2.2.4 COMPARACION DE BIGINTEGERS

import java.math.BigInteger; //Libreria para JAVA BigInteger

public class biginteger_comparison {
public static void main(String args[]){
BigInteger b1=new BigInteger("456");
BigInteger b2=new BigInteger("456");
BigInteger b3=new BigInteger("567");

if(b1.compareTo(b2)==0)
System.out.println("Los BigIntegers b1 y b2 son iguales");
else
System.out.println("Los BigIntegers b1 y b2 son diferentes");
//Muestra: Los BigIntegers b1 y b2 son iguales
if(b1.equals(b2))
System.out.println("Los BigIntegers b1 y b2 son iguales");
else
System.out.println("Los BigIntegers b1 y b2 son diferentes");
//Muestra: Los BigIntegers b1 y b2 son iguales
System.out.println("Compare de b1 y b3: "+b1.compareTo(b3));//-1
System.out.println("Compare de b3 y b1: "+b3.compareTo(b1));//1
}
}
B1.compareTo(B2) Donde B1 y B2 son objetos BigInteger, la función compareTo devuelve un entero tal que:
0: Significa que B1 y B2 son iguales.
1: Significa que B1 es mayor que B2.
-1: Significa que B1 es menor que B2.
B1.equals(B2) Donde B1 y B2 son objetos BigInteger, la función equals devuelve true (verdadero) si B1 y B2
son iguales. Caso contrario devuelve false (falso).

2.2.5 VALORES MAXIMOS Y MINIMOS

import java.math.BigInteger;
public class biginteger_max_min {
public static void main(String args[]){
BigInteger b1=new BigInteger("456");
16 José Gonzalo Espejo Cuba
GUIA DE JAVA

BigInteger b2=new BigInteger("457");

System.out.println("MAX");
System.out.println("El mayor de b1 y b2 es: "+b1.max(b2));//457
System.out.println("MIN");
System.out.println("El mayor de b1 y b2 es: "+b1.min(b2));//456
}
}
B1.max(B2) Donde B1 y B2 son objetos BigInteger, la función max devuelve el mayor valor entre B1 y B2.
B1.min(B2) Donde B1 y B2 son objetos BigInteger, la función min devuelve el menor valor entre B1 y B2.

2.2.6 TRANSFORMACION DE BIGINTEGERS A VALORES NUMERICOS Y CADENAS

import java.math.BigInteger;
public class biginteger_to_values {
public static void main(String args[]){
BigInteger b=new BigInteger("124");
byte num_byte=b.byteValue();//Transformando a un entero byte
short num_short=b.shortValue();//Transformando a un entero short
int num_int=b.intValue();//Transformando a un entero int
long num_long=b.longValue();//Transformando a un entero long
float num_realf=b.floatValue();//Transformando a un real float
double num_reald=b.doubleValue();//Transformando a un real double
String cadena=b.toString();//Transformando a una cadena

System.out.println(num_byte);//Muestra: 124
System.out.println(num_short);//Muestra: 124
System.out.println(num_int);//Muestra: 124
System.out.println(num_long);//Muestra: 124
System.out.println(num_realf);//Muestra: 124.0
System.out.println(num_reald);//Muestra: 124.0
System.out.println(cadena);//Muestra: 124
}
}
byteValue() Retorna un entero de tipo byte.
shortValue() Retorna un entero de tipo short.
intValue() Retorna un entero de tipo int.
longValue() Retorna un entero de tipo long.
floatValue() Retorna un real de tipo float.
doubleValue() Retorna un real de tipo double.
toString() Retorna una cadena de tipo String.

2.2.7 FIBONACCI Y FACTORIAL

static int max=1000;

static BigInteger F[]=new BigInteger[max];//Vector de numeros fibonacci
/*
* Metodo para generar los 1000 primeros numeros fibonacci
* Fibonacci es aquel número que cumple: F(i)=F(i-1)+F(i-1)
* En c/c++ se puede generar hasta los 93 numeros fibonacci con
el tipo de dato unsigned long long
*/
public static void fibonacci(){
F[0]=new BigInteger("0");
 José Gonzalo Espejo Cuba 17
GUIA DE JAVA

F[1]=new BigInteger("1");
for(int i=2;i<max;i++)
F[i]=F[i-2].add(F[i-1]);//Realiza la suma
}
/*
* Metodo para generar el factorial de un numero n
* Factorial es aquel numero que cumple: n!=(n)*(n-1)*(n-2)*...*3*2*1
* En c/c++ y java el maximo numero factorial que se puede generar es 20
con el tipo de dato long long en c/c++ y long en JAVA
*/
public static BigInteger factorial(int n){
BigInteger facto,inc;
facto=new BigInteger("1");
for(int i=1;i<=n;i++){
inc=new BigInteger(Integer.toString(i));
facto=facto.multiply(inc);
}
return facto;
}

2.3 JAVA BIGDECIMAL

2.3.1 CONSTRUCTORES Y ASIGNACION DE BIGINTEGER

import java.math.BigDecimal;//Libreria para utilizer BigDecimal

public class big_decimal {
public static void main(String args[]){
//DECLARACION DE OBJETOS BIGDECIMAL
BigDecimal b1, b2, b3, b4, b5,b6;

//CREACION DE BIGDECIMAL
b1=new BigDecimal("0.00039992278782225436547665732323554656");
b3=b4=b5=b6=new BigDecimal("0");

//ASIGNACION DR BIGDECIMAL
b2=b1;//Asignando b1 a bigdecimal b2;
b3=b3.valueOf(0.000000024354);//Asignado un número real a b3
b4=b4.ZERO;//Asignado 0 a b4
b5=b5.ONE;//Asignado 1 a b5
b6=b6.TEN;//Asignado 10 a b6

//MOSTRANDO DATOS
System.out.println(b1);//Muestra: 0.00039992278782225436547665732323554656
System.out.println(b2);//Muestra: 0.00039992278782225436547665732323554656
System.out.println(b3);//Muestra: 2.4354E-8
System.out.println(b4);//Muestra: 0
System.out.println(b5);//Muestra: 1
System.out.println(b6);//Muestra: 10
}
}
BigDecimal b Declara un objeto BigDecimal b.
b=new BigDecimal ("0.01") Crea un objeto BigDecimal b que contiene un valor numérico, su constructor recibe
una parámetro de cadena para inicializar el BigDecimal b.
B1=B2 Donde B1 y B2 son objetos BigDecimal, el operador de asignación = asigna el valor
de B2 a B1.
valueOf(num) Donde num es un número real. La función valueOf retorna un BigDecimal que tiene
el valor de num.
ZERO Retorna un BigDecimal que tiene el valor de 0.
18 José Gonzalo Espejo Cuba
GUIA DE JAVA

ONE Retorna un BigDecimal que tiene el valor de 1.

TEN Retorna un BigDecimal que tiene el valor de 10.

2.3.2 OPERACIONES ARITMETICAS

import java.math.BigDecimal;//Libreria para utilizer BigDecimal

import java.math.MathContext; //Libreria para el contexto matematico
public class Bigdecimal_operaciones_aritmeticas {
public static void main(String[] args) {
BigDecimal b1,b2,suma1,suma2,suma3,suma4,suma5,resta1,resta2,resta3,
resta4,resta5,va1,va2,va3,va4,va5,prod1,prod2,prod3,prod4,prod5,
div1,div2,div3,div4,pot1,pot2,pot3,pot4,pot5,resid1,resid2,
resid3,resid4,resid5;
b1=new BigDecimal("48233189.04563763446567890876");
b2=new BigDecimal("5624355.27044341002030000023");

//SUMA
suma1=b1.add(b2);//Sin limite de digitos
suma2=b1.add(b2, MathContext.DECIMAL32);//7 digitos
suma3=b1.add(b2, MathContext.DECIMAL64);//16 digitos
suma4=b1.add(b2, MathContext.DECIMAL128);//34 digitos
suma5=b1.add(b2, MathContext.UNLIMITED);//Sin limite de digitos

//RESTA
resta1=b1.subtract(b2);//Sin limite de digitos
resta2=b1.subtract(b2, MathContext.DECIMAL32);//7 digitos
resta3=b1.subtract(b2, MathContext.DECIMAL64);//16 digitos
resta4=b1.subtract(b2, MathContext.DECIMAL128);//34 digitos
resta5=b1.subtract(b2, MathContext.UNLIMITED);//Sin limite de digitos

//VALOR ABSOLUTO
va1=resta1.abs();//Sin limite de digitos
va2=resta1.abs(MathContext.DECIMAL32);//7 digitos
va3=resta1.abs(MathContext.DECIMAL64);//16 digitos
va4=resta1.abs(MathContext.DECIMAL128);//34 digitos
va5=resta1.abs(MathContext.UNLIMITED);//Sin limite de digitos

//PRODUCTO
prod1=b1.multiply(b2);//Sin limite de digitos
prod2=b1.multiply(b2, MathContext.DECIMAL32);//7 digitos
prod3=b1.multiply(b2, MathContext.DECIMAL64);//16 digitos
prod4=b1.multiply(b2, MathContext.DECIMAL128);//34 digitos
prod5=b1.multiply(b2, MathContext.UNLIMITED);//Sin limite de digitos

//DIVISION
div1=b1.divide(b2, MathContext.DECIMAL32);//7 digitos
div2=b1.divide(b2, MathContext.DECIMAL64);//16 digitos
div3=b1.divide(b2, MathContext.DECIMAL128);//34 digitos
div4=b1.divideToIntegralValue(b2);//Parte entera de la division

//POTENCIA
pot1=b1.pow(3);//Sin limite de digitos
pot2=b1.pow(3, MathContext.DECIMAL32);//7 digitos
pot3=b1.pow(3, MathContext.DECIMAL64);//16 digitos
pot4=b1.pow(3, MathContext.DECIMAL128);//34 digitos
pot5=b1.pow(3, MathContext.UNLIMITED);//Sin limite de digitos

//MODULO
resid1=b1.remainder(b2);//Sin Limites
resid2=b1.remainder(b2, MathContext.DECIMAL32);//7 digitos
resid3=b1.remainder(b2, MathContext.DECIMAL64);//16 digitos
resid4=b1.remainder(b2, MathContext.DECIMAL128);//34 digitos
resid5=b1.remainder(b2, MathContext.UNLIMITED);//Sin Limites

//NEGATIVO
b1=b1.negate();

System.out.println(suma1);//Muestra: 53857544.31608104448597890899
 José Gonzalo Espejo Cuba 19
GUIA DE JAVA

System.out.println(suma2);//Muestra: 5.385754E+7
System.out.println(suma3);//Muestra: 53857544.31608104
System.out.println(suma4);//Muestra: 53857544.31608104448597890899
System.out.println(suma5);//Muestra: 53857544.31608104448597890899
System.out.println(resta1);//Muestra: 42608833.77519422444537890853
System.out.println(resta2);//Muestra: 4.260883E+7
System.out.println(resta3);//Muestra: 42608833.77519422
System.out.println(resta4);//Muestra: 42608833.77519422444537890853
System.out.println(resta5);//Muestra: 42608833.77519422444537890853
System.out.println(va1);//Muestra: 42608833.77519422444537890853
System.out.println(va2);//Muestra: 4.260883E+7
System.out.println(va3);//Muestra: 42608833.77519422
System.out.println(va4);//Muestra: 42608833.77519422444537890853
System.out.println(va5);//Muestra: 42608833.77519422444537890853
System.out.println(prod1);//Muestra: 271280591019125.3792512347368306593102832093749341490148
System.out.println(prod2);//Muestra: 2.712806E+14
System.out.println(prod3);//Muestra: 271280591019125.4
System.out.println(prod4);//Muestra: 271280591019125.3792512347368306593
System.out.println(prod5);//Muestra: 271280591019125.3792512347368306593102832093749341490148
System.out.println(div1);//Muestra: 8.575772
System.out.println(div2);//Muestra: 8.575772106557389
System.out.println(div3);//Muestra: 8.575772106557388787039073593655905
System.out.println(div4);//Muestra: 8
System.out.println(pot1);
//Muestra: 112211645670463389357295.355703431376693266206326164013530641234581668938362942141376
System.out.println(pot2);//Muestra: 1.122116E+23
System.out.println(pot3);//Muestra: 1.122116456704634E+23
System.out.println(pot4);//Muestra: 112211645670463389357295.3557034314
System.out.println(pot5);
//Muestra: 112211645670463389357295.355703431376693266206326164013530641234581668938362942141376
System.out.println(resid1);//Muestra: 3238346.88209035430327890692
System.out.println(resid2);//Muestra: 3238346.88209035430327890692
System.out.println(resid3);//Muestra: 3238346.88209035430327890692
System.out.println(resid4);//Muestra: 3238346.88209035430327890692
System.out.println(resid5);//Muestra: 3238346.88209035430327890692
System.out.println(b1);//Muestra: -48233189.04563763446567890876
}
}

B1.add(B2) Donde B1 y B2 son objetos BigDecimal, la función add devuelve un BigDecimal

que es la suma: B1 + B2.
B1.add(B2,cont) Donde B1 y B2 son objetos BigDecimal y cont es un contexto matemático de la
librería java.math.MathContext, la función add devuelve un BigDecimal que es la
suma: B1 + B2. Además utiliza la cantidad de dígitos según el contexto cont.
B1.substract(B2) Donde B1 y B2 son objetos BigDecimal, la función substract devuelve un
BigDecimal que es la resta: B1 - B2.
B1.substract(B2,cont) Donde B1 y B2 son objetos BigDecimal y cont es un contexto matemático de la
librería java.math.MathContext, la función substract devuelve un BigDecimal que
es la resta: B1 - B2. Además utiliza la cantidad de dígitos según el contexto cont.
B.abs() Donde B es un objeto BigDecimal, la función abs devuelve un BigDecimal que es el
valor absoluto de B.
B.abs(cont) Donde B es un objeto BigDecimal y cont es un contexto matemático de la librería
java.math.MathContext, la función abs devuelve un BigDecimal que es el valor
absoluto de B. Además utiliza la cantidad de dígitos según el contexto cont.
B1.multiply(B2) Donde B1 y B2 son objetos BigDecimal, la función multiply devuelve un
BigDecimal que es el producto: B1 * B2.
B1.multiply(B2,cont) Donde B1 y B2 son objetos BigDecimal y cont es un contexto matemático de la
librería java.math.MathContext, la función multiply devuelve un BigDecimal que
es el producto: B1 * B2. Además utiliza la cantidad de dígitos según el contexto
cont.
B1.divide(B2) Donde B1 y B2 son objetos BigDecimal, la función divide devuelve un BigDecimal
20 José Gonzalo Espejo Cuba
GUIA DE JAVA

que es la división: B1 / B2.

B1.divide(B2,cont) Donde B1 y B2 son objetos BigDecimal y cont es un contexto matemático de la
librería java.math.MathContext, la función divide devuelve un BigDecimal que es
la división: B1 / B2. Además utiliza la cantidad de dígitos según el contexto cont.
B1.divideToIntegralValue(B2) Donde B1 y B2 son objetos BigDecimal, la función divide devuelveToIntegral un
BigDecimal que es la parte entera de la división: B1 / B2.
B1.remainder(B2) Donde B1 y B2 son objetos BigDecimal, la función remainder devuelve un
BigDecimal que es el residuo: B1 % B2.
B1.remainder(B2,cont) Donde B1 y B2 son objetos BigDecimal y cont es un contexto matemático de la
librería java.math.MathContext, la función remainder devuelve un BigDecimal
que es el residuo: B1 % B2. Además utiliza la cantidad de dígitos según el
contexto cont.
B.pow(n) Donde B es un objeto BigDecimal y n es un numero entero, la función pow
devuelve un BigDecimal que es la potencia: B ^ n.
B.pow(n,cont) Donde B es un objeto BigDecimal, n es un numero entero y cont es un contexto
matemático de la librería java.math.MathContext, la función pow devuelve un
BigDecimal que es la potencia: B ^ n. Además utiliza la cantidad de dígitos según
el contexto cont.
B.negate() Donde B es un objeto BigDecimal, la función negate devuelve un BigDecimal que
es el valor negativo de B.
B.negate(cont) Donde B es un objeto BigDecimal y cont es un contexto matemático de la librería
java.math.MathContext, la función negate devuelve un BigDecimal que es el valor
negativo de B. Además utiliza la cantidad de dígitos según el contexto cont.

2.3.3 OPERACIONES DE COMA FLOTANTE

import java.math.BigDecimal; //Libreria para utilizer BigDecimal

import java.math.MathContext; //Libreria para el context matematico
public class Bigdecimal_operaciones_coma_flotante {
public static void main(String[] args) {
BigDecimal b=new BigDecimal("2334.4345");
System.out.println("Moviendo 1 posicion a la izquierda");
System.out.println(b.movePointLeft(1));//Muestra: 233.44345
System.out.println("Moviendo 2 posiciones a la izquierda");
System.out.println(b.movePointLeft(2));//Muestra: 23.344345
System.out.println("Moviendo 4 posiciones a la izquierda");
System.out.println(b.movePointLeft(4));//Muestra: 0.23344345
System.out.println("Moviendo 1 posicion a la derecha");
System.out.println(b.movePointRight(1));//Muestra: 23344.345
System.out.println("Moviendo 2 posiciones a la derecha");
System.out.println(b.movePointRight(2));//Muestra: 233443.45
System.out.println("Moviendo 5 posiciones a la derecha");
System.out.println(b.movePointRight(5));//Muestra: 233443450
System.out.println("Precision de digitos de b: "+b.precision());//8
System.out.println("Numero de digitos despues de la coma decimal: "+b.scale());//4
System.out.println("Agregando 5 digitos despues de la coma decimal: "+b.setScale(5));//2334.43450
System.out.println("Agregando 7 digitos despues de la comadecimal:"+b.setScale(7));//2334.4345000
System.out.println("b*10="+b.scaleByPowerOfTen(1));//Muestra:23344.345
System.out.println("b*100="+b.scaleByPowerOfTen(2));//Muestra: 233443.45
System.out.println("b*1000="+b.scaleByPowerOfTen(3));//Muestra: 2334434.5

if(b.signum()==1)
System.out.println("El bigdecimal b es mayor a 0");
else{
if(b.signum()==-1)
System.out.println("El bigdecimal b es menor a 0");
else
System.out.println("El bigdecimal es igual a 0");
}
 José Gonzalo Espejo Cuba 21
GUIA DE JAVA

//Muestra: El bigdecimal b es mayor a 0

System.out.println("Sin limite de digitos: "+b);//2334.4345
System.out.println("7 digitos: "+b.round(MathContext.DECIMAL32));//2334.434
}
}

movePointLeft(int n) Donde n es un entero, mueve la coma flotante n posiciones a la izquierda.

movePointRight(int n) Donde n es un entero, mueve la coma flotante n posiciones a la derecha.
precisión() Devuelve un número entero que representa el número de dígitos.
scale() Devuelve un número entero que representa el número de dígitos después de la coma
flotante.
setscale(n) Donde n es un entero y n debe ser mayor o igual al número de la escala, establece los
dígitos después de la coma flotante con ceros.
scaleByPowerOfTen(n) Donde n es un entero, la función scaleByTower devuelve un BigDecimal que
representa el valor original del BigDecimal multiplicado por una potencia de 10.
signum() Devuelve un número entero: 1, 0 o -1.
1: Si el BigDecimal es mayor a cero
0: Si el BigDecimal es igual a cero
-1: Si el BigDecimal es menor a cero
round(context) Donde context es un contexto matemático de la librería java.math.MathContext,
redondea el número según el contexto.

2.3.4 COMPARACION DE BIGDECIMALS

import java.math.BigDecimal;
public class Bigdecimal_comparison {
public static void main(String[] args) {
BigDecimal b1=new BigDecimal("0.0000000456");
BigDecimal b2=new BigDecimal("0.0000000456");
BigDecimal b3=new BigDecimal("0.0000000457");
if(b1.compareTo(b2)==0)
System.out.println("Los BigDecimals b1 y b2 son iguales");
else
System.out.println("Los BigDecimals b1 y b2 son diferentes");
//Muestra: Los BigDecimals b1 y b2 son iguales
if(b1.equals(b2))
System.out.println("Los BigDecimals b1 y b2 son iguales");
else
System.out.println("Los BigDecimals b1 y b2 son diferentes");
//Muestra: Los BigDecimals b1 y b2 son iguales
System.out.println("Compare de b1 y b3: "+b1.compareTo(b3));//-1
System.out.println("Compare de b3 y b1: "+b3.compareTo(b1));//1
}
}
B1.compareTo(B2) Donde B1 y B2 son objetos BigDecimals, la función compareTo devuelve un entero tal que:
0: Significa que B1 y B2 son iguales.
1: Significa que B1 es mayor que B2.
-1: Significa que B1 es menor que B2.
B1.equals(B2) Donde B1 y B2 son objetos BigDecimals, la función equals devuelve true (verdadero) si B1 y
B2 son iguales. Caso contrario devuelve false (falso).

2.3.5 VALORES MAXIMOS Y MINIMOS

import java.math.BigDecimal;
22 José Gonzalo Espejo Cuba
GUIA DE JAVA

public class Bigdecimal_min_max {

public static void main(String[] args) {
BigDecimal b1=new BigDecimal("0.0000456");
BigDecimal b2=new BigDecimal("0.0000457");
System.out.println("MAX");
System.out.println("El mayor de b1 y b2 es: "+b1.max(b2));//0.0000457
System.out.println("MIN");
System.out.println("El mayor de b1 y b2 es: "+b1.min(b2));//0.0000456
}
}
B1.max(B2) Donde B1 y B2 son objetos BigDecimals, la función max devuelve el mayor valor entre B1 y B2.
B1.min(B2) Donde B1 y B2 son objetos BigDecimals, la función min devuelve el menor valor entre B1 y B2.

2.3.6 TRANSFORMACION DE BIGDECIMALS A VALORES NUMERICOS Y CADENAS

import java.math.BigDecimal;
import java.math.BigInteger;
public class bigdecimal_to_values {
public static void main(String args[]){
BigDecimal b=new BigDecimal("124.23567");
byte num_byte=b.byteValue();//Transformando a un entero byte
short num_short=b.shortValue();//Transformando a un entero short
int num_int=b.intValue();//Transformando a un entero int
long num_long=b.longValue();//Transformando a un entero long
float num_realf=b.floatValue();//Transformando a un real float
double num_reald=b.doubleValue();//Transformando a un real double
String cad1=b.toString();//Transformando a una cadena
String cad2=b.toEngineeringString();//Transformando a una cadena
String cad3=b.toPlainString();//Transformando a una cadena
BigInteger bi=b.toBigInteger();//Transformando a un BigInteger

System.out.println(num_byte);//Muestra: 124
System.out.println(num_short);//Muestra: 124
System.out.println(num_int);//Muestra: 124
System.out.println(num_long);//Muestra: 124
System.out.println(num_realf);//Muestra: 124.23567
System.out.println(num_reald);//Muestra: 124.23567
System.out.println(cad1);//Muestra: 124.23567
System.out.println(cad2);//Muestra: 124.23567
System.out.println(cad3);//Muestra: 124.23567
System.out.println(bi);//Muestra: 124
}
}
byteValue() Retorna un entero de tipo byte.
shortValue() Retorna un entero de tipo short.
intValue() Retorna un entero de tipo int.
longValue() Retorna un entero de tipo long.
floatValue() Retorna un real de tipo float.
doubleValue() Retorna un real de tipo double.
toString() Retorna una cadena de tipo String usando notación científica.
toEngineeringString() Retorna una cadena de tipo String usando notación con exponente si es necesario.
toPlainString() Retorna una cadena de tipo String usando notación sin exponente.
toBigInteger() Retorna un BigInteger.
 José Gonzalo Espejo Cuba 23
GUIA DE JAVA

2.3.7 HERRAMIENTAS DE MATHCONTEXT

MathContext.DECIMAL32 Utiliza 7 dígitos, si el número de dígitos sobrepasa los 7 dígitos, entonces utiliza la
notación científica.
MathContext.DECIMAL64 Utiliza 16 dígitos, si el número de dígitos sobrepasa los 16 dígitos, entonces utiliza la
notación científica.
MathContext.DECIMAL128 Utiliza 34 dígitos, si el número de dígitos sobrepasa los 34 dígitos, entonces utiliza la
notación científica.
MathContext.UNLIMITED No tiene límites de digitos.
24 José Gonzalo Espejo Cuba
GUIA DE JAVA

3 CADENAS YCARACTERES

3.1 LA CLASE STRING

3.1.1 CONSTRUCTORES DE STRING

public class constructores_string {

public static void main(String args[]){
char arreglo[]={'P','R','O','G','R','A','M','A','C','I','O','N'};
String cad1=new String();//Crea una cadena vacia
String cad2=new String("Hola");//Crea una cadena con contenido
String cad3=new String(cad2);//Crea una cadena con contenido de otra cadena
String cad4=new String(arreglo);//Crea una cadena con contenido del arreglo
String cad5=new String(arreglo,7,3);//Crea una cadena con contenido del arreglo

System.out.printf("cad1: %s\n",cad1);//cad1:
System.out.printf("cad2: %s\n",cad2);//cad2: Hola
System.out.printf("cad3: %s\n",cad3);//cad3: Hola
System.out.printf("cad4: %s\n",cad4);//cad4: PROGRAMACION
System.out.printf("cad5: %s\n",cad5);//cad5: ACI
}
}
String cad1=new String() Crea una cadena cad.
String cad1=new String(cad2) Crea una cadena cad1 con el contenido de cad2 que puede ser de tipo
String o de tipo char[].
String cad1=new String(cad2,i,j) Donde cad2 es de tipo char[], i y j son enteros no negativos. Crea una
cadena cad1 con el contenido de cad2. Tomando a j caracteres a partir de
la i-esima posición.

3.1.2 CONCATENACION Y ASIGNACION DE CADENAS

public class concatenacion_cadenas {

public static void main(String args[]){
String cad1,cad2,cad3,cad4;//Declarando cadenas
cad1="Hola";//Asignado 'Hola' a cad1
cad2="Mundo";//Asignado 'Hola' a cad2
cad3=cad1+cad2;//Concatenando cad1 con cad2
cad4=cad1.concat(cad2);
System.out.printf("cad3: %s\n",cad3);//cad3: HolaMundo
System.out.printf("cad4: %s\n",cad4);//cad4: HolaMundo
}
}
= Operador de asignación.
+ Operador de concatenación.
A.concat(B) Donde A y B son de tipo String, la función concat devuelve una cadena que es la concatenación de A y B.

3.1.3 REEMPLAZO DE CADENAS

public class reemplazo_cadenas {

public static void main(String args[]){
String cad1,cad2,cad3,cad4,cad5;//Declarando cadenas
cad1="Programacion";
cad2="Mundo";//Asignado 'Hola' a cad2
cad3=cad1.replace('o', 'a');//Reemplazo de caracteres
cad4=cad1.replace("ama", "onoe");//Reemplazo de secuencia de caracteres
 José Gonzalo Espejo Cuba 25
GUIA DE JAVA

System.out.printf("cad3: %s\n",cad3);//cad3: Pragramacian

System.out.printf("cad4: %s\n",cad4);//cad4: Progronoecion
System.out.printf("cad5: %s\n",cad5);//cad4: Mundo
}
}
A.replace(c1, c2) Donde A es una cadena, c1 y c2 son caracteres. La función replace devuelve una cadena en
donde se reemplaza el carácter c1 (si está en la cadena) de A por el carácter c2.
A.replace(s1, s2) Donde A es una cadena, s1 y s2 son secuencia de caracteres. La función replace devuelve una
cadena en donde se reemplaza la secuencia s1 (si está en la cadena) de A por la secuencia s2.

3.1.4 LONGITUD DE CADENAS

public class longitud_cadenas {

public static void main(String args[]){
String cadena=new String(" Programacion en JAVA ");
System.out.println("Longitud de la cadena: "+cadena.length());//28
cadena=cadena.trim();//Eliminando los caracteres en blanco
System.out.println(cadena);//Programacion en JAVA
System.out.println("Longitud de la cadena: "+cadena.length());//20
//METODO EMPTY
if(cadena.isEmpty())
System.out.print("La cadena esta vacia");
else
System.out.print("La cadena no esta vacia");
//Muestra: La cadena no esta vacia
}
}
length() Devuelve un entero no negativo que representa la longitud de la cadena, es decir número de caracteres.
trim() Devuelve una copia de la cadena que limpia los espacios en blanco tanto de atrás como de adelante.
isEmpty() Devuelve true (verdadero) Si la cadena está vacía, es decir que n o contiene ningún carácter. Caso
contrario devuelve false (falso).

3.1.5 SUBCADENAS

public class subcadenas {

public static void main(String args[]){
String cadena=new String("Programacion en JAVA");
//Rango: [5,final)
System.out.println(cadena.substring(5));//amacion en JAVA
//Rango: [2,final)
System.out.println(cadena.substring(2));//ogramacion en JAVA
//Rango: [2,10)
System.out.println(cadena.substring(2,10));//ogramaci
//Rango: [4,17)
System.out.println(cadena.substring(3,17));//gramacion en J
//Rango: [4,17)
System.out.println(cadena.subSequence(3, 17));//gramacion en J
}
}
substring(i) Donde i es un entero no negativo, la función substring devuelve una subcadena a partir del
carácter i hasta el final.
substring(i,j) Donde i y j son enteros no negativos, la función substring devuelve una subcadena a partir del
carácter i hasta el carácter j.
subSequence(i, i) Donde i y j son enteros no negativos, la función subSequence devuelve una secuencia de
26 José Gonzalo Espejo Cuba
GUIA DE JAVA

caracteres a partir del carácter i hasta el carácter j.

3.1.6 LOCALIZACION DE SECUENCIAS DE CARACTERES

public class localizacion {

public static void main(String args[]){
String cadena=new String("Programacion en JAVA");
System.out.println("La secuencia 'ama' comienza en la posicion: "+cadena.indexOf("ama"));//5
System.out.println("La secuencia 'ama' comienza en la posicion: "+cadena.indexOf("ama",7));//-1
if(cadena.contains("amacion"))
System.out.println("La cadena contiene la secuencia: 'amacion'");
//Muestra: La cadena contiene la secuencia: 'amacion'
if(cadena.startsWith("Prog"))
System.out.println("La cadena comienza con la secuencia: 'Prog'");
//Muestra: La cadena comienza con la secuencia: 'Prog'
if(cadena.startsWith("gra",3))
System.out.println("La cadena comienza con la secuencia: 'gra' a partir de 3");
//Muestra: La cadena comienza con la secuencia: 'gra' a partir de 3
if(cadena.endsWith("JAVA"))
System.out.println("La cadena termina con la secuencia: 'JAVA'");
//Muestra: La cadena termina con la secuencia: 'JAVA'
}
}

indexOf(cad) Donde cad es una secuencia de caracteres. Devuelve un entero que representa la posición de del
primer carácter de la cadena en la que aparece la secuencia cad. Si la secuenci cad no se encuentra
en la cadena entonces devolverá -1.
indexOf(cad,n) Donde cad es una secuencia de caracteres y n es un entero no negativo. Devuelve un entero que
representa la posición de del primer carácter de la cadena en la que aparece la secuencia cad a
partir del carácter de la n-esima posición. Si la secuencia cad no se encuentra en la cadena
entonces devolverá -1.
A.contains(B) Donde A y B son cadenas. La función contains devuelve true (verdadero) si A contiene a B. Caso
contrario devuelve false (falso).
A.starsWith(B) Donde A y B son cadenas. La función starsWith devuelve true (verdadero) si A comienza con B.
Caso contrario devuelve false (falso).
A.starsWith(B,n) Donde A y B son cadenas y n es un entero no negativo. La función starsWith devuelve true
(verdadero) si A comienza con B a partir de la posición n. Caso contrario devuelve false (falso).
A.endsWith(B) Donde A y B son cadenas. La función endsWith devuelve true (verdadero) si A termina con B. Caso
contrario devuelve false (falso).

3.1.7 COMPARACION DE STRINGS

public class String_comparison {

public static void main(String args[]){
String cad1,cad2,cad3;
cad1=cad2="Programacion";
cad3="programacion";

if(cad1.equals(cad2))
System.out.println("Las cadenas cad1 y cad2 son iguales");
else
System.out.println("Las cadenas cad1 y cad2 son diferentes");
//Muestra: Las cad1 y cad2 son iguales

if(cad1.equals(cad3))
System.out.println("Las cad1 y cad3 son iguales");
else
System.out.println("Las cad1 y cad3 son diferentes");
 José Gonzalo Espejo Cuba 27
GUIA DE JAVA

//Muestra: Las cad1 y cad3 son diferentes

if(cad1.equalsIgnoreCase(cad3))
System.out.println("Las cad1 y cad3 son iguales");
else
System.out.println("Las cad1 y cad3 son diferentes");
//Muestra: Las cad1 y cad3 son iguales

System.out.println("compareTo entre cad1 y cad2: "+cad1.compareTo(cad2));//0

System.out.println("compareTo entre cad1 y cad3: "+cad1.compareTo(cad3));//-32
System.out.println("compareTo entre cad3 y cad1: "+cad3.compareTo(cad1));//32
}
}
A.compareTo(B) Donde A y B son Strings, la función compareTo devuelve un entero tal que:
0: Significa que A y B son iguales.
>0: Significa que A es mayor que B lexicograficamente.
<0: Significa que A es menor que B.
A.equals(B) Donde A y B son String, la función equals devuelve true (verdadero) si A y B son iguales, los
caracteres deben ser exactamente iguales. Caso contrario devuelve false (falso).
A.equalsIgnoreCase(B) Donde A y B son String, la función equalsIgnoreCase devuelve true (verdadero) si A y B son
iguales, a diferencia de equals, equalsIgnoreCase toma por iguales caraceres alfabéticos
iguales ya sean mayúsculas o minúsculas, es decir que ‘a’ es igual a ‘A’. Caso contrario
devuelve false (falso).

3.2 CLASE STRING BUILDER

3.2.1 CONSTTRUCTORES

public class StringBuilder_Constructors {

public static void main(String[] args) {
StringBuilder sb1=new StringBuilder();//Crea una cadena vacia
StringBuilder sb2=new StringBuilder("Hola");//Crea una cadena con contenido
StringBuilder sb3=new StringBuilder(sb2); //Crea una cadena con contenido
System.out.println(sb1);//Muestra:
System.out.println(sb2);//Muestra: Hola
System.out.println(sb3);//Muestra: Hola
}
}
sb1=new StringBuilder() Crea un StringBuilder sb1 vacío.
sb2=new StringBuilder(cad) Donde cad es una secuencia de caracteres. Crea un StringBuilder sb2 vacío con el
contenido de cad.

3.2.2 CONCATENACION DE CADENAS

public class StringBuilder_append {

public static void main(String[] args) {
Object objeto="Programacion";
String cad="en";
char arreglo[]={'J','A','V','A'};
char espacio=' ';
int entero=2013;
StringBuilder sb=new StringBuilder("!!!");
StringBuilder bufer=new StringBuilder();

bufer.append(objeto);//Concatenando con un objeto

bufer.append(espacio);//Concatenando con un caracter
bufer.append(cad);//Concatenando con un String
28 José Gonzalo Espejo Cuba
GUIA DE JAVA

bufer.append(espacio);//Concatenando con un caracter

bufer.append(arreglo);//Concatenando con un char[]
bufer.append(espacio);//Concatenando con un caracter
bufer.append(entero);//Concatenando con un valor numerico
bufer.append(sb);//Concatenando con un StringBuilder
//RESULTADO FINAL
System.out.println(bufer);//Muestra: Programacion en JAVA 2013!!!
}
}
bufer.append(X) Donde bufer es de tipo StringBuilder y X puede ser: Object, char, char[], String, StringBuilder, int,
long, double, float o boolean. Concatena el contenido actual de bufer con el contenido de X.

3.2.3 INSERCCION Y ELIMINACION DE CARACTERES

public class StringBuilder_insertion_elimination {

public static void main(String[] args) {
Object objeto="Programacion";
String cad="en";
char arreglo[]={'J','A','V','A'};
char espacio=' ';
int entero=2013;
StringBuilder sb=new StringBuilder("!!!");
StringBuilder bufer=new StringBuilder();

System.out.println("INSERCCION DE SECUENCIA DE CARACTERES");

bufer.insert(0, objeto);//Inserta un Objeto en la posicion 0
System.out.println(bufer);//Muestra: Programacion
bufer.insert(12,cad);//Inserta un String en la posicion 12
System.out.println(bufer);//Muestra: Programacionen
bufer.insert(14,arreglo);//Inserta un char[] en la posicion 14
System.out.println(bufer);//Muestra: ProgramacionenJAVA
bufer.insert(18,sb);//Inserta un StringBuilder en la posicion 18
System.out.println(bufer);//Muestra: ProgramacionenJAVA!!!
bufer.insert(18,entero);//Inserta un entero en la posicion 18
System.out.println(bufer);//Muestra: ProgramacionenJAVA2013!!!
bufer.insert(12,espacio);//Inserta un char en la posicion 12
System.out.println(bufer);//Muestra: Programacion enJAVA2013!!!
bufer.insert(15,espacio);//Inserta un char en la posicion 12
System.out.println(bufer);//Muestra: Programacion en JAVA2013!!!
bufer.insert(20,espacio);//Inserta un char en la posicion 20
System.out.println(bufer);//Muestra: Programacion en JAVA 2013!!!

System.out.println("\nELIMINACION DE SECUENCIA DE CARACTERES");

bufer.delete(13, 16);//Eliminando: 'en ' de la posicion 13 hasta la 16
System.out.println(bufer);//Muestra: Programacion JAVA 2013!!!
bufer.deleteCharAt(1);//Eliminando: el caracter de la posicion 1
System.out.println(bufer);//Muestra: Pogramacion JAVA 2013!!!
bufer.deleteCharAt(3);//Eliminando: el caracter de la posicion 1
System.out.println(bufer);//Muestra: Pogamacion JAVA 2013!!!
bufer.delete(0, 11);//Eliminando: 'Pogamacion ' de la posicion 0 hasta la 11
System.out.println(bufer);//Muestra: JAVA 2013!!!
}
}
insert(i,X) Donde i es un entero no negativo y X puede ser: Object, char, char[], String, StringBuilder, int,
long, double, float o boolean. Inserta X en la i-esima posición.
deleteCharAt(i) Donde i es un entero no negativo. Elimina el i-esimo carácter.
delete(i, j) Donde i y j son enteros no negativos. Elimina la secuencia de caracteres desde i hasta j.
 José Gonzalo Espejo Cuba 29
GUIA DE JAVA

3.2.4 REEMPLAZO DE SECUENCIA DE CARACTERES

public class StringBuilder_replace {

public static void main(String[] args) {
StringBuilder bufer=new StringBuilder("Programacion en JAVA");

System.out.println("REEMPLAZO DE CARACTERES");
bufer.setCharAt(1, 'R');//Reemplazando el caracter de la posicion 1 por R
System.out.println(bufer);//Muestra: PRogramacion en JAVA
bufer.setCharAt(13, 'o');//Reemplazando el caracter de la posicio 13 por o
System.out.println(bufer);//Muestra: PRogramacion on JAVA

System.out.println("\nREEMPLAZO DE SECUENCIA DE CARACTERES");

bufer.replace(16, 20, "C++");//Reemplazando la secuncia JAVA por la secuencia C++
System.out.println(bufer);//Muestra: PRogramacion on C++
}
}
setCharAt(i,c) Donde i es un entero no negativo y c es un char. Reemplaza el carácter de la i-esima posición por
el carácter c.
replace(i,j,cad) Donde i, j son enteros no negativos y cad es una secuencia de caracteres. Reemplaza la secuencia
de caracteres del StringBufer desde i hasta j, y la reemplaza por la secuencia cad.

3.2.5 LONGITUD DE CADENAS

public class StringBuilder_tamaño {

public static void main(String[] args) {
StringBuilder bufer=new StringBuilder("Programacion en JAVA");
System.out.println(bufer);//Muestra: 'Programacion en JAVA'
System.out.println("Longitud del bufer: "+bufer.length());//20
System.out.println("Capacidad del bufer: "+bufer.capacity());//36

bufer.setLength(37);//Modificando la longitud de bufer a 37

System.out.println(bufer);//Muestra: 'Programacion en JAVA
System.out.println("Longitud del bufer: "+bufer.length());//37
System.out.println("Capacidad del bufer: "+bufer.capacity());//74

bufer.setLength(11);//Modificando la longitud de bufer a 11

System.out.println(bufer);//Muestra: 'Programacio'
System.out.println("Longitud del bufer: "+bufer.length());//11
System.out.println("Capacidad del bufer: "+bufer.capacity());//74
}
}
length() Devuelve un entero no negativo que representa la longitud del StringBuilder, es decir el número de
caracteres.
setLength() Establece una nueva longitud para el StringBuilder.
capacity() Devuelve un entero no negativo que representa la capacidad del StringBuilder, es decir el número de
caracteres que un StringBuilder puede almacenar. El valor de capacity inicializa con el valor de la
cadena más 16.

3.2.6 SUBCADENAS

public class StringBuilder_subcadenas {

public static void main(String args[]){
StringBuilder cadena=new StringBuilder("Programacion en JAVA");
//Rango: [5,final)
System.out.println(cadena.substring(5));//amacion en JAVA
30 José Gonzalo Espejo Cuba
GUIA DE JAVA

//Rango: [2,final)
System.out.println(cadena.substring(2));//ogramacion en JAVA
//Rango: [2,10)
System.out.println(cadena.substring(2,10));//ogramaci
//Rango: [4,17)
System.out.println(cadena.substring(3,17));//gramacion en J
//Rango: [4,17)
System.out.println(cadena.subSequence(3, 17));//gramacion en J
}
}
substring(i) Donde i es un entero no negativo, la función substring devuelve una subcadena a partir del
carácter i hasta el final.
substring(i,j) Donde i y j son enteros no negativos, la función substring devuelve una subcadena a partir del
carácter i hasta el carácter j.
subSequence(i, i) Donde i y j son enteros no negativos, la función subSequence devuelve una secuencia de
caracteres a partir del carácter i hasta el carácter j.

3.2.7 LOCALIZACION DE SECUENCIAS DE CARACTERES Y METODO REVERSE

public class StringBuilder_localizacion_caracteres {

public static void main(String args[]){
StringBuilder cadena=new StringBuilder("Programacion en JAVA");
System.out.println(cadena);//Programacion en JAVA
System.out.println("La secuencia 'ama' comienza en la posicion: "+cadena.indexOf("ama"));//5
System.out.println("La secuencia 'ama' comienza en la posicion: "+cadena.indexOf("ama",7));//-1
cadena.reverse();//La cadena en reversa
System.out.println(cadena);// AVAJ ne noicamargorP
System.out.println("La secuencia 'ama' comienza en la posicion: "+cadena.indexOf("ama"));//5
System.out.println("La secuencia 'ama' comienza en la posicion: "+cadena.indexOf("ama",7));//-1
}
}

indexOf(cad) Donde cad es una secuencia de caracteres. Devuelve un entero que representa la posición de del
primer carácter de la cadena en la que aparece la secuencia cad. Si la secuenci cad no se encuentra
en la cadena entonces devolverá -1.
indexOf(cad,n) Donde cad es una secuencia de caracteres y n es un entero no negativo. Devuelve un entero que
representa la posición de del primer carácter de la cadena en la que aparece la secuencia cad a
partir del carácter de la n-esima posición. Si la secuencia cad no se encuentra en la cadena
entonces devolverá -1.
reverse() Invierte la cadena.

3.2.8 COMPARACION DE STRINGBUILDER

public class StringBuilder_comparison {

public static void main(String args[]){
StringBuilder cad1,cad2,cad3;
cad1=cad2=new StringBuilder("Programacion");
cad3=new StringBuilder("programacion");

if(cad1.equals(cad2))
System.out.println("Las cad1 y cad2 son iguales");
else
System.out.println("Las cad1 y cad2 son diferentes");
//Muestra: Las cad1 y cad2 son iguales

if(cad1.equals(cad3))
System.out.println("Las cad1 y cad3 son iguales");
else
 José Gonzalo Espejo Cuba 31
GUIA DE JAVA

System.out.println("Las cad1 y cad3 son diferentes");

//Muestra: Las cad1 y cad3 son diferentes
}
}
A.compareTo(B) Donde A y B son Strings, la función compareTo devuelve un entero tal que:
0: Significa que A y B son iguales.
>0: Significa que A es mayor que B lexicograficamente.
<0: Significa que A es menor que B.
A.equals(B) Donde A y B son String, la función equals devuelve true (verdadero) si A y B son iguales. Caso
contrario devuelve false (falso).

3.3 CARACTERES
3.3.1 OBTENCION DE UN CHAR [] A PARTIR DE UNA CADENA

public class obtencion_secuencia_caracteres {

public static void main(String args[]){
String A=new String("Programacion en JAVA");
StringBuilder B=new StringBuilder("Programacion en C++");

char vec1[]=A.toCharArray();//De String a char[]

char vec2[]=new char[A.length()];
char vec3[]=new char[B.length()];
A.getChars(0, A.length(), vec2, 0);
B.getChars(0, B.length(), vec3, 0);

//VEC1
for(int i=0;i<A.length();i++)
System.out.print(vec1[i]);//Muestra: Programacion en JAVA
System.out.println();//Salto de linea

//VEC2
for(int i=0;i<A.length();i++)
System.out.print(vec2[i]);//Muestra: Programacion en JAVA
System.out.println();//Salto de linea

//VEC3
for(int i=0;i<B.length();i++)
System.out.print(vec3[i]);//Muestra: Programacion en C++
System.out.println();//Salto de linea
}
}
A.getChars(ini, fin, vec, n) Donde A es de tipo String o StringBuilder y vec es un char[], ini, fin y n son
enteros positivos. La función getChars copia el contenido de un String o
StringBuilder a un char[], toma los caracteres de A a partir del carácter en la
posición ini hasta la posición fin y los copia en la posición n de vec.
toCharArray() Copia el contenido de una cadena de tipo String a un array char[].

3.3.2 OBTENCION DE CARACTERES

public class Caracteres {

public static void main(String args[]){
String A=new String("Programacion en JAVA");
StringBuilder B=new StringBuilder("Programacion en C++");
for(int i=0;i<A.length();i++)
System.out.print(A.charAt(i));//Muestra: Programacion en JAVA
System.out.println();
for(int i=0;i<B.length();i++)
32 José Gonzalo Espejo Cuba
GUIA DE JAVA

System.out.print(B.charAt(i));//Muestra: Programacion en C++

System.out.println();
}
}
charAt(i) Donde i es un entero no negativo, la función charAt devuelve el carácter de una
cadena de tipo String o StringBuilder en la i-esima posición.

3.3.3 CLASIFICACION DE CARACTERES

public class Clasificacion_Caracteres {

public static void main(String args[]){
String cad="31 de Octubre, de 2013!\nEl Mes de HALLOWEEN.\n";
int numdef,numcontrol,numespacios,numletras,nummayus,numminus,numdig,numda;
numdef=numcontrol=numespacios=numletras=nummayus=numminus=numdig=numda=0;
for(int i=0;i<cad.length();i++){
if(Character.isDefined(cad.charAt(i)))//El caracter esta definido?
numdef++;
if(Character.isISOControl(cad.charAt(i)))//El caracter es de control?
numcontrol++;
if(Character.isSpace(cad.charAt(i)))//El caracter es de espacio?
numespacios++;
if(Character.isLetter(cad.charAt(i))){//El caracter es de control?
numletras++;
if(Character.isLowerCase(cad.charAt(i)))//La letra es minuscula?
numminus++;
if(Character.isUpperCase(cad.charAt(i)))//La letra es mayuscula?
nummayus++;
}
if(Character.isDigit(cad.charAt(i)))//El caracter es digito
numdig++;
if(Character.isLetterOrDigit(cad.charAt(i)))//El caracter es digito
numda++;
}
System.out.println("Numero de caracteres definidos: "+numdef);//45
System.out.println("Numero de caracteres de control: "+numcontrol);//2
System.out.println("Numero de espacios: "+numespacios);//9
System.out.println("Numero de letras: "+numletras);//27
System.out.println("Numero de mayusculas: "+nummayus);//12
System.out.println("Numero de minusculas: "+numminus);//15
System.out.println("Numero de digitos: "+numdig);//6
System.out.println("Numero de digitos o letras: "+numda);//33
}
}
Character.isDefined(c) Donde c es un carácter, la función isDefined devuelve true (verdadero) si c está
definido. Caso contrario devuelve false (falso).
Character.isISOControl(c) Donde c es un carácter, la función isISOControl devuelve true (verdadero) si c es
de tipo de control. Caso contrario devuelve false (falso).
Character.isSpace(c) Donde c es un carácter, la función isSpace devuelve true (verdadero) si c es un
espacio. Caso contrario devuelve false (falso).
Character.isWhitespace(c) Donde c es un carácter, la función isWhitespace devuelve true (verdadero) si c es
un espacio. Caso contrario devuelve false (falso).
Character.isLetter(c) Donde c es un carácter, la función isLetter devuelve true (verdadero) si c es una
letra. Caso contrario devuelve false (falso).
Character.isJavaLetter(c) Donde c es un carácter, la función isJavaLetter devuelve true (verdadero) si c es
una letra. Caso contrario devuelve false (falso).
 José Gonzalo Espejo Cuba 33
GUIA DE JAVA

Character.isLowerCase(c) Donde c es un carácter, la función isLowerCase devuelve true (verdadero) si c es

una letra minúscula. Caso contrario devuelve false (falso).
Character.isUpperCase(c) Donde c es un carácter, la función isUpperCase devuelve true (verdadero) si c es
una letra mayúscula. Caso contrario devuelve false (falso).
Character.isDigit(c) Donde c es un carácter, la función isDigit devuelve true (verdadero) si c es un
digito. Caso contrario devuelve false (falso).
Character.isLetterOrDigit(c) Donde c es un carácter, la función isLetterOrDigit devuelve true (verdadero) si c
es un digito o una letra. Caso contrario devuelve false (falso).

3.3.4 CONVERSIONES DE CARACTERES DE MAYUSCULA A MINUSCULA

public class conversion_caracteres {

public static void main(String[] args) {
StringBuilder cad=new StringBuilder("Programacion En Lenguaje JAVA");
for(int i=0;i<cad.length();i++){
if(Character.isLetter(cad.charAt(i))){
if(Character.isUpperCase(cad.charAt(i)))
cad.setCharAt(i, Character.toLowerCase(cad.charAt(i)));
else
cad.setCharAt(i, Character.toUpperCase(cad.charAt(i)));
}
}
System.out.println(cad);//Muestra: pROGRAMACION eN lENGUAJE java
}
}
Character.toLowerCase(c) Donde c es un carácter, la función toLowerCase devuelve el carácter c
transformado en minúscula.
Character.toUpperCase(c) Donde c es un carácter, la función toUpperCase devuelve el carácter c
transformado en mayúscula.

3.4 CONVERSION DE CADENAS

3.4.1 CONVERSION A MAYUSCULAS Y MINUSCULAS

public class conversion_mayus_minus {

public static void main(String[] args) {
String cad1=new String("Programacion En Lenguaje JAVA");
String cad2,cad3;

cad2=cad1.toLowerCase();//Almacenando cad1 transformado en minusculas

cad3=cad1.toUpperCase();//Almacenando cad1 transformado en mayúsculas

System.out.println(cad2);//Muestra: programacion en lenguaje java

System.out.println(cad3);//Muestra: PROGRAMACION EN LENGUAJE JAVA
}
}
toLowerCase() Devuelve una copia de la cadena original con sus caracteres convertidos a minúsculas.
toUpperCase() Devuelve una copia de la cadena original con sus caracteres convertidos a mayúsculas.

3.4.2 CONVERSION DE CADENAS A NUMEROS

public class conversion_cadenas_numeros {

public static void main(String[] args) {
StringBuilder sb=new StringBuilder("45");
34 José Gonzalo Espejo Cuba
GUIA DE JAVA

String cad=sb.toString();//Conversion de StringBuilder a String

byte numbyte=Byte.parseByte(cad);//Conversion de String a byte

short numshort=Short.parseShort(cad);//Conversion de String a short
int numint=Integer.parseInt(cad);//Conversion de String a int
long numlong=Long.parseLong(cad);//Conversion de String a long
float realf=Float.parseFloat(cad);//Conversion de String a float
double reald=Double.parseDouble(cad);//Conversion de String a double

System.out.println(numbyte);//Muestra: 45
System.out.println(numshort);//Muestra: 45
System.out.println(numint);//Muestra: 45
System.out.println(numlong);//Muestra: 45
System.out.println(realf);//Muestra: 45.0
System.out.println(reald);//Muestra: 45.0
}
}

3.4.3 CONVERSION DE NUMEROS A CADENAS

import java.math.BigInteger;
import java.math.BigDecimal;
public class conversion_numeros_cadenas {
public static void main(String[] args) {
String cad1,cad2,cad3,cad4,cad5,cad6,cad7,cad8;
byte numbyte=22;
short numshort=1243;
int numint=2445;
long numlong=184345;
float realf=(float) 23.0;
double reald=45.23;
BigInteger bi=new BigInteger("345465");
BigDecimal bd=new BigDecimal("243.45");

cad1=Byte.toString(numbyte);//Conversion de Byte a String

cad2=Short.toString(numshort);//Conversion de Short a String
cad3=Integer.toString(numint);//Conversion de int a String
cad4=Long.toString(numlong);//Conversion de Long a String
cad5=Float.toString(realf);//Conversion de Float a String
cad6=Double.toString(reald);//Conversion de Double a String
cad7=bi.toString();//Conversion de BigInteger a String
cad8=bd.toString();//Conversion de BigDecimal a String

System.out.println(cad1);//Muestra: 22
System.out.println(cad2);//Muestra: 1243
System.out.println(cad3);//Muestra: 2445
System.out.println(cad4);//Muestra: 184345
System.out.println(cad5);//Muestra: 23.0
System.out.println(cad6);//Muestra: 45.23
System.out.println(cad7);//Muestra: 345465
System.out.println(cad8);//Muestra: 243.45
}
}

3.5 JAVA STRINGTOKENIZER

import java.util.StringTokenizer;
public class JAVA_StringTokenizer {
public static void main(String[] args) {
String cad1="Este es el primer ejemplo";
 José Gonzalo Espejo Cuba 35
GUIA DE JAVA

String cad2="Este!!!es, el segundo?. Ejemplo-";

StringTokenizer tokens1,tokens2,tokens3;
tokens1=new StringTokenizer(cad1);
tokens2=new StringTokenizer(cad1," ");
tokens3=new StringTokenizer(cad2," ,.!?-");

System.out.println("Tokens1");
while(tokens1.hasMoreTokens()){
System.out.println(tokens1.nextToken());
}

System.out.println("Tokens2");
while(tokens2.hasMoreTokens()){
System.out.println(tokens2.nextToken());
}

System.out.println("Tokens3");
while(tokens3.hasMoreTokens()){
System.out.println(tokens3.nextToken());
}
}
}
Tokens1 Tokens2 Tokens3
Este Este Este
es es es
el el el
primer primer segundo
ejemplo ejemplo Ejemplo
StringTokenizer(X) Donde X es de tipo String. Corta la cadena X en pedazos donde haya espacios en blanco.
StringTokenizer(X,Y) Donde X y Y son de tipo String. Corta la cadena X en pedazos donde se encuentre uno o más
caracteres que pertenecen a Y
36 José Gonzalo Espejo Cuba
GUIA DE JAVA

4 VECTORES Y MATRICES

4.1 CREACION DE VECTORES Y MATRICES

4.1.1 CREACION DE VECTORES

import java.util.Scanner;//Libreria para leer los datos

public class arrays {
//Metodo para crear un vector
public static int[] crea_vector(int dimension){
int nuevo[]=new int[dimension];
return nuevo;
}
//Metodo para leer los datos de un vector
public static void leer_vector(int x[],Scanner leer){
for(int i=0;i<x.length;i++)
x[i]=leer.nextInt();
}
//Metodo para imprimir los datos de un vector
public static void mostrar_vector(int x[]){
for(int i=0;i<x.length;i++)
System.out.print(x[i]+" ");
System.out.println();
}
public static void main(String[] args) {
Scanner lee=new Scanner(System.in);
int n=10;//Variable que sera la dimension del vector2 y del vector3
//Declara un vector1 con los espacios inicializados
int vector1[]={34, 67, 23, 45, 100, 450};
//Crea un vector2
int vector2[]=new int[n];
//Declara un vector3 y lo inicializa con el metodo crea_vector
int vector3[]=crea_vector(n);

//Leyendo desde teclado el vector2 y el vector 3

System.out.println("Introduzca "+n+" datos para el vector2");
leer_vector(vector2,lee);
System.out.println("Introduzca "+n+" datos para el vector3");
leer_vector(vector3,lee);

//Mostrando el contenido de los vector

System.out.println("Vector1:");
mostrar_vector(vector1);//Muestra: 34 67 23 45 100 450
System.out.println("Vector2:");
mostrar_vector(vector2);//Muestra los datos leidos
System.out.println("Vector3:");
mostrar_vector(vector3);//Muestra los datos leidos
}
}
Tipo_dato v[] Declara un array v de un tipo de dato.
Tipo_dato v[]= new Tipo_dato[n] Donde n es un entero positivo, crea un array v de n espacios, donde se
almacenaran n datos del mismo tipo de dato.

4.1.2 CREACION DE MATRICES

import java.util.Scanner;
public class matrices {
//Metodo para crear una matriz
public static int[][] crea_matriz(int filas, int columnas){
int nuevo[][]=new int[filas][columnas];
 José Gonzalo Espejo Cuba 37
GUIA DE JAVA

return nuevo;
}
//Metodo para leer los datos de una matriz
public static void leer_matriz(int x[][],int filas, int columnas,Scanner leer){
for(int i=0;i<filas;i++){
for(int j=0;j<columnas;j++)
x[i][j]=leer.nextInt();
}
}
//Metodo para mostrar los datos de una matriz
public static void mostrar_matriz(int x[][], int filas, int columnas){
for(int i=0;i<filas;i++){
for(int j=0;j<columnas;j++)
System.out.print(x[i][j]+" ");
System.out.println();
}
}
public static void main(String[] args) {
Scanner lee=new Scanner(System.in);
//Variables que seran la dimension de la matriz2 y de la matriz3
int n=3;
int m=4;

//Declara una matriz1 con los espacios inicializados

int matriz1[][]={{16,50,34,30},{25,11,10,14},{7,2,19,86}};

//Crea una matriz2

int matriz2[][]=new int[n][m];

//Declara una matriz3 y lo inicializa con el metodo crea_matriz

int matriz3[][]=crea_matriz(n, m);

//Leyendo desde teclado la matriz2 y la matriz3

System.out.println("Introduzca "+n*m+" datos para la matriz2");
leer_matriz(matriz2,n,m,lee);
System.out.println("Introduzca "+n*m+" datos para la matriz3");
leer_matriz(matriz3,n,m,lee);

//Mostrando el contenido de los vector

System.out.println("Matriz1:");
mostrar_matriz(matriz1,n,m);
/*
Muestra:
16 50 34 30
25 11 10 14
7 2 19 86
*/
System.out.println("Matriz2:");
mostrar_matriz(matriz2,n,m);//Muestra los datos leidos
System.out.println("Matriz3:");
mostrar_matriz(matriz3,n,m);//Muestra los datos leidos
}
}
Tipo_dato M[][] Declara una matriz M de un tipo de dato.
Tipo_dato M[]= new Tipo_dato[n][m] Donde n y m son enteros positivos, crea una matriz M de n*m, donde se
almacenaran n*m datos del mismo tipo de dato.

4.2 METODOS GENERICOS

public class metodos_genericos {

38 José Gonzalo Espejo Cuba
GUIA DE JAVA

//Metodo para mostrar los datos de un vector

public static <E> void mostrar_vector(E x[]){
for(int i=0;i<x.length;i++)
System.out.print(x[i]+" ");
System.out.println();
}
public static void main(String[] args) {
Byte vectorbyte[]={1,2,3,4,5,6,7,8,9,10,11,12};
Short vectorshort[]={101,102,103,104,105,200};
Integer vectorint[]={1000,2000,3000,4000,5000};
Long vectorlong[]={456L,4656L,45792L,12245L};
Float vectorfloat[]={1.00F, 566F,3.1416F,2.01F};
Double vectordouble[]={43.0034, 12.455, 45.0323, 2.001};
Character vectorchar[]={'H','O','L','A','!'};
String vectorstring[]={"Jose","Fermin","Mauricio","Roger"};

System.out.println("vectorbyte:");
mostrar_vector(vectorbyte);//Muestra: 1 2 3 4 5 6 7 8 9 10 11 12
System.out.println("vectorshort:");
mostrar_vector(vectorshort);//Muestra: 101 102 103 104 105 200
System.out.println("vectorint:");
mostrar_vector(vectorint);//Muestra: 1000 2000 3000 4000 5000
System.out.println("vectorlong:");
mostrar_vector(vectorlong);//Muestra: 456 4656 45792 12245
System.out.println("vectorfloat:");
mostrar_vector(vectorfloat);//Muestra: 1.0 566.0 3.1416 2.01
System.out.println("vectordouble:");
mostrar_vector(vectordouble);//Muestra: 43.0034 12.455 45.0323 2.001
System.out.println("vectorchar:");
mostrar_vector(vectorchar);//Muestra: H O L A !
System.out.println("vectorstring:");
mostrar_vector(vectorstring);//Muestra: Jose Fermin Mauricio Roger
}
}
 José Gonzalo Espejo Cuba 39
GUIA DE JAVA

5 PROGRAMACION ORIENTADA A OBJETOS

5.1 DEFINICION DE CLASES Y CONSTRUCTORES

5.1.1 DEFINIENDO UNA CLASE

class persona{
//ATRIBUTOS
private String nombre;
private String ap_paterno;
private String ap_materno;
//Fecha de nacimiento
private int dd;//dia
private int mm;//mes
private int aa;//año
}

5.1.2 CONSTRUCTORES

class persona{
//ATRIBUTOS
private String nombre;
private String ap_paterno;
private String ap_materno;
//Fecha de nacimiento
private int dd;//dia
private int mm;//mes
private int aa;//año

//CONSTRUCTORES: Inicialización de datos

//Constructor vacio
public persona(){}
//Constructor de persona con tres parametros (nombre y apellidos)
public persona(String nom,String ap,String am){
nombre=nom;
ap_paterno=ap;
ap_materno=am;
}
//Constructor de persona con tres parametros (fecha de nacimiento)
public persona(int d,int m,int a){
dd=d;
mm=m;
aa=a;
}
//Constructor de persona con todos los parametros
public persona(String nom,String ap,String am,int d,int m,int a){
nombre=nom;
ap_paterno=ap;
ap_materno=am;
dd=d;
mm=m;
aa=a;
}
public void mostrar(){
System.out.println("Nombre: "+nombre);
System.out.println("Apellido Paterno: "+ap_paterno);
System.out.println("Apellido Materno: "+ap_materno);
System.out.printf("Fecha de nacimiento: %02d/%02d/%04d\n",dd,mm,aa);
}
}//FIN DE LA CLASE persona
40 José Gonzalo Espejo Cuba
GUIA DE JAVA

public class POO {

public static void main(String args[]){
//Crea una persona A con el constructor vacio
persona A=new persona();
//Crea una persona B con el constructor de tres parametros (nombre y apellidos)
persona B=new persona("Jose Gonzalo","Espejo","Cuba");
//Crea una persona C con el constructor de tres parametros (fecha de nacimiento)
persona C=new persona(23,11,1997);
//Crea una persona D con el constructor de todos los parametros
persona D=new persona("Fermin","Papa","Frita",6,8,2006);
A.mostrar();
/*Muestra:
Nombre: null
Apellido Paterno: null
Apellido Materno: null
Fecha de nacimiento: 00/00/0000
*/
B.mostrar();
/*Muestra:
Nombre: Jose Gonzalo
Apellido Paterno: Espejo
Apellido Materno: Cuba
Fecha de nacimiento: 00/00/0000
*/
C.mostrar();
/*Muestra:
Nombre: null
Apellido Paterno: null
Apellido Materno: null
Fecha de nacimiento: 23/11/1997
*/
D.mostrar();
/*Muestra:
Nombre: Fermin
Apellido Paterno: Papa
Apellido Materno: Frita
Fecha de nacimiento: 06/08/2006
*/
}
}

5.2 FUNCIONES Y METODOS MIEMBROS DE UNA CLASE

5.2.1 EMPLEO DE LAS METODOS MIEMBRO

class semaforo{
//ATRIBUTOS
private boolean foco_rojo;
private boolean foco_amarillo;
private boolean foco_verde;
//CONSTRUCTOR
public semaforo(){foco_rojo=foco_amarillo=foco_verde=false;}
//METODOS O FUNCIONES MIEMBRO
public void encender_rojo(){
//Encendemos el foco rojo y apagamos los demas
foco_rojo=true;
foco_amarillo=false;
foco_verde=false;
}
public void encender_amarillo(){
//Encendemos el foco rojo y apagamos los demas
foco_rojo=false;
foco_amarillo=true;
 José Gonzalo Espejo Cuba 41
GUIA DE JAVA

foco_verde=false;
}
public void encender_verde(){
//Encendemos el foco rojo y apagamos los demas
foco_rojo=false;
foco_amarillo=false;
foco_verde=true;
}
public boolean puede_avanzar(){
//Si el foco verde esta encendido devuelve verdadero
return (foco_verde);
}
}//Fin de la clase semaforo

public class Maneja_semaforo {

public static void main(String[] args) {
semaforo S=new semaforo();
S.encender_rojo();
if(S.puede_avanzar())
System.out.println("Luz verde encendida, puede avanzar");
else
System.out.println("Luz verde apagada, debe detenerse");
S.encender_amarillo();
if(S.puede_avanzar())
System.out.println("Luz verde encendida, puede avanzar");
else
System.out.println("Luz verde apagada, debe detenerse");
S.encender_verde();
if(S.puede_avanzar())
System.out.println("Luz verde encendida, puede avanzar");
else
System.out.println("Luz verde apagada, debe detenerse");
}
}

5.2.2 SOBRECARGA DE METODOS

class persona{
//ATRIBUTOS
private String nombre;
private String ap_paterno;
private String ap_materno;
//Fecha de nacimiento
private int dd;//dia
private int mm;//mes
private int aa;//año

public persona(){}
public void set_datos(String nom,String ap,String am){
nombre=nom;
ap_paterno=ap;
ap_materno=am;
}
public void set_datos(int d,int m,int a){
dd=d;
mm=m;
aa=a;
}
public void set_datos(String nom,String ap,String am,int d,int m,int a){
nombre=nom;
ap_paterno=ap;
ap_materno=am;
42 José Gonzalo Espejo Cuba
GUIA DE JAVA

dd=d;
mm=m;
aa=a;
}
public void mostrar(){
System.out.println("Nombre: "+nombre);
System.out.println("Apellido Paterno: "+ap_paterno);
System.out.println("Apellido Materno: "+ap_materno);
System.out.printf("Fecha de nacimiento: %02d/%02d/%04d\n",dd,mm,aa);
}
}//FIN DE LA CLASE persona

public class Sobrecarga_funciones {

public static void main(String[] args) {
persona A=new persona();
A.mostrar();
/*Muestra:
Nombre: null
Apellido Paterno: null
Apellido Materno: null
Fecha de nacimiento: 00/00/0000
*/
System.out.println();
A.set_datos("Jose Gonzalo", "Espejo", "Cuba");
A.mostrar();
/*Muestra:
Nombre: Jose Gonzalo
Apellido Paterno: Espejo
Apellido Materno: Cuba
Fecha de nacimiento: 00/00/0000
*/
System.out.println();
A.set_datos(25,11,1986);
A.mostrar();
/*Muestra:
Nombre: Jose Gonzalo
Apellido Paterno: Espejo
Apellido Materno: Cuba
Fecha de nacimiento: 25/11/1986
*/
System.out.println();

persona B=new persona();

B.set_datos("Fermin", "Papa", "Frita", 6, 10, 2003);
B.mostrar();
/*Muestra:
Nombre: Fermin
Apellido Paterno: Papa
Apellido Materno: Frita
Fecha de nacimiento: 06/10/2003
*/
}
}

5.3 ACCESO A LOS DATOS DE UNA CLASE

5.3.1 METODOS GET Y SET (DATOS DE TIPO PRIVADO ENCAPSULADOS)

class persona{
//ATRIBUTOS
private String nombre;
private String ap_paterno;
private String ap_materno;
 José Gonzalo Espejo Cuba 43
GUIA DE JAVA

//Fecha de nacimiento
private int dd;//dia
private int mm;//mes
private int aa;//año
public persona(){}
//FUNCIONES PARA MODIFICAR DATOS PRIVADOS
public void set_nombre(String nom){nombre=nom;}
public void set_ap_paterno(String ap){ap_paterno=ap;}
public void set_ap_materno(String am){ap_materno=am;}
public void set_fec_nac(int d,int m,int a){
dd=d;
mm=m;
aa=a;
}
//FUNCIONES PARA OBTENER DATOS PRIVADOS
public String get_nombre(){return nombre;}
public String get_ap_paterno(){return ap_paterno;}
public String get_ap_materno(){return ap_materno;}

}//FIN DE LA CLASE persona

public class acceso_datos {

public static void main(String args[]){
persona P=new persona();
P.set_nombre("Jose Gonzalo");
P.set_ap_paterno("Espejo");
P.set_ap_materno("Cuba");
P.set_fec_nac(25, 11, 1986);

//Mostrando los datos de persona P

System.out.println(P.get_nombre());//Muestra: Jose Gonzalo
System.out.println(P.get_ap_paterno());//Muestra: Espejo
System.out.println(P.get_ap_materno());//Muestra: Cuba
}
}

5.3.2 ACCESO A DATOS DIRECTAMENTE (SIN ENCAPSULACION)

class persona{
//ATRIBUTOS
String nombre;
String ap_paterno;
String ap_materno;
//Fecha de nacimiento
int dd;//dia
int mm;//mes
int aa;//año
public persona(){}
}//FIN DE LA CLASE persona

public class acceso_datos {

public static void main(String args[]){
persona P=new persona();
P.nombre="Jose Gonzalo";
P.ap_paterno="Espejo";
P.ap_materno="Cuba";
P.dd=25;
P.mm=11;
P.aa=1986;

//Mostrando los datos de persona P

System.out.println(P.nombre);//Muestra: Jose Gonzalo
44 José Gonzalo Espejo Cuba
GUIA DE JAVA

System.out.println(P.ap_paterno);//Muestra: Espejo
System.out.println(P.ap_materno);//Muestra: Cuba
System.out.printf("%02d/%02d/%04d\n", P.dd,P.mm,P.aa);//Muestra: 25/11/1986
}
}

5.4 HERENCIA

class persona{
//ATRIBUTOS
protected String nombre;
protected String ap_paterno;
protected String ap_materno;
//Fecha de nacimiento
protected int dd;//dia
protected int mm;//mes
protected int aa;//año
public persona(){}
public persona(String nom,String ap,String am, int d,int m,int a){
nombre=nom;
ap_paterno=ap;
ap_materno=am;
dd=d;
mm=m;
aa=a;
}
public void mostrar(){
System.out.println("Nombre: "+nombre);
System.out.println("Apellido Paterno: "+ap_paterno);
System.out.println("Apellido Materno: "+ap_materno);
System.out.printf("Fecha de nacimiento: %02d/%02d/%04d\n",dd,mm,aa);
}
}//FIN DE LA CLASE persona
class estudiante extends persona{
String cod_estudiante;
estudiante(){
super();//Hereda el contructor vacio de persona
}
//Constructor de 7 parametros
estudiante(String nom,String ap,String am, int d,int m,int a,String ce){
super(nom,ap,am,d,m,a);//Hereda el contructor de 6 parametros de persona
cod_estudiante=ce;
}

public String get_codigo(){return cod_estudiante;}

}//FIN DE LA CLASE estudiante

public class Herencia_simple {

public static void main(String[] args) {
estudiante E=new estudiante("Jose Gonzalo","Espejo","Cuba",25,11,1986,"ECJ251186");
E.mostrar();
System.out.println("Codigo: "+E.get_codigo());
/*Muestra:
Nombre: Jose Gonzalo
Apellido Paterno: Espejo
Apellido Materno: Cuba
Fecha de nacimiento: 25/11/1986
Codigo: ECJ251186
*/
}
}
 José Gonzalo Espejo Cuba 45
GUIA DE JAVA

5.5 COMPOSICION
5.5.1 EJEMPLO SIMPLE

import java.util.Scanner;
class oficina{
private int nro;
private int capacidad;
private String detalle;
public oficina(int n,int c,String d){
nro=n;
capacidad=c;
detalle=d;
}
void mostrar_oficina(){
System.out.println("Nro: "+nro);
System.out.println("Capacidad: "+capacidad);
System.out.println("Nro: "+nro);
}
}
class edificio{
int nro_oficinas;
oficina vec[];
edificio(int n){
nro_oficinas=n;
vec=new oficina[nro_oficinas];
}
public void crear_oficinas(Scanner leer){
int a,b;
String c;
for(int i=0;i<nro_oficinas;i++){
a=leer.nextInt();
b=leer.nextInt();
c=leer.next();
vec[i]=new oficina(a,b,c);
}
}
public void mostrar(){
for(int i=0;i<nro_oficinas;i++){
vec[i].mostrar_oficina();
System.out.println("**********");
}
}
}
public class Ejemplo_composicion {
public static void main(String[] args) {
Scanner leer=new Scanner(System.in);
edificio E=new edificio(2);
E.crear_oficinas(leer);
E.mostrar();
}
}
46 José Gonzalo Espejo Cuba
GUIA DE JAVA

6 CONTENEDORES DE JAVA

6.1 VECTORS (VECTORES)

6.1.1 INSERCCION DE ELEMENTOS

import java.util.Vector;//Librería para utilizar los vectores dinámicos de JAVA

public class Vector_inserccion {
public static void mostrar_Vector(Vector <Integer> V){
for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i) +" ");
System.out.println();
}
public static void main(String[] args) {
//CONSTRUCTORES DE VECTOR
Vector <Integer> v1=new Vector <Integer>();//Crea un Vector v1
Vector <Integer> v2=new Vector <Integer>();//Crea un Vector v2
//INSERCCION DE ELEMENTOS
System.out.println("FUNCION ADD");
v1.add(5);//Inserta 5 al final de v1
v1.add(17);//Inserta 17 al final de v1
v1.add(13);//Inserta 13 al final de v1
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 5 17 13
v1.add(0, 8);//Inserta 8 al principio de v1
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 8 5 17 13
v1.add(2, 16);//Inserta 16 en la posicion 2 de v1
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 8 5 16 17 13

System.out.println("\nFUNCION ADDELEMENT");
v2.addElement(14);//Añade el elemento 14
v2.addElement(4);//Añade el elemento 4
System.out.print("v2: ");
mostrar_Vector(v2);//Muestra: 14 4

System.out.println("\nFUNCION ADDALL");
v1.addAll(v2);//Inserta v2 al final de v1
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 8 5 16 17 13 14 4
v1.addAll(3, v2);//Inserta v2 en la posicion 3 de v1
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 8 5 16 14 4 17 13 14 4

System.out.println("FUNCION INSERTELEMENTAT");
v1.insertElementAt(100, 7);//Inserta 100 en la posicion 7 de v1
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 8 5 16 14 4 17 13 100 14 4
v1.insertElementAt(94, 10);//Inserta 94 en la posicion final de v1
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 8 5 16 14 4 17 13 100 14 4 94
}
}
V.add(dato) Donde V es un vector, la función add inserta el dato en la posición final de V.
V.add(pos,dato) Donde V es un vector y pos en un entero no negativo, la función add inserta el dato
en la posición pos de V.
V.addElement(dato) Donde V es un vector, la función addElement inserta el dato en la posición final de
V.
V1.addAll(V2) Donde V1 y V2 son vectores, la función addAll inserta el contenido de V2 en la
 José Gonzalo Espejo Cuba 47
GUIA DE JAVA

posición final de V1.

V1.addAll(pos,V2) Donde V1 y V2 son vectores y pos es un entero no negativo, la función addAll
inserta el contenido de V2 en la posición pos de V1.
V.insertElementAt(dato,pos) Donde V es un vector y pos en un entero no negativo, la función insertElementAt
inserta el dato en la posición pos de V.

6.1.2 ELIMINACION DE DATOS DEL VECTOR

import java.util.Vector;
public class Vector_eliminacion_datos {
public static void mostrar_Vector(Vector <Integer> V){
for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i) +" ");
System.out.println();
}
public static void main(String[] args) {
Vector<Integer>v1=new Vector<Integer>();
Vector<Integer>v2=new Vector<Integer>();
Vector<Integer>v3=new Vector<Integer>();
v1.add(6);
v1.add(50);
v1.add(15);
v1.add(25);
v1.add(10);
v1.add(9);
v1.add(24);
v2.add(25);
v2.add(7);
v2.add(10);
v3.add(50);
v3.add(24);
v3.add(12);
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 6 50 15 25 10 9 24
System.out.print("v2: ");
mostrar_Vector(v2);//Muestra: 25 7 10
System.out.print("v3: ");
mostrar_Vector(v3);//Muestra: 50 24 12

System.out.println("FUNCION REMOVE");
v1.remove(2);//Elimina el dato de la posicion 2
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 6 50 25 10 9 24
System.out.println("FUNCION REMOVEELEMENTAT");
v1.removeElementAt(0);//Elimina el dato de la posicion inicial
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 50 25 10 9 24
System.out.println("FUNCION REMOVEALL");
v1.removeAll(v2);//Elimina los datos de v1 que se encuentran en v2
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 50 9 24
System.out.println("FUNCION RETAINALL");
v1.retainAll(v3);//Elimina los datos de v1 que se no encuentran en v3
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra: 50 9 24
System.out.println("FUNCION REMOVEALLELEMENTS");
v1.removeAllElements();//Elimina todos los datos
System.out.print("v1: ");
mostrar_Vector(v1);//Muestra:
}
48 José Gonzalo Espejo Cuba
GUIA DE JAVA

}
V.remove(k) Donde V es un vector y k es un entero no negativo, la función remove elimina el dato
que se encuentra en la k-esima posición.
V.removeElementAt(k) Donde V es un vector y k es un entero no negativo, la función removeElementAt
elimina el dato que se encuentra en la k-esima posición.
V1.removeAll(V2) Donde V1 y V2 son vectores. La función removeAll elimina los datos de V1 que se
encuentran en V2.
V1.retainAll(V2) Donde V1 y V2 son vectores. La función retainAll elimina los datos de V1 que no se
encuentran en V2.
V.removeAllElements() Donde V es un vector. La función removeAllElements elimina todos los datos de V.

6.1.3 REEMPLAZO DE DATOS EN UN VECTOR

import java.util.Vector;
public class reemplazo_datos {
public static void mostrar(Vector<Integer> V){
for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i)+" ");
System.out.println();
}
public static void main(String args[]){
Vector<Integer>V=new Vector<Integer>();
V.add(3);
V.add(28);
V.add(17);
V.add(31);
V.add(25);
mostrar(V);//Muestra: 3 28 17 31 25

System.out.println("FUNCION SET");
V.set(2, 54);//Reemplazando el dato de la posicion 2
mostrar(V);//Muestra: 3 28 54 31 25
System.out.println("FUNCION SETELEMENTAT");
V.setElementAt(100,4);//Reemplazando el dato de la posicion 4
mostrar(V);//Muestra: 3 28 54 31 100
}
}
set(k, nuevo_dato) Donde k es un entero no negativo. La función set reemplaza el dato que se
encuentra en la k-esima posición por un nuevo dato.
setElementAt(k, nuevo_dato) Donde k es un entero no negativo. La función setElementAt reemplaza el dato que
se encuentra en la k-esima posición por un nuevo dato.

6.1.4 CAPACIDAD Y TAMAÑO DEL VECTOR

import java.util.Vector;
public class Vector_capacity {
public static void mostrar(Vector<Integer> V){
for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i)+" ");
System.out.println();
}
public static void main(String args[]){
Vector<Integer>V=new Vector<Integer>();
V.add(3);
V.add(28);
 José Gonzalo Espejo Cuba 49
GUIA DE JAVA

V.add(17);
V.add(31);
V.add(25);
mostrar(V);//Muestra: 3 28 17 31 25
System.out.println("Longitud del vector: "+V.size());//5

V.setSize(11);//Modificando la longitud del vector

mostrar(V);//Muestra: 3 28 17 31 25 null null null null null
System.out.println("Longitud del vector: "+V.size());//11

V.setSize(4);//Modificando la longitud del vector

mostrar(V);//Muestra: 3 28 17 31
System.out.println("Longitud del vector: "+V.size());//4

V.clear();//Eliminando todos los elementos del vector

mostrar(V);//Muestra:
System.out.println("Longitud del vector: "+V.size());//0

if(V.isEmpty())//El vector esta vacio?

System.out.println("Si, el vector esta vacio");
}
}
size() Devuelve un entero que representa la longitud del vector, es decir el número de elementos que contiene.
setSize(n) Donde n es un entero no negativo. La función setSize establece el tamaño del vector, si n es menor al
tamaño actual del vector entonces se conservan los primeros n elementos.
clear() Donde V es un vector. La función clear() elimina todos los datos de V.
isEmpty() Devuelve true (verdadero) si el vector este vacio, es decir no contiene ningún elemento. Caso contrario
devuelve false (falso).

6.1.5 ELEMENTOS DEL VECTOR

import java.util.Vector;
public class Vector_elements {
public static void main(String args[]){
Vector<Integer>V=new Vector<Integer>();
V.add(3);
V.add(28);
V.add(17);
V.add(31);
V.add(25);

System.out.println("ElementAt");
for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i)+" ");//Muestra: 3 28 17 31 25
System.out.println();

System.out.println("get");
for(int i=0;i<V.size();i++)
System.out.print(V.get(i)+" ");//Muestra: 3 28 17 31 25
System.out.println();
//Mediante iteradores
ListIterator listIterator = V.listIterator();
while(listIterator.hasNext())//Mientras haya mas elementos
System.out.print(listIterator.next()+" ");
System.out.println();

System.out.println("Primer elemento: "+V.firstElement());//3

System.out.println("Ultimo elemento: "+V.lastElement());//25
}
50 José Gonzalo Espejo Cuba
GUIA DE JAVA

}
elementAt(i) Donde i es un entero no negativo. La función elementAt devuele el dato que se enceuntra en la i-
esima posición.
get(i) Donde i es un entero no negativo. La función get devuele el dato que se enceuntra en la i-esima
posición.
firstElement() Devuele el dato que se enceuntra en la primera posición.
lastElement() Devuele el dato que se enceuntra en la ultima posición.
ListIterator() Funciona como un puntero. Se obtiene los datos mediante iteradores.
hasnext() Devuelve true (verdadero) si el iterador esta apuntando a un elemento del contenedor. Caso
contrario devuelve false (falso).
next() Apunta al siguiente elemento del contenedor.

6.1.6 COMPARACION Y BUSQUEDA DE SECUENCIA DE DATOS

import java.util.Vector;
public class busqueda_y_comparacion {
public static void main(String args[]){
Vector<Integer>V1=new Vector<Integer>();
Vector<Integer>V2=new Vector<Integer>();
Vector<Integer>V3=new Vector<Integer>();
V1.add(3);V1.add(28);V1.add(17);V1.add(31);V1.add(25);
V2.add(3);V2.add(28);V2.add(17);V2.add(31);V2.add(25);
V3.add(28);V3.add(17);V3.add(31);

//COMPARACION DE V1 CON V2
if(V1.equals(V2))//V1 y V2 son iguales?
System.out.println("Los vectores V1 y V2 son iguales");
else
System.out.println("Los vectores V1 y V2 son diferentes");
//Muestra: Los vectores V1 y V2 son iguales

//BUSQUEDA DE ELEMENTOS
if(V1.contains(17))//V1 contiene el numero 17?
System.out.println("17 esta en el vector V1");
else
System.out.println("17 no se encuentra en el vector V1");
//Muestra: 17 esta en el vector V1

if(V1.containsAll(V3))//V1 contiene a V3
System.out.println("V1 contiene a V3");
else
System.out.println("V3 no se encuentra en V1");
//Muestra: V1 contiene a V3
}
}
V1.equals(V2) Donde V1 y V2 son vectores. La función equals devuelve true (verdadero) si V1 y V2 son
iguales, es decir que contienen los mismos elementos. Caso contrario devuelve false (falso).
V.contains(dato) Donde V es un vector. La función contains devuelve true (verdadero) si el dato esta en V. Caso
contrario devuelve false (falso).
V1.containsAll(V2) Donde V1 y V2 son vectores. La función containsAll devuelve true (verdadero) si V1contiene a
V2. Caso contrario devuelve false (falso).
clear() Donde V es un vector. La función clear() elimina todos los datos de V.
isEmpty() Devuelve true (verdadero) si el vector este vacio, es decir no contiene ningún elemento. Caso
 José Gonzalo Espejo Cuba 51
GUIA DE JAVA

contrario devuelve false (falso).

6.2 STACKS (PILAS)

import java.util.Stack;
public class Pila {
public static void main(String args[]){
Stack<Integer>P=new Stack<Integer>();
//Introduciendo los datos: 12, 43, 4, 11, 20 y 13 a la pila P
P.push(12);
P.push(43);
P.push(4);
P.push(11);
P.push(20);
P.push(13);
System.out.println("Longitud de la pila: "+P.size());//6

//Removiendo y mostrando los datos de la pila.

while(!P.empty()){//Mientras que la pila P no este vacia
System.out.print(P.peek()+" ");//Muestra el ultimo dato de la pila P
P.pop();//Devuelve el ultimo dato de la pila P y lo elimina
}//Impresion: 13 20 11 4 43 12
}
}
push(dato) Introduce un dato al final de la pila.
peek() Devuelve el último dato que fue introducido en la pila.
pop() Devuelve y elimina el último dato que fue introducido en la pila.
empty() Devuelve true (verdadero) si la pila esta vacia, es decir no contiene ningún elemento. Caso contrario
devuelve false (falso).
size() Devuelve un entero que representa la longitud de la pila, es decir el número de elementos que contiene.

6.3 QUEUES (COLAS)

import java.util.Queue;
import java.util.ArrayDeque;
public class Cola {
public static void main(String[] args) {
Queue <Integer> C=new ArrayDeque<Integer>();
//Introduciendo los datos: 12, 43, 4, 11, 20 y 13 a la cola C
C.add(12);
C.add(43);
C.add(4);
C.add(11);
C.offer(20);
C.offer(13);
System.out.println("Longitud de la cola: "+C.size());//6

//Removiendo y mostrando los datos de la cola.

while(!C.isEmpty()){//Mientras que la cola C no este vacia
System.out.print(C.peek()+" ");//Muestra el primer dato de la cola C
C.poll();//Devuelve el primer dato de la cola C y lo elimina
}//Impresion: 12 43 4 11 20 13
}
}
add(dato) Introduce un dato al final de la cola.
52 José Gonzalo Espejo Cuba
GUIA DE JAVA

offer(dato) Introduce un dato al final de la cola.

element() Devuelve el primer dato que se encuentra al principio de la cola,
peek() Devuelve el primer dato que se encuentra al principio de la cola; Devuelve null si la cola esta vacia.
poll() Devuelve y elimina el primer dato que se encuentra al principio de la cola; Devuelve null si la cola esta
vacia.
remove() Devuelve y elimina el primer dato que se encuentra al principio de la cola.
isEmpty() Devuelve true (verdadero) si la cola esta vacia, es decir no contiene ningún elemento. Caso contrario
devuelve false (falso).
size() Devuelve un entero que representa la longitud de la cola, es decir el número de elementos que contiene.

6.4 COLA DE PRIORIDADES

6.4.1 COLA DE PRIORIDADES DE DATOS PRIMITIVOS

import java.util.PriorityQueue;
public class priorityqueue1 {
public static void main(String args[]){
PriorityQueue<Integer> CP=new PriorityQueue<Integer>();
//Introduciendo datos a la cola de prioridades CP2
CP.add(34);
CP.add(57);
CP.add(12);
CP.add(24);
CP.add(93);
System.out.println("Longitud de CP2: "+CP.size());//5
if(CP.contains(34))//CP contiene el dato 34?
System.out.println("CP contiene a 34");
while(!CP.isEmpty()){//Mientras CP no este vacio
System.out.print(CP.peek()+" ");
CP.poll();
}//Imprime: 12 24 34 57 93
System.out.println();
}
}
add(dato) Introduce un dato en la cola de prioridades.
peek() Devuelve el menor de los datos de la cola de prioridades.
remove() Devuelve el menor de los datos de la cola de prioridades.
poll() Devuelve el menor de los datos de la cola de prioridades. A diferencia de peek, remueve este dato.
isEmpty() Devuelve true (verdadero) si la cola de prioridades esta vacia, es decir no contiene ningún elemento.
Caso contrario devuelve false (falso).
size() Devuelve un entero que representa el tamaño o longitud de la cola de prioridades, es decir el número
de elementos que contiene.
contains(dato) Devuelve true (verdadero) si la cola de prioridades contiene el dato. Caso contrario devuelve false
(falso).

6.4.2 COLA DE PRIORIDADES DE CLASES

//Programa de Cola de Prioridades que almacena la clase Estudiante ordenandolo por el

//Nombre
import java.util.PriorityQueue;
class Estudiante implements Comparable<Estudiante>{
 José Gonzalo Espejo Cuba 53
GUIA DE JAVA

String nombre;
int codigo;
public Estudiante(String name,int code){
nombre=name;
codigo=code;
}
//Metodo para comparar dos cadenas (orden lexicografico)
public int compareTo(Estudiante otro) {
return nombre.compareToIgnoreCase(otro.nombre);
}
public void mostrar(){
System.out.println("Nombre: "+nombre);
System.out.println("Codigo: "+codigo);
}
}
public class ColaPrioridad_Estudiante {
public static void main(String args[]){
PriorityQueue<Estudiante> CP=new PriorityQueue<Estudiante>();
CP.add(new Estudiante("Juan Perez",45));
CP.add(new Estudiante("Miguel Sanchez",17));
CP.add(new Estudiante("Alan Romero",100));
CP.add(new Estudiante("Alan Castillo",120));
//Ordenado mediante el Nombre
while(!CP.isEmpty()){
CP.poll().mostrar();
System.out.println();
}
/*MUESTRA:
Nombre: Alan Castillo
Codigo: 120

Nombre: Alan Romero

Codigo: 100

Nombre: Juan Perez

Codigo: 45

Nombre: Miguel Sanchez

Codigo: 17
*/
}
}
//Programa de Cola de Prioridades que almacena la clase Estudiante ordenandolo por el
//codigo
import java.util.PriorityQueue;
class Estudiante implements Comparable<Estudiante>{
String nombre;
int codigo;
public Estudiante(String name,int code){
nombre=name;
codigo=code;
}
//Programa para comparar dos numeros
public int compareTo(Estudiante otro) {
return codigo-otro.codigo;
}
public void mostrar(){
System.out.println("Nombre: "+nombre);
System.out.println("Codigo: "+codigo);
}
}
public class ColaPrioridad_Estudiante {
public static void main(String args[]){
54 José Gonzalo Espejo Cuba
GUIA DE JAVA

PriorityQueue<Estudiante> CP=new PriorityQueue<Estudiante>();

CP.add(new Estudiante("Juan Perez",45));
CP.add(new Estudiante("Miguel Sanchez",17));
CP.add(new Estudiante("Alan Romero",100));
CP.add(new Estudiante("Alan Castillo",120));
//Ordenado mediante el codigo
while(!CP.isEmpty()){
CP.poll().mostrar();
System.out.println();
}
/*MUESTRA:
Nombre: Miguel Sanchez
Codigo: 17

Nombre: Juan Perez

Codigo: 45

Nombre: Alan Romero

Codigo: 100

Nombre: Alan Castillo

Codigo: 120
*/
}
}

6.5 DEQUES (BICOLAS)

import java.util.Deque;
import java.util.ArrayDeque;
import java.util.Iterator;
public class Bicola {
//Metodo que recorre una bicola mediante un iterador ascendente
public static void mostrar_bicola1(Deque <Integer> X){
Iterator<Integer>it=X.iterator();
while(it.hasNext())
System.out.print(it.next()+" ");
System.out.println();
}
//Metodo que recorre una bicola mediante un iterador descendente
public static void mostrar_bicola2(Deque <Integer> X){
Iterator<Integer>it=X.descendingIterator();
while(it.hasNext())
System.out.print(it.next()+" ");
System.out.println();
}
public static void main(String[] args) {
Deque<Integer>B=new ArrayDeque<Integer>();
//Introduciendo por delante los datos: 8, 11, 15
B.addFirst(8);
B.addFirst(11);
B.offerFirst(15);
mostrar_bicola1(B);//Muestra: 15 11 8
//Introduciendo por detras los datos: 12, 20, 13
B.addLast(12);
B.addLast(20);
B.offerLast(13);
mostrar_bicola1(B);//Muestra: 15 11 8 12 20 13
mostrar_bicola2(B);//Muestra: 13 20 12 8 11 15
System.out.println("Longitud de la bicola: "+B.size());//6
if(B.contains(15))//¿Esta el dato 15 en la bicola B?
System.out.println("La bicola B si contiene el dato 15");
 José Gonzalo Espejo Cuba 55
GUIA DE JAVA

else
System.out.println("La bicola B no contiene el dato 15");
//Muestra: La bicola B si contiene el dato 15

System.out.println("Primer dato de la bicola: "+B.getFirst());//15

System.out.println("Ultimo dato de la bicola: "+B.getLast());//13
B.pollFirst();//Elimina el primer dato de la bicola
B.pollLast();//Elimina el ultimo dato de la bicola
mostrar_bicola1(B);//Muestra: 11 8 12 20
System.out.println("Primer dato de la bicola: "+B.peekFirst());//11
System.out.println("Ultimo dato de la bicola: "+B.peekLast());//20
B.removeFirst();//Elimina el primer dato de la bicola
B.removeLast();//Elimina el ultimo dato de la bicola
mostrar_bicola1(B);//Muestra: 8 12

if(B.isEmpty())
System.out.println("La bicola esta vacia");
else
System.out.println("La bicola tiene "+B.size()+" elementos");
//Muestra: La bicola tiene 2 elementos
}
}
addFirst(dato) Introduce un dato al principio de la bicola.
offerFirst(dato) Introduce un dato al principio de la bicola.
addLast(dato) Introduce un dato al final de la bicola.
offerLast(dato) Introduce un dato al final de la bicola.
getFirst() Devuelve el primer dato que se encuentra al principio de la bicola,
peekFirst() Devuelve el primer dato que se encuentra al principio de la bicola; Devuelve null si la bicola
esta vacia.
pollFirst() Devuelve y elimina el primer dato que se encuentra al principio de la bicola; Devuelve null si
la bicola esta vacia.
removeFirst() Devuelve y elimina el primer dato que se encuentra al principio de la bicola.
getLast() Devuelve el ultimo dato que se encuentra al principio de la bicola,
peekLast() Devuelve el ultimo dato que se encuentra al principio de la bicola; Devuelve null si la bicola
esta vacia.
pollLast() Devuelve y elimina el ultimo dato que se encuentra al principio de la bicola; Devuelve null si
la bicola esta vacia.
removeLast() Devuelve y elimina el último dato que se encuentra al principio de la bicola.
isEmpty() Devuelve true (verdadero) si la bicola esta vacia, es decir no contiene ningún elemento. Caso
contrario devuelve false (falso).
size() Devuelve un entero que representa la longitud de la bicola, es decir el número de elementos
que contiene.
contains(dato) Devuelve true (verdadero) si la bicola contiene el dato. Caso contrario devuelve false (falso).
iterator() Devuelve un iterador que avanza de maner ascendente, desde el primer elemento hasta el
último.
descendingIterator() Devuelve un iterador que avanza de maner descendente, desde el último elemento hasta el
primero.
clear() Elimina todos los elementos de la bicola.
56 José Gonzalo Espejo Cuba
GUIA DE JAVA

6.6 LISTAS
6.6.1 INSERCCION DE DATOS EN LAS LISTAS

import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class Linkedlist {
public static void mostrar_Lista(List< Integer > X){
ListIterator <Integer> iterador = X.listIterator();
while(iterador.hasNext())
System.out.print(iterador.next()+" ");
System.out.println();
}
public static void main(String[] args) {
List<Integer>L1=new LinkedList<Integer>();//Crea una lista L1
List<Integer>L2=new LinkedList<Integer>();//Crea una lista L2

//INSERCCION DE ELEMENTOS
System.out.println("FUNCION ADD");
L1.add(5);//Inserta 5 al final de v1
L1.add(17);//Inserta 17 al final de v1
L1.add(13);//Inserta 13 al final de v1
System.out.print("L1: ");
mostrar_Lista(L1);//Muestra: 5 17 13
L1.add(0, 8);//Inserta 8 al principio de v1
System.out.print("L1: ");
mostrar_Lista(L1);//Muestra: 8 5 17 13
L1.add(2, 16);//Inserta 16 en la posicion 2 de v1
System.out.print("L1: ");
mostrar_Lista(L1);//Muestra: 8 5 16 17 13

System.out.println("\nFUNCION ADDALL");
L2.addAll(L1);//Inserta L1 al final de L2
System.out.print("L2: ");
mostrar_Lista(L2);//Muestra: 8 5 16 17 13
L2.addAll(3, L1);//Inserta L1 en la posicion 3 de L2
System.out.print("L2: ");
mostrar_Lista(L2);//Muestra: 8 5 16 8 5 16 17 13 17 13
}
}
L.add(dato) Donde L es una lista, la función add inserta el dato en la posición final de L.
L.add(pos,dato) Donde L es una lista y pos en un entero no negativo, la función add inserta el dato en la
posición pos de L.
L.addAll(C) Donde L es una lista y C es una estructura de coleccion, la función addAll inserta el
contenido de C en la posición final de L.
L.addAll(pos,C) Donde L es una lista y C es una estructura de coleccion, la función addAll inserta el
contenido de C en la posición pos de L.

6.6.2 ELIMINACION DE DATOS DE LA LISTA

import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class List_eliminacion_datos {
public static void mostrar_Lista(List< Integer > X){
ListIterator <Integer> iterador = X.listIterator();
while(iterador.hasNext())
System.out.print(iterador.next()+" ");
System.out.println();
 José Gonzalo Espejo Cuba 57
GUIA DE JAVA

}
public static void main(String[] args) {
List<Integer>L1=new LinkedList<Integer>();
List<Integer>L2=new LinkedList<Integer>();
List<Integer>L3=new LinkedList<Integer>();
L1.add(6);
L1.add(50);
L1.add(15);
L1.add(25);
L1.add(10);
L1.add(9);
L1.add(24);
L2.add(25);
L2.add(7);
L2.add(10);
L3.add(50);
L3.add(24);
L3.add(12);
System.out.print("L1: ");
mostrar_Lista(L1);//Muestra: 6 50 15 25 10 9 24
System.out.print("L2: ");
mostrar_Lista(L2);//Muestra: 25 7 10
System.out.print("L3: ");
mostrar_Lista(L3);//Muestra: 50 24 12

System.out.println("FUNCION REMOVE");
L1.remove(2);//Elimina el dato de la posicion 2
System.out.print("L1: ");
mostrar_Lista(L1);//Muestra: 6 50 25 10 9 24

System.out.println("FUNCION REMOVEALL");
L1.removeAll(L2);//Elimina los datos de L1 que se encuentran en L2
System.out.print("L1: ");
mostrar_Lista(L1);//Muestra: 6 50 9 24

System.out.println("FUNCION RETAINALL");
L1.retainAll(L3);//Elimina los datos de L1 que se no encuentran en L3
System.out.print("L1: ");
mostrar_Lista(L1);//Muestra: 50 24

System.out.println("FUNCION CLEAR");
L1.clear();//Elimina todos los datos
System.out.print("L1: ");
mostrar_Lista(L1);//Muestra:
}
}
L.remove(k) Donde L es una lista y k es un entero no negativo, la función remove elimina el dato que se
encuentra en la k-esima posición.
L.removeAll(C) Donde L es una lista y C es una colección. La función removeAll elimina los datos de L que se
encuentran en C.
L.retainAll(C) Donde L es una lista y C es una colección. La función retainAll elimina los datos de L que no se
encuentran en C.
L.clear() Donde L es una lista. La función clear elimina todos los datos de L.

6.6.3 REEMPLAZO DE DATOS EN LA LISTA

import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
58 José Gonzalo Espejo Cuba
GUIA DE JAVA

public class List_reemplazo_datos {

public static void mostrar_Lista(List<Integer> X){
ListIterator <Integer> iterador = X.listIterator();
while(iterador.hasNext())
System.out.print(iterador.next()+" ");
System.out.println();
}
public static void main(String args[]){
List<Integer>L=new LinkedList<Integer>();
L.add(3);
L.add(28);
L.add(17);
L.add(31);
L.add(25);
mostrar_Lista(L);//Muestra: 3 28 17 31 25

System.out.println("FUNCION SET");
L.set(2, 54);//Reemplazando el dato de la posicion 2
mostrar_Lista(L);//Muestra: 3 28 54 31 25
}
}
set(k, nuevo_dato) Donde k es un entero no negativo. La función set reemplaza el dato que se encuentra en la
k-esima posición por un nuevo dato.

6.6.4 CAPACIDAD Y TAMAÑO DE LA LISTA

import java.util.LinkedList;
import java.util.List;
public class List_capacity {
public static void main(String args[]){
List<Integer>L=new LinkedList<Integer>();
L.add(3);
L.add(28);
L.add(17);
L.add(31);
L.add(25);
System.out.println("Longitud de la lista: "+L.size());//5

L.clear();//Eliminando todos los datos de la lista

if(L.isEmpty())//La lista esta vacia?
System.out.println("Si, la lista esta vacia");
}
}
size() Devuelve un entero que representa la longitud de la lista, es decir el número de elementos que contiene.
clear() La función clear() elimina todos los datos de V.
isEmpty() Devuelve true (verdadero) si la lista este vacia, es decir no contiene ningún elemento. Caso contrario
devuelve false (falso).

6.6.5 ELEMENTOS DE LA LISTA

import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class List_elements {
public static void main(String args[]){
List<Integer>L=new LinkedList<Integer>();
L.add(3);
 José Gonzalo Espejo Cuba 59
GUIA DE JAVA

L.add(28);
L.add(17);
L.add(31);
L.add(25);

System.out.println("get");
for(int i=0;i<L.size();i++)
System.out.print(L.get(i)+" ");//Muestra: 3 28 17 31 25
System.out.println();

//Iteradores de lista
ListIterator listIterator1 = L.listIterator();
while(listIterator1.hasNext())
System.out.print(listIterator1.next()+" ");
System.out.println();

ListIterator listIterator2 = L.listIterator(2);//A partir de la posicion 2

while(listIterator2.hasNext())
System.out.print(listIterator2.next()+" ");
System.out.println();
}
}
get(i) Donde i es un entero no negativo. La función get devuele el dato que se enceuntra en la i-esima
posición.
listIterator() Funciona como un puntero como en c, Se obtiene los datos mediante iteradores desde la primera
posición.
listIterator(i) Donde i es un entero no negativo. Se obtiene los datos mediante iteradores desde la i-esima
posición.
hasnext() Devuelve true (verdadero) si el iterador esta apuntando a un elemento del contenedor. Caso
contrario devuelve false (falso).
next() Apunta al siguiente elemento del contenedor.

6.6.6 BUSQUEDA Y COMPARACION DE SECUENCIA DE DATOS

import java.util.LinkedList;
import java.util.List;
public class List_search_comparison {
public static void main(String args[]){
List<Integer>L1=new LinkedList<Integer>();
List<Integer>L2=new LinkedList<Integer>();
List<Integer>L3=new LinkedList<Integer>();
L1.add(3);L1.add(28);L1.add(17);L1.add(31);L1.add(25);
L2.add(3);L2.add(28);L2.add(17);L2.add(31);L2.add(25);
L3.add(28);L3.add(17);L3.add(31);
//COMPARACION DE L1 CON L2
if(L1.equals(L2))//V1 y V2 son iguales?
System.out.println("Las listas L1 y L2 son iguales");
else
System.out.println("Las listas L1 y L2 son diferentes");
//Muestra: Las listas L1 y L2 son iguales

//BUSQUEDA DE ELEMENTOS
if(L1.contains(17))//L1 contiene el numero 17?
System.out.println("17 esta en la lista L1");
else
System.out.println("17 no se encuentra en la lista L1");
//Muestra: 17 esta en la lista L1
60 José Gonzalo Espejo Cuba
GUIA DE JAVA

if(L1.containsAll(L3))//L1 contiene a L3
System.out.println("L1 contiene a L3");
else
System.out.println("L3 no se encuentra en L1");
//Muestra: L1 contiene a L3
}
}
L1.equals(L2) Donde L1 y L2 son listas. La función equals devuelve true (verdadero) si L1 y L2 son iguales, es
decir que contienen los mismos elementos. Caso contrario devuelve false (falso).
L.contains(dato) Donde L es una lista. La función contains devuelve true (verdadero) si el dato esta en L. Caso
contrario devuelve false (falso).
isEmpty() Devuelve true (verdadero) si la lista este vacio, es decir no contiene ningún elemento. Caso
contrario devuelve false (falso).

6.7 CONJUNTOS
6.7.1 INSERCCION DE DATOS

import java.util.Iterator;
import java.util.Set;
import java.util.HashSet;
public class Conjuntos_inserccion_datos {
public static void mostrar_conjunto(Set<Integer> C){
for(Iterator<Integer> it=C.iterator();it.hasNext();)
System.out.print(it.next()+" ");
System.out.println();
}
public static void main(String args[]){
//CREACION DE CONJUNTOS
Set<Integer>conjA=new HashSet<Integer>();
Set<Integer>conjB=new HashSet<Integer>();
//INSERCCION DE DATOS
System.out.println("FUNCION ADD");
//Introduciendo datos al conjunto A
conjA.add(25);
conjA.add(11);
conjA.add(25);
conjA.add(16);
conjA.add(11);
conjA.add(2);
conjA.add(7);
conjA.add(25);
conjA.add(19);
conjA.add(14);
System.out.print("ConjA: ");
mostrar_conjunto(conjA);//Muestra: 16 19 2 7 25 11 14
System.out.println("FUNCION ADDALL");
conjB.addAll(conjA);//Introduciendo los datos del conjunto A al conjunto B
System.out.print("ConjB: ");
mostrar_conjunto(conjB);//Muestra: 16 2 19 7 25 11 14
}
}
add(dato) Inserta el dato en un conjunto, los conjuntos no permiten datos repetidos. A diferencia de
<set> de C++, los conjuntos en JAVA no tienen algún orden.
addAll(C) Inserta el contenido de la collecion C en un conjunto.
 José Gonzalo Espejo Cuba 61
GUIA DE JAVA

6.7.2 ELIMINACION DE DATOS

import java.util.Iterator;
import java.util.Set;
import java.util.HashSet;
public class Conjuntos_eliminacion_datos {
public static void mostrar_conjunto(Set<Integer> C){
for(Iterator<Integer> it=C.iterator();it.hasNext();)
System.out.print(it.next()+" ");
System.out.println();
}
public static void main(String args[]){
//CREACION DE CONJUNTOS
Set<Integer>conjA=new HashSet<Integer>();
Set<Integer>conjB=new HashSet<Integer>();
Set<Integer>conjC=new HashSet<Integer>();
//Introduciendo datos al conjunto A
conjA.add(25);conjA.add(11);conjA.add(25);conjA.add(16);conjA.add(11);
conjA.add(2);conjA.add(7);conjA.add(25);conjA.add(19);conjA.add(14);
//Introduciendo datos al conjunto B
conjB.add(25);conjB.add(16);conjB.add(7);conjB.add(10);
//Introduciendo datos al conjunto C
conjC.add(11);conjC.add(2);conjC.add(86);
System.out.print("ConjA: ");
mostrar_conjunto(conjA);//Muestra: 16 19 2 7 25 11 14
System.out.print("ConjB: ");
mostrar_conjunto(conjB);//Muestra: 16 7 25 10
System.out.print("ConjC: ");
mostrar_conjunto(conjC);//Muestra: 2 86 11

//ELIMINACION DE DATOS
System.out.println("\nFUNCION REMOVE");
conjA.remove(19);//Eliminando el dato 19
System.out.print("ConjA: ");
mostrar_conjunto(conjA);//Muestra: 16 2 7 25 11 14
conjA.remove(54);//Eliminando el dato 54
System.out.print("ConjA: ");
mostrar_conjunto(conjA);//Muestra: 16 2 7 25 11 14

System.out.println("\nFUNCION REMOVEALL");
conjA.removeAll(conjB);//Eliminando los datos que pertenecen a B
System.out.print("ConjA: ");
mostrar_conjunto(conjA);//Muestra: 2 11 14

System.out.println("\nFUNCION REMOVEALL");
conjA.retainAll(conjC);//Eliminando los datos que no pertenecen a C
System.out.print("ConjA: ");
mostrar_conjunto(conjA);//Muestra: 2 11

System.out.println("\nFUNCION CLEAR");
conjA.clear();//Eliminando todos los datos de conjA
System.out.print("ConjA: ");
mostrar_conjunto(conjA);//Muestra:
}
}
A.remove(dato) Donde A es un conjunto, la función remove elimina el dato si es que se encuentra en A.
A.removeAll(C) Donde A es un conjunto y C es una colección. La función removeAll elimina los datos de A que se
encuentran en C.
A.retainAll(C) Donde A es un conjunto y C es una colección. La función retainAll elimina los datos de A que no
se encuentran en C.
A.clear() Donde A es un conjunto. La función clear elimina todos los datos de A.
62 José Gonzalo Espejo Cuba
GUIA DE JAVA

6.7.3 CAPACIDAD Y TAMAÑO DEL CONJUNTO

import java.util.Iterator;
import java.util.Set;
import java.util.HashSet;
public class capacidad_conjuntos {
public static void mostrar_conjunto(Set<Integer> C){
for(Iterator<Integer> it=C.iterator();it.hasNext();)
System.out.print(it.next()+" ");
System.out.println();
}
public static void main(String args[]){
//CREACION DE CONJUNTOS
Set<Integer>conjA=new HashSet<Integer>();
//Introduciendo datos al conjunto A
conjA.add(25);conjA.add(11);conjA.add(25);conjA.add(16);conjA.add(11);
conjA.add(2);conjA.add(7);conjA.add(25);conjA.add(19);conjA.add(14);
System.out.print("ConjA: ");
mostrar_conjunto(conjA);//Muestra: 16 19 2 7 25 11 14

System.out.println("Nro de elementos del Conjunto: "+conjA.size());//7

conjA.clear();//Eliminando todos los datos

if(conjA.isEmpty())//El conjunto A, esta vacio?

System.out.println("Si, el conjunto esta vacio");
}
}
size() Devuelve un entero que representa la longitud del conjunto, es decir el número de elementos que contiene.
isEmpty() Devuelve true (verdadero) si el conjunto esta vacio, es decir no contiene ningún elemento. Caso contrario
devuelve false (falso).

6.7.4 BUSQUEDA Y COMPARACION DE SECUENCIA DE DATOS

import java.util.HashSet;
import java.util.Set;
public class busqueda_comparacion_en_conjunto {
public static void main(String args[]){
Set<Integer>conjA=new HashSet<Integer>();
Set<Integer>conjB=new HashSet<Integer>();
Set<Integer>conjC=new HashSet<Integer>();

//Introduciendo datos al conjunto A

conjA.add(25);conjA.add(11);conjA.add(25);conjA.add(16);conjA.add(11);
conjA.add(2);conjA.add(7);conjA.add(25);conjA.add(19);conjA.add(14);
//Introduciendo datos al conjunto B
conjB.addAll(conjA);
//Introduciendo datos al conjunto C
conjC.add(11);conjC.add(2);conjC.add(19);

//COMPARACION DE CONJUNTOS A Y B
if(conjA.equals(conjB))//Los conjuntos A y B son iguales?
System.out.println("Los conjuntos A y B son iguales");
else
System.out.println("Los conjuntos A y B son diferentes");
//Muestra: Los conjuntos A y B son iguales

if(conjA.contains(25))//El conjunto A contiene al dato 25?

System.out.println("25 esta en el conjunto A");
else
System.out.println("25 no se encuentra en el conjunto A");
//Muestra: 25 esta en el conjunto A
 José Gonzalo Espejo Cuba 63
GUIA DE JAVA

if(conjA.contains(conjC))//A contiene a C?
System.out.println("A contiene a C");
else
System.out.println("C no se encuentra en A");
//Muestra: C no se encuentra en A
}
}
C1.equals(C2) Donde C1 y C2 son conjuntos. La función equals devuelve true (verdadero) si C1 y C2 son iguales,
es decir que contienen los mismos elementos. Caso contrario devuelve false (falso).
C.contains(dato) Donde C es un conjunto. La función contains devuelve true (verdadero) si el dato esta en C. Caso
contrario devuelve false (falso).
A.contains(X) Donde A es un conjunto y X es una colección. La función contains devuelve true (verdadero) si los
datos de X estan en C. Caso contrario devuelve false (falso).

6.8 MAPAS
6.8.1 INSERCCION DE DATOS

import java.util.Iterator;
import java.util.Map;
import java.util.HashMap;
public class inserccion_datos {
public static void mostrar_mapa(Map<Character,String> X){
Iterator<String>contenido=X.values().iterator();
for(Iterator<Character> llave=X.keySet().iterator();llave.hasNext();)
System.out.println(llave.next()+" "+contenido.next());
}
public static void main(String args[]){
//CREACION DE MAPAS
Map<Character,String> M1=new HashMap<Character,String>();
Map<Character,String> M2=new HashMap<Character,String>();
//INSERCCION DE DATOS
System.out.println("Funcion put");
M1.put('b', "primero");
M1.put('c', "segundo");
M1.put('a', "tercero");
M1.put('A', "cuarto");
M1.put('e', "quinto");
M1.put('a', "sexto");
M1.put('d', "septimo");
System.out.println("M1: ");
mostrar_mapa(M1);
/*Muestra:
d septimo
e quinto
b primero
A cuarto
c segundo
a sexto
* */
System.out.println("\nFuncion putAll");
M2.putAll(M1);
System.out.println("M2: ");
mostrar_mapa(M2);
/*Muestra:
d septimo
e quinto
b primero
c segundo
64 José Gonzalo Espejo Cuba
GUIA DE JAVA

A cuarto
a sexto
* */
}
}
put(dato1,dato2) Introduce un par de datos, el dato1 sera la llave la cual será la única, es decir que el
contenedor no almacenara datos repetidos en el primer parámetro.
putAll(C) Inserta el contenido de la collecion C en el mapa.
keySet().iterator() Devuelve un iterador que apunta a las llaves.
values().iterator() Devuelve un iterador que apunta al contenido de los mapas.

6.8.2 ELIMINACION DE DATOS

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class eliminacion_datos {
public static void mostrar_mapa(Map<Character,String> X){
Iterator<String>contenido=X.values().iterator();
for(Iterator<Character> llave=X.keySet().iterator();llave.hasNext();)
System.out.println(llave.next()+" "+contenido.next());
}
public static void main(String args[]){
//CREACION DE MAPAS
Map<Character,String> A=new HashMap<Character,String>();
//Introduciendo datos aL mapa A
A.put('b', "primero");
A.put('c', "segundo");
A.put('a', "tercero");
A.put('A', "cuarto");
A.put('e', "quinto");
A.put('d', "septimo");

System.out.println("\nFUNCION REMOVE");
A.remove('h');
System.out.println("Eliminando el elemento de llave h");
mostrar_mapa(A);
/*Muestra:
d septimo
e quinto
b primero
A cuarto
c segundo
a sexto
* */
System.out.println("Eliminando el elemento de llave b");
A.remove('b');
mostrar_mapa(A);
/*Muestra:
d septimo
e quinto
A cuarto
c segundo
a sexto
* */
System.out.println("\nFUNCION CLEAR");
A.clear();
System.out.println("Eliminando todos los elementos");
mostrar_mapa(A);
 José Gonzalo Espejo Cuba 65
GUIA DE JAVA

/*Muestra:
* */
}
}
remove(dato) Elimina el dato si es que se encuentra en el mapa.
clear() Elimina todos los datos del mapa.

6.8.3 CAPACIDAD Y TAMAÑO DEL MAPA

import java.util.HashMap;
import java.util.Map;
public class longitud_mapa {
public static void main(String args[]){
//CREACION DE MAPAS
Map<Character,String> A=new HashMap<Character,String>();
//Introduciendo datos aL mapa A
A.put('b', "primero");
A.put('c', "segundo");
A.put('a', "tercero");
A.put('a', "cuarto");
A.put('e', "quinto");
A.put('d', "septimo");

System.out.println("Nro de elementos del Mapa: "+A.size());//5

A.clear();//Eliminando todos los datos

if(A.isEmpty())//El mapa A, esta vacio?

System.out.println("Si, el conjunto esta vacio");
}
}
size() Devuelve un entero que representa la longitud del mapa, es decir el número de elementos que contiene.
isEmpty() Devuelve true (verdadero) si el mapa este vacio, es decir no contiene ningún elemento. Caso contrario
devuelve false (falso).

6.8.4 BUSQUEDA DE DATOS

import java.util.HashMap;
import java.util.Map;
public class datos_del_mapa {
public static void main(String args[]){
//CREACION DE MAPAS
Map<Character,String> A=new HashMap<Character,String>();
//Introduciendo datos aL mapa A
A.put('b', "primero");
A.put('c', "segundo");
A.put('a', "tercero");
A.put('a', "cuarto");
A.put('e', "quinto");
A.put('d', "septimo");

System.out.println("FUNCION GET");
System.out.println(A.get('b'));//primero
System.out.println(A.get('a'));//cuarto

System.out.println("\nFUNCION CONTAINSKEY");
if(A.containsKey('a'))//El mapa contiene la llave 'a'?
System.out.println("Si, el mapa contiene la llave 'a'");
66 José Gonzalo Espejo Cuba
GUIA DE JAVA

else
System.out.println("No, la llave 'a' no se encuentra en el mapa");
//Muestra: Si, el mapa contiene la llave 'a'
if(A.containsKey('t'))//El mapa contiene la llave 't'?
System.out.println("Si, el mapa contiene la llave 't'");
else
System.out.println("No, la llave 't' no se encuentra en el mapa");
//Muestra: No, la llave 't' no se encuentra en el mapa

System.out.println("\nFUNCION CONTAINSVALUE");
if(A.containsValue("segundo"))//El mapa contiene el elemento "segundo"?
System.out.println("Si, el mapa contiene el elemento \"segundo\"");
else
System.out.println("No, el contenido \"segundo\" no se encuentra en el mapa");
//Muestra: Si, el mapa contiene el contenido "segundo"
if(A.containsValue('t'))//El mapa contiene el elemento 't'?
System.out.println("Si, el mapa contiene el elemento 't'");
else
System.out.println("No, el contenido 't' no se encuentra en el mapa");
//Muestra: No, el contenido 't' no se encuentra en el mapa
}
}
get(llave) Devuelve el contenido del mapa que esta señalado por una llave.
containsKey(llave) Devuelve true (verdadero) si el mapa contiene la llave. En caso contrario devuelve false
(falso).
containsValue(dato) Devuelve true (verdadero) si el mapa contiene el dato en algún contenido de las llaves. En
caso contrario devuelve false (falso).
 José Gonzalo Espejo Cuba 67
GUIA DE JAVA

7 ALGORITMOS DE JAVA

7.1 ALGORITMO ADDALL

import java.util.Collections;//Librería para utilizar los algoritmos en las colecciones

import java.util.Vector;//Librería para usar la collecion Vector
public class Algoritmo_addall {
public static void mostrar(Vector<String> v){
for(int i=0;i<v.size();i++)
System.out.print(v.get(i)+" ");
System.out.println();
}
public static void main(String[] args) {
Vector<String> v=new Vector<String>();

Collections.addAll(v, "este","es", "un","ejemplo");

mostrar(v);//Muestra: este es un ejemplo

String h[]={"este", "es", "el", "segundo"};

Collections.addAll(v, h);
mostrar(v);//Muestra: este es un ejemplo este es el segundo
}
}
Collections.addAll(A,x[]) Donde A es una estructura de la colección de JAVA y x[] es una secuencia de datos
o un array[]. La función addAll introduce los datos de la secuencia x[], en la
colección A.

7.2 ALGORITMO DE BUSQUEDA BINARIA (BINARY SEARCH)

7.2.1 BYNARY SEARCH DE LA CLASE ARRAY

import java.util.Arrays;//Librería para usar los algoritmos en arrays

public class Binary_search_arrays {
public static void mostrar(int x[]){
for(int i=0;i<x.length;i++)
System.out.print(x[i]+" ");
System.out.println();
}
public static void main(String[] args) {
int vec[]={18, 12, 20, 6, 9, 3, 11, 26, 2};
int pos;//Con esta variable obtendremos las posiciones
Arrays.sort(vec);//Ordenamos el vector primero antes de la busqueda
mostrar(vec);//Muestra: 2 3 6 9 11 12 18 20 26

pos=Arrays.binarySearch(vec,9);//Buscando el dato 9
System.out.println("El dato 9 se encuentra en la posicion: "+pos);// 3
pos=Arrays.binarySearch(vec,0,3,9);//Buscando el dato 9 en el rango [0,3)
System.out.println("El dato 9 se encuentra en la posicion: "+pos);// -4
pos=Arrays.binarySearch(vec,20);//Buscando el dato 20
System.out.println("El dato 9 se encuentra en la posicion: "+pos);// 7
pos=Arrays.binarySearch(vec,17);//Buscando el dato 17
System.out.println("El dato 9 se encuentra en la posicion: "+pos);// -7
}
}
Arrays.binarySearch(A[],dato) Donde A[] es un array. La función binarySearch busca el dato y
devuelve un entero que representa la posición en la que esta el
dato. Si el dato buscado no se encuentra en el array, entonces
dicha función devuelve un número entero negativo. El array debe
ser ordenado antes de usar la búsqueda binaria.
68 José Gonzalo Espejo Cuba
GUIA DE JAVA

Arrays.binarySearch(A[],dato,ini,fin) Donde A[] es un array, ini y fin son enteros no negativos (ini<fin).
La función binarySearch busca el dato en el rango [ini, fin) y
devuelve un entero que representa la posición en la que esta el
dato. Si el dato buscado no se encuentra en el array, entonces
dicha función devuelve un número entero negativo. El array debe
ser ordenado antes de usar la búsqueda binaria.

7.2.2 BYNARY SEARCH DE LA CLASE COLLECTIONS

import java.util.Collections;//Librería para usar los algoritmos en colecciones

import java.util.Vector; //Librería para usar los vectores
public class Binary_search_collections {
public static void mostrar(Vector<Integer> v) {
for(int i=0;i<v.size();i++)
System.out.print(v.get(i)+" ");
System.out.println();
}
public static void main(String[] args) {
Vector<Integer> vec=new Vector<Integer>();
vec.add(18); vec.add(12); vec.add(20); vec.add(6); vec.add(9);
vec.add(3); vec.add(11); vec.add(26); vec.add(2);
int pos;//Con esta variable obtendremos las posiciones
Collections.sort(vec);//Ordenamos el vector primero antes de la busqueda
mostrar(vec);//Muestra: 2 3 6 9 11 12 18 20 26

pos=Collections.binarySearch(vec, 9);//Buscando el dato 9

System.out.println("El dato 9 se encuentra en la posicion: "+pos);// 3
pos=Collections.binarySearch(vec, 20);//Buscando el dato 20
System.out.println("El dato 9 se encuentra en la posicion: "+pos);// 7
pos=Collections.binarySearch(vec, 17);//Buscando el dato 17
System.out.println("El dato 9 se encuentra en la posicion: "+pos);// -7
}
}
Collections.binarySearch(A,dato) Donde A es una colección. La función binarySearch busca el dato y
devuelve un entero que representa la posición en la que esta el dato. Si el
dato buscado no se encuentra en la colección, entonces dicha función
devuelve un número entero negativo. A debe ser ordenado antes de usar
la búsqueda binaria.

7.3 ALGORITMOS DE COPIA

7.3.1 ALGORITMOS COPY EN LA CLASE COLLECTIONS

import java.util.Collections;
import java.util.Vector;
public class Copy_collections {
public static void mostrar(Vector<Integer> v) {
for(int i=0;i<v.size();i++)
System.out.print(v.get(i)+" ");
System.out.println();
}
public static void main(String[] args) {
Vector<Integer> vec1=new Vector<Integer>();
vec1.add(18); vec1.add(12); vec1.add(20); vec1.add(6); vec1.add(9);
vec1.add(3); vec1.add(11); vec1.add(26); vec1.add(2);

Vector<Integer> vec2=new Vector<Integer>();

vec2.setSize(vec1.size());//Ajustamos el tamaño de vec2
Collections.copy(vec2, vec1);
mostrar(vec2);//Muestra: 18 12 20 6 9 3 11 26 2
 José Gonzalo Espejo Cuba 69
GUIA DE JAVA

}
}
Collections.copy(A,B) Donde A y B son colecciónes. La función copy copia el contenido de B en A.
Previamente el tamaño de A debe ser ajustado al tamaño de B.

7.3.2 ALGORITMOS COPY EN LA CLASE ARRAYS

import java.util.Arrays;
public class Copy_arrays {
public static void mostrar(int x[]){
for(int i=0;i<x.length;i++)
System.out.print(x[i]+" ");
System.out.println();
}
public static void main(String[] args) {
int vec[]={18, 12, 20, 6, 9, 3, 11, 26, 2};
int copia1[],copia2[],copia3[],copia4[];

System.out.println("FUNCION COPYOF");
copia1=Arrays.copyOf(vec, 3);//Copiando los 3 primeros elementos de vec en copia1
mostrar(copia1);//Muestra: 18 12 20
copia2=Arrays.copyOf(vec, 7);//Copiando los 7 primeros elementos de vec en copia2
mostrar(copia2);//Muestra: 18 12 20 6 9 3 11

System.out.println("FUNCION COPYOFRANGE");
copia3=Arrays.copyOfRange(vec, 2, 7);//Copiando desde la posicion 2 hasta la 7
mostrar(copia3);//Muestra: 20 6 9 3 11
copia4=Arrays.copyOfRange(vec, 3, 5);//Copiando desde la posicion 2 hasta la 7
mostrar(copia4);//Muestra: 6 9
}
}
Arrays.copyOf(A[],n) Donde A[] es un array y n es un entero no negativo, la función copyOf copia
los n primeros elementos de A, y devuelve un nuevo array[] con dichos
elementos.
Arrays.copyOfRange(A[],ini,fin) Donde A[] es un array, ini y fin son enteros no negativos, la función
copyOfRange copia los elementos de A desde la posición ini hasta la
posición fin, y devuelve un nuevo array[] con dichos elementos.

7.4 ALGORITMO DISJOINT

import java.util.Collections;
import java.util.Vector;
public class Disjoint_Collections {
public static void main(String[] args) {
Vector<Integer> vec1,vec2,vec3;
vec1=new Vector<Integer>();
vec2=new Vector<Integer>();
vec3=new Vector<Integer>();
vec1.add(11);vec1.add(18);vec1.add(53);
vec2.add(12);vec2.add(20);vec2.add(13);
vec3.add(11);vec3.add(24);vec3.add(13);
if(Collections.disjoint(vec1, vec2))
System.out.println("vec1 y vec2 son disjuntos");
else
System.out.println("vec1 y vec2 tienen algun elemento en comun");
//Muestra: vec1 y vec2 son disjuntos
70 José Gonzalo Espejo Cuba
GUIA DE JAVA

if(Collections.disjoint(vec1, vec3))
System.out.println("vec1 y vec3 son disjuntos");
else
System.out.println("vec1 y vec3 tienen algun elemento en comun");
//Muestra: vec1 y vec3 tienen algun elemento en comun
}
}
Collections.disjoint(A, B) Donde A y B son colecciones. La función disjoint devuelve true (verdadero) si las
colecciones son disjuntas, es decir no tienen ningún elemento en común. Si existe
algún elemento que tengan A y B entonces disjoint devulve false (falso).

7.5 ALGORITMO DE COMPARACION EQUALS PARA ARRAYS

import java.util.Arrays;
public class Equals_arrays {
public static void main(String[] args) {
int a[]={25,11,19,86,7,2,10};
int b[]={25,11,19,86,7,2,10};
int c[]={25,11,86,19,7,2,10};

if(Arrays.equals(a, b))
System.out.println("Los vectores a y b son iguales");
else
System.out.println("Los vectores a y b son diferentes");
//Muestra: Los vectores a y b son iguales

if(Arrays.equals(a, c))
System.out.println("Los vectores a y c son iguales");
else
System.out.println("Los vectores a y c son diferentes");
//Muestra: Los vectores a y c son diferentes
}
}
Arrays.equals(A[], B[]) Donde A[] y B[] son arrays, la función equals, devuelve true (verdadero) si los arrays A
y B tienen los mismos elementos y en el mismo orden. Caso contrario devuelve false
(falso).

7.6 ALGORITMOS FILL

7.6.1 ALGORITMO FILL PARA LA CLASE COLLECTIONS

import java.util.Collections;
import java.util.Vector;
public class Fill_collections {
public static void mostrar(Vector<Integer> v) {
for(int i=0;i<v.size();i++)
System.out.print(v.get(i)+" ");
System.out.println();
}
public static void main(String[] args) {
Vector<Integer> V=new Vector<Integer>();
V.setSize(10);//Ajustando el tamaño del vector a 10
mostrar(V);//Muestra: null null null null null null null null null null
Collections.fill(V, 24);//Llenando el vector con el numero 24
mostrar(V);//Muestra: 24 24 24 24 24 24 24 24 24 24
}
}
Collections.fill(V,dato) Donde V es una colección. La función fill llena los espacios de la colección con un dato.
 José Gonzalo Espejo Cuba 71
GUIA DE JAVA

7.6.2 ALGORITMO FILL PARA LA CLASE ARRAYS

import java.util.Arrays;
public class Fill_arrays {
public static void mostrar(int x[]){
for(int i=0;i<x.length;i++)
System.out.print(x[i]+" ");
System.out.println();
}
public static void main(String[] args) {
int V[]=new int[10];
Arrays.fill(V, 24);//Llenando el vector con el numero 24
mostrar(V);//Muestra: 24 24 24 24 24 24 24 24 24 24
}
}
Arrays.fill(V[], dato) Donde V[] es un array. La función fill llena los espacios del array con un dato.

7.7 ALGORITMO FREQUENCY

import java.util.Collections;
import java.util.Vector;
public class JavaApplication17 {
public static void main(String[] args) {
Vector<Character> v=new Vector<Character>();
v.add('r');v.add('w');v.add('r');v.add('a');v.add('c');v.add('r');
int n=Collections.frequency(v, 'r');
System.out.println("Numero de datos iguales a 'r': "+n);// 3
}
}
Collections.frequency(A, dato) Donde A es una colección. La función frequency devuelve un entero que
representa el número de veces en la que el dato aparece en la colección.

7.8 ALGORITMOS MAX Y MIN

import java.util.Collections;
import java.util.Vector;
public class Max_min_Collections {
public static void main(String[] args) {
Vector<Integer>V=new Vector<Integer>();
V.add(18); V.add(12); V.add(20); V.add(6); V.add(9); V.add(3); V.add(11);
System.out.println("El mayor de los elementos es "+Collections.max(V));// 20
System.out.println("El minimo de los elementos es "+Collections.min(V));// 3
}
}
Collections.max(A) Donde A es una colección. La función max busca y devuelve el mayor (lexicograficamente) de
los datos de A.
Collections.min(A) Donde A es una colección. La función min busca y devuelve el menor (lexicograficamente) de
los datos de A.

7.9 ALGORITMOS REPLACEALL

import java.util.Collections;
import java.util.Vector;
public class Replace_Collectios {
public static void mostrar_Vector(Vector <Integer> V){
72 José Gonzalo Espejo Cuba
GUIA DE JAVA

for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i) +" ");
System.out.println();
}
public static void main(String[] args) {
Vector<Integer>v=new Vector<Integer>();
v.add(11); v.add(17); v.add(4); v.add(12); v.add(4); v.add(11); v.add(20);
mostrar_Vector(v);//Muestra: 11 17 4 12 4 11 20
Collections.replaceAll(v, 4, 32);//Reemplazando el dato 4 por el dato 32
mostrar_Vector(v);//Muestra: 11 17 32 12 32 11 20
Collections.replaceAll(v, 12, 24);//Reemplazando el dato 12 por el dato 24
mostrar_Vector(v);//Muestra: 11 17 32 24 32 11 20
}
}
Collections. replaceAll(A, anterior, nuevo) Donde A es una colección, anterior y nuevo son datos. La
función replaceAll busca el dato anterior en A y reemplaza
los datos por los nuevos.

7.10 ALGORITMO REVERSE

import java.util.Collections;
import java.util.Vector;
public class Reverse_Collections {
public static void mostrar_Vector(Vector <Integer> V){
for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i) +" ");
System.out.println();
}
public static void main(String[] args) {
Vector<Integer>v=new Vector<Integer>();
v.add(11); v.add(17); v.add(4); v.add(12); v.add(14); v.add(30); v.add(20);
mostrar_Vector(v);//Muestra: 11 17 4 12 14 30 20
Collections.reverse(v);
mostrar_Vector(v);//Muestra: 20 30 14 12 4 17 11
}
}
Collections. reverse(A) Donde A es una colección. La función reverse invierte el orden de los datos en A.

7.11 ALGORITMO ROTATE

import java.util.Collections;
import java.util.Vector;
public class Rotate_collections {
public static void mostrar_Vector(Vector <Integer> V){
for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i) +" ");
System.out.println();
}
public static void main(String[] args) {
Vector<Integer>v=new Vector<Integer>();
v.add(11); v.add(17); v.add(4); v.add(12); v.add(14); v.add(30); v.add(20);
mostrar_Vector(v);//Muestra: 11 17 4 12 14 30 20
Collections.rotate(v, -2); //Rotando dos posiciones a la izquierda
mostrar_Vector(v);//Muestra: 4 12 14 30 20 11 17
Collections.rotate(v, 3); //Rotando tres posiciones a la derecha
mostrar_Vector(v);//Muestra: 20 11 17 4 12 14 30
}
}
 José Gonzalo Espejo Cuba 73
GUIA DE JAVA

Collections.rotate(A,k) Donde A es una colección y k es un entero. La función rotate rota los elementos, si k es
negativo rota los elementos k posiciones a la izquierda, si k es positivo rota los
elementos k posiciones a la derecha.

7.12 ALGORITMOS DE ORDENAMIENTO

7.12.1 ALGORITMO SORT DE LA CLASE COLECTIONS

import java.util.Collections;
import java.util.Vector;
public class Java_Collections_sort {
public static void mostrar_Vector(Vector <Integer> V){
for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i) +" ");
System.out.println();
}
public static void main(String[] args) {
Vector<Integer>V=new Vector<Integer>();
V.add(12); V.add(3); V.add(34); V.add(24);
mostrar_Vector(V);//Muestra: 12 3 34 24
Collections.sort(V);//Orden ascendente
mostrar_Vector(V);//Muestra: 3 12 24 34
Collections.sort(V, Collections.reverseOrder());//Orden descendete
mostrar_Vector(V);//34 24 12 3
}
}
Collections.sort(A) Donde A es una colección. La función sort ordena los elementos de A en forma
ascendente (orden lexicografico). Podemos añadir un parámetro para que los datos se
ordenen en orden descendente con Collections.reverseOrder().

7.12.2 ALGORITMO SORT DE LA CLASE ARRAY

import java.util.Arrays;
public class Algoritmosort_arrays {
public static void mostrar(int v[]){
for(int i=0;i<v.length;i++)
System.out.print(v[i]+" ");
System.out.println();
}
public static void main(String[] args) {
int vec1[]={27, 6, 46, 9,10};
int vec2[]={30, 11, 20, 13, 55, 18};
System.out.print("vec1: ");
mostrar(vec1);//Muestra: 27 6 46 9 10
System.out.print("vec2: ");
mostrar(vec2);//Muestra: 30 11 20 13 55 18

//Ordenando ascendentemente todos los elementos de vec1

Arrays.sort(vec1);
//Ordenando ascendentemente los elementos de vec2 desde la posicion 1 hasta la cinco
Arrays.sort(vec2, 1, 5);

System.out.print("vec1: ");
mostrar(vec1);//Muestra: 27 6 46 9 10
System.out.print("vec2: ");
mostrar(vec2);//Muestra: 30 11 20 13 55 18
}
}
Arrays.sort(A[]) Donde A[] es un array. La función sort ordena los datos de A en forma ascedente.
74 José Gonzalo Espejo Cuba
GUIA DE JAVA

Arrays.sort(A[],ini,fin) Donde A[] es un array, ini y fin son enteros no negativos (ini<fin). La función sort
ordena los datos de A en forma ascedente en el rango [ini, fin).

7.13 ALGORITMO SHUFFLE

import java.util.Collections;
import java.util.Vector;
public class Shuffle {
public static void mostrar(Vector<Integer> v){
for(int i=0;i<v.size();i++)
System.out.print(v.get(i)+" ");
System.out.println();
}
public static void main(String[] args) {
Vector <Integer> vec=new Vector<Integer>();
Collections.addAll(vec, 1,2,3,4,5,6,7,8,9,10);
mostrar(vec);//Muestra: 1 2 3 4 5 6 7 8 9 10
Collections.shuffle(vec);
mostrar(vec);//Muestra: 10 5 2 6 3 4 1 8 9 7
Collections.shuffle(vec);
mostrar(vec);//Muestra: 9 4 5 3 1 6 2 8 10 7
}
}
Collections.shuffle(A) Donde A es una colección. La función shuffle ordena los elementos de A aleatoriamente.

7.14 ALGORITMO SWAP

import java.util.Collections;
import java.util.Vector;
public class Swap_collections {
public static void mostrar_Vector(Vector <Integer> V){
for(int i=0;i<V.size();i++)
System.out.print(V.elementAt(i) +" ");
System.out.println();
}
public static void main(String[] args) {
Vector<Integer>v=new Vector<Integer>();
v.add(11); v.add(17); v.add(4); v.add(12); v.add(14); v.add(30); v.add(20);
mostrar_Vector(v);//Muestra: 11 17 4 12 14 30 20
//Intercambia el dato de la posicion 6 con el dato de la posicion 3
Collections.swap(v, 6, 3);
mostrar_Vector(v);//Muestra: 11 17 4 20 14 30 12
//Intercambia el dato de la posicion 2 con el dato de la posicion 5
Collections.swap(v, 2, 5);
mostrar_Vector(v);//Muestra: 11 17 30 20 14 4 12
}
}
Collections.swap(A,i,j) Donde A es una colección, i y j son enteros no negativos. La función swap intercambia
el dato que se encuentra en la posición i por el dato que se encuentra en la posición j.

7.15 ALGORITMO TOSTRING

import java.util.Arrays;
public class Tostring {
public static void main(String[] args) {
int x[]={25, 11, 14, 10, 16};
 José Gonzalo Espejo Cuba 75
GUIA DE JAVA

String cadena=Arrays.toString(x);
System.out.println(cadena);//Muestra: [25, 11, 14, 10, 16]
}
}
Arrays.toString(A[]) Donde A es una array. La función toString transforma un array en una cadena.

7.16 UTILIZANDO COMPARADORES EN SORT, BINARY SEARCH, MAX Y MIN

7.16.1 COMPARADORES CON COLLECTIONS

class tiempo{
int hora;
int minutos;
int segundos;
public tiempo(){}
public tiempo(int hh, int mm,int ss){
hora=hh;
minutos=mm;
segundos=ss;
}
public void mostrar_tiempo(){
System.out.printf("%02d:%02d:%02d\n",hora,minutos,segundos);
}
}
class comparador_tiempo implements Comparator<tiempo>{
public int compare(tiempo t1,tiempo t2){
int nt1=(t1.hora*3600)+(t1.minutos*60)+(t1.segundos);
int nt2=(t2.hora*3600)+(t2.minutos*60)+(t2.segundos);
return nt1-nt2;
}
}
public class Maneja_comparador_1 {
public static void mostrar(Vector<tiempo> v){
for(int i=0;i<v.size();i++)
v.get(i).mostrar_tiempo();
}
public static void main(String[] args) {
Vector<tiempo>vt=new Vector<tiempo>();
vt.add(new tiempo(13,11,11));
vt.add(new tiempo(7,19,14));
vt.add(new tiempo(1,12,20));
vt.add(new tiempo(13,11,10));
vt.add(new tiempo(11,50,20));
mostrar(vt);
/*MUESTRA:
13:11:11
07:19:14
01:12:20
13:11:10
11:50:20
*/

System.out.println("\nORDENAMIENTO SORT");
Collections.sort(vt, new comparador_tiempo());
mostrar(vt);
/*MUESTRA:
01:12:20
07:19:14
11:50:20
13:11:10
13:11:11
*/
76 José Gonzalo Espejo Cuba
GUIA DE JAVA

System.out.println("\nBUSQUEDA");
int b1=Collections.binarySearch(vt, new tiempo(13,11,10), new comparador_tiempo());
int b2=Collections.binarySearch(vt, new tiempo(12,0,0), new comparador_tiempo());
System.out.println("b1: "+b1);//3
System.out.println("b2: "+b2);//-4

System.out.println("\nMAX Y MIN");
tiempo may=Collections.max(vt, new comparador_tiempo());
tiempo men=Collections.min(vt, new comparador_tiempo());
System.out.println("Tiempo mayor:");
may.mostrar_tiempo();//Muestra: 13:11:11
System.out.println("Tiempo menor:");
men.mostrar_tiempo();//Muestra: 01:12:20
}
}

7.16.2 COMPARADORES CON ARRAYS

import java.util.Arrays;
import java.util.Comparator;
class tiempo{
int hora;
int minutos;
int segundos;
public tiempo(){}
public tiempo(int hh, int mm,int ss){
hora=hh;
minutos=mm;
segundos=ss;
}
public void mostrar_tiempo(){
System.out.printf("%02d:%02d:%02d\n",hora,minutos,segundos);
}
}
class comparador_tiempo implements Comparator<tiempo>{
public int compare(tiempo t1,tiempo t2){
int nt1=(t1.hora*3600)+(t1.minutos*60)+(t1.segundos);
int nt2=(t2.hora*3600)+(t2.minutos*60)+(t2.segundos);
return nt1-nt2;
}
}
public class Maneja_comparador_2 {
public static void mostrar(tiempo x[]){
for(int i=0;i<x.length;i++)
x[i].mostrar_tiempo();
}
public static void main(String[] args) {
tiempo vt[]=new tiempo[5];
vt[0]=new tiempo(13,11,11);
vt[1]=new tiempo(7,19,14);
vt[2]=new tiempo(1,12,20);
vt[3]=new tiempo(13,11,10);
vt[4]=new tiempo(11,50,20);
mostrar(vt);
/*MUESTRA:
13:11:11
07:19:14
01:12:20
13:11:10
11:50:20
*/
 José Gonzalo Espejo Cuba 77
GUIA DE JAVA

System.out.println("\nORDENAMIENTO SORT");
Arrays.sort(vt, new comparador_tiempo());
mostrar(vt);
/*MUESTRA:
01:12:20
07:19:14
11:50:20
13:11:10
13:11:11
*/

System.out.println("\nBUSQUEDA");
int b1=Arrays.binarySearch(vt, new tiempo(13,11,10), new comparador_tiempo());
int b2=Arrays.binarySearch(vt, new tiempo(12,0,0), new comparador_tiempo());
System.out.println("b1: "+b1);//3
System.out.println("b2: "+b2);//-4
}
}
78 José Gonzalo Espejo Cuba
GUIA DE JAVA

8 MISCELANEA

8.1 SECUENCIA FOR MEJORADA

El for mejorado se utiliza únicamente para recorrer arrays o Collections, además el for no funciona si se trata de modificar
los datos de una estructura.
8.1.1 FOR DE ARRAYS

int vec[]={12, 20, 5, 13, 6, 36};

int suma=0;
for(int numero:vec){
System.out.print(" + "+numero);
suma+=numero;
}

8.1.2 FOR DE COLLECTIONS

//Se puede utilizar cualquier cualquier colección excepto Mapas

Vector<Integer>A=new Vector<Integer>();
A.add(12); A.add(20);A.add(5); A.add(13);A.add(6); A.add(36);
int suma=0;
for(int numero:A){
System.out.print(" + "+numero);
suma+=numero;
}
System.out.println(" = "+suma);//Muestra: + 12 + 20 + 5 + 13 + 6 + 36 = 92

8.2 EXCEPCIONES
8.2.1 EXCEPCION EN LA LECTURA DE ENTEROS

import java.util.InputMismatchException;
import java.util.Scanner;
public class ExcepcionesDeEntrada {
public static void main(String[] args) {
Scanner leer=new Scanner(System.in);
int numero;
try{
numero=leer.nextInt();
System.out.println("El numero leido es: "+numero);
}
catch(InputMismatchException error){
System.out.println("Lectura incorrecta");
}
}
}

Este programa lee un dato entero, si el dato introducido no es un entero de tipo int, es decir introducimos una cadena o un
numero que sobrepase la capacidad del tipo int, la lectura será incorrecta. El bloque try analiza el proceso de la entrada y
al fallar es enviado a catch.

8.2.2 EXCEPCION EN DIVISION ENTRE CERO

import java.util.Scanner;
public class Division_entre_cero {
//Metodo que realiza la division de dos numeros
public static int cociente(int num,int den)throws ArithmeticException{
return num/den;
 José Gonzalo Espejo Cuba 79
GUIA DE JAVA

}
public static void main(String[] args) {
Scanner leer=new Scanner(System.in);
int numerador,denominador;
try{
numerador=leer.nextInt();
denominador=leer.nextInt();
System.out.println("El cociente es: "+cociente(numerador,denominador));
}
catch(ArithmeticException error){
System.out.println("Error!! division entre cero");
}
}
}

Este programa realiza la división entre un numerador y un denominador, el método cociente utiliza una palabra reservada
throws que indica que el método lanza una posible excepción, en este caso de tipo aritmético (ArithmeticException). Si
el error aritmético se cumple, esta excepción es atrapada por catch.

8.2.3 ESTRUCTURA GENERAL DE UN PROGRAMA CON EXCEPCION

//Metodo que lanza una posible excepción

public static void metodo(parametros)throws ArithmeticException{
//codigo
}
public static void main(String[] args) {
//CODIGO
try{//Inicio de try
//CODIGO
método(parametros);
//GODIGO
}//Fin de try
catch(Exception error){//Atrapa la excepcion
//CODIGO
}
}
}

8.3 MANEJO DEL TIEMPO EN JAVA

8.3.1 JAVA DATE

import java.util.Date;
public class Java_date {
static String
dia[]={"Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado"};
public static void main(String[] args) {
Date fecha1,fecha2,fecha3,fecha4;
fecha1=new Date();//Creamos el objeto Date con la fecha actual

System.out.println("FUNCIONES GET");
int ind=fecha1.getDay();//Obtiene un entero que representa el nombre del dia
int dd=fecha1.getDate();//Obtiene un entero que representa el dia
int mm=fecha1.getMonth();//Obtiene un entero que representa el mes
int yy=fecha1.getYear()+1900;//Obtiene un entero que representa el año
int hora=fecha1.getHours();//Obtiene un entero que representa la hora
int min=fecha1.getMinutes();//Obtiene un entero que representa los minutos
int sec=fecha1.getSeconds();//Obtiene un entero que representa los segundos
long total_milisec=fecha1.getTime();//Obtiene un entero que representa milisec

//MOSTRANDO LA FECHA ACTUAL

80 José Gonzalo Espejo Cuba
GUIA DE JAVA

//Mostrando el objeto fecha directamente

System.out.println("fecha1");
System.out.println(fecha1);//Muestra: Mon Dec 09 12:51:25 CLST 2013
//Imprimimos la fecha por nuestros metodos
System.out.printf("%S %02d/%02d/%d
%02d:%02d:%02d\n",dia[ind],dd,mm,yy,hora,min,sec);//Muestra: LUNES 09/11/2013 12:51:25
System.out.println("Tiempo en milisegundos: "+total_milisec);//Muestra: 1386604285769

System.out.println("\nCONSTRUCTOR CON PARAMETROS");

System.out.println("fecha2");
fecha2=new Date(100,9,10,23,45,3);//Creando otra fecha
System.out.println(fecha2);//Muestra: Tue Oct 10 23:45:03 CLT 2000

System.out.println("\nFUNCIONES SET");
fecha3=new Date();
fecha3.setHours(11);//Establece la hora
fecha3.setMinutes(18);//Establece los minutos
fecha3.setSeconds(43);//Establece los segundos
fecha3.setDate(25);//Establece la fecha
fecha3.setMonth(10);//Establece el mes
fecha3.setYear(2024-1900);//Establece el año
System.out.println(fecha3);//Muestra: Mon Nov 25 11:18:43 CLST 2024

System.out.println("\nFUNCIONES BEFORE Y AFTER");

if(fecha2.before(fecha1))//¿La fecha2 esta antes que fecha1?
System.out.println("La fecha 2 esta antes que fecha 1");
if(fecha3.after(fecha1))//¿La fecha3 esta despues que fecha1?
System.out.println("La fecha 3 esta despues que fecha 1");

fecha4=fecha1;//Asignacion de fechas

System.out.println("\nCOMPARACION DE FECHAS");
if(fecha1.equals(fecha4))
System.out.println("La fecha 1 es igual a la fecha 4");
System.out.println(fecha1.compareTo(fecha2));//Muestra: 1
System.out.println(fecha1.compareTo(fecha3));//Muestra: -1
System.out.println(fecha1.compareTo(fecha4));//Muestra: 0

System.out.println("\nTRANSFORMACION DE FECHAS A CADENAS");

String cad1=fecha1.toGMTString();
String cad2=fecha1.toLocaleString();
String cad3=fecha3.toString();
System.out.println(cad1);//Muestra: 9 Dec 2013 15:51:25 GMT
System.out.println(cad2);//Muestra: 09-12-2013 12:51:25 PM
System.out.println(cad3);//Muestra: Mon Nov 25 11:18:43 CLST 2024
}
}
getDay() Obtiene el dia de la semana (Domingo-Sabado) representado en un entero (0-6).
getDate() Obtiene el dia del mes representado en un entero positivo.
getMonth() Obtiene el mes representado en un entero positivo (0-11).
getYear() Obtiene el año – 1900.
getHours() Obtiene las horas de un dia representado en un entero positivo (0-23)
getMinutes() Obtiene los minutos de una hora representado en un entero positivo (0-59)
getSeconds() Obtiene los segundos de un minuto representado en un entero positivo (0-59)
getTime() Obtiene los milisegundos transcurridos desde el 1ro de Enero de 1970 00:00:00
setDate(dia) Establece el nuevo dia (entero positivo).
 José Gonzalo Espejo Cuba 81
GUIA DE JAVA

setMonth(mes) Establece el nuevo mes (entero positivo)

setYear(año) Establece el nuevo año (entero positivo)
setHours(hora) Establece la nueva hora (entero positivo)
setMinutes(minutos) Establece los nuevo minutos (entero positivo)
setSeconds(segundos) Obtiene los segundos de un minuto representado en un entero positivo (0-59)
A.before(B) Donde A y B son Dates. La función before devuelve true (verdadero) si A es una fecha antes
que B, caso contrario devuelve false (falso).
A.after(B) Donde A y B son Dates. La función after devuelve true (verdadero) si A es una fecha despues
que B, caso contrario devuelve false (falso).
A.equals(B) Donde A y B son Dates. La función equals devuelve true (verdadero) si A es una fecha igual
a B, caso contrario devuelve false (falso).
A.compareTo(B) Donde A y B son Dates. La función compareTo devuelve entero tal que:
0: si A es igual a B.
>0: si A es mayor a B.
<0: si A es menor a B.
toGMTString() Devuelve una cadena con el tiempo en formato GTM.
toLocaleString() Devuelve una cadena con el tiempo en formato Local (AM o PM).
toString() Devuelve una cadena con el tiempo en su formato normal.

8.3.2 JAVA CALENDAR

import java.util.Calendar;
import java.util.Date;
public class JavaCalendar {
static String
dia[]={"Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado"};
public static void display(Date D){
String dn=dia[D.getDay()];
int dd=D.getDate();
int mm=D.getMonth()+1;
int yy=D.getYear()+1900;
int hh=D.getHours();
int mi=D.getMinutes();
int ss=D.getSeconds();
System.out.printf("%s %02d/%02d/%d %02d:%02d:%02d\n",dn,dd,mm,yy,hh,mi,ss);
}
public static void main(String[] args) {
Calendar calendario=Calendar.getInstance();
display(calendario.getTime());//Muestra: Martes 10/12/2013 19:57:50

System.out.println("\nMETODO GET");
System.out.println("Hora: "+calendario.get(Calendar.HOUR_OF_DAY));//19
System.out.println("Minutos: "+calendario.get(Calendar.MINUTE));//57
System.out.println("Segundos: "+calendario.get(Calendar.SECOND));//50
System.out.println("Dia de la semana:
"+dia[calendario.get(Calendar.DAY_OF_WEEK)-1]);//Martes
System.out.println("Dia del mes: "+calendario.get(Calendar.DAY_OF_MONTH));//10
System.out.println("Semana del mes: "+calendario.get(Calendar.WEEK_OF_MONTH));//3
System.out.println("Semana del año: "+calendario.get(Calendar.WEEK_OF_YEAR));//50
System.out.println("Mes del año: "+(calendario.get(Calendar.MONTH)+1));//12
System.out.println("Año: "+(calendario.get(Calendar.YEAR)));//2013
System.out.println("Milisegundos: "+calendario.getTimeInMillis());//1386701870521
82 José Gonzalo Espejo Cuba
GUIA DE JAVA

System.out.println("\nMETODO ADD");
calendario.add(calendario.DATE, 5);//Avanza 5 dias
display(calendario.getTime());//Muestra: Domingo 15/12/2013 19:57:50
calendario.add(calendario.DATE, -20);//Retrocede 20 dias
display(calendario.getTime());//Muestra: Lunes 25/11/2013 19:57:50
calendario.add(calendario.MONTH, 4);//Avanza 4 meses
display(calendario.getTime());//Muestra: Martes 25/03/2014 19:57:50
calendario.add(calendario.YEAR, 1);//Avanza 1 año
display(calendario.getTime());//Muestra: Miercoles 25/03/2015 19:57:50
calendario.add(calendario.HOUR, -3);//Retrocede 3 horas
display(calendario.getTime());//Muestra: Miercoles 25/03/2015 16:57:50
calendario.add(calendario.MINUTE, -10);//Retrocede 10 minutos
display(calendario.getTime());//Muestra: Miercoles 25/03/2015 16:47:50
calendario.add(calendario.SECOND, 1000);//Avanza 1000 segundos
display(calendario.getTime());//Muestra: Miercoles 25/03/2015 17:04:30

System.out.println("\nMETODO SET");
calendario.set(Calendar.MONTH, 7);//Establece al mes 8 agosto
display(calendario.getTime());//Muestra: Martes 25/08/2015 17:04:30
calendario.set(2003, 5, 6);//Establece el año, mes y dia respectivamente
display(calendario.getTime());//Muestra: Viernes 06/06/2003 17:04:30
calendario.set(2004, 10, 25, 21, 30);//Establece año, mes, dia, hora y minutos
respectivamente
display(calendario.getTime());//Muestra: Jueves 25/11/2004 21:30:30
calendario.set(2004, 10, 25, 21, 30, 54);//Establece año, mes, dia, hora,
minutos y segundos respectivamente
display(calendario.getTime());//Muestra: Jueves 25/11/2004 21:30:54

System.out.println("\nMETODO CLEAR");
calendario.clear(calendario.MINUTE);//Quitando los minutos
display(calendario.getTime());//Muestra: Jueves 25/11/2004 21:00:54
calendario.clear();//Quitando todos los datos
display(calendario.getTime());//Muestra: Jueves 01/01/1970 00:00:00
}
}
getTime() Obtiene un objeto de tipo Date.
get(campo) Donde campo es un entero. La función get obtiene el campo (hora, mes, minutos,
mes, etc.) de un calendario.
getTimeInMillis() Obtiene los milisegundos transcurridos desde el 1ro de Enero de 1970 00:00:00
add(campo, k) Donde campo es un entero. La función add añade o sustrae k unidades al campo
(hora, mes, minutos, mes, etc.) de un calendario.
set(campo, k) Donde campo y k son enteros. La función set establece el valor k a un
determinado campo (hora, mes, minutos, mes, etc.) de un calendario.
set(año,mes,dia) Donde año, mes y dia son enteros. La función set establece el año, mes y dia.
set(año,mes,dia,hora,min) Donde año, mes, dia, hora y min son enteros. La función set establece el año,
mes, dia, hora y minutos.
set(año,mes,dia,hora,min,sec) Donde año, mes, dia, hora y min son enteros. La función set establece el año,
mes, dia, hora, minutos y segundos.
clear(campo) Donde campo es un entero. La función clear borra el campo (hora, mes, minutos,
mes, etc.) de un calendario.
clear() Borra todos los campos y los establece a 1ro de Enero de 1970 00:00:00
A.compareTo(B) Donde A y B son Calendars. La función compareTo devuelve entero tal que:
0: si A es igual a B.
>0: si A es mayor a B.
<0: si A es menor a B.
 José Gonzalo Espejo Cuba 83
GUIA DE JAVA

8.3.3 GREGORIAN CALENDAR

import java.util.Calendar;
import java.util.GregorianCalendar;
public class JavaGregorianCalendar {
public static void main(String[] args) {
Calendar cal=GregorianCalendar.getInstance();
//CODIGO
}
}

Gregorian Calendar es el sistema de calendario estándar en el mundo, al menos en el mundo occidental que comprende
Europa, Norte, Centro y SurAmérica y muchos otros países.

8.4 OTROS METODOS DE REDONDEO

8.4.1 DECIMAL FORMAT

import java.text.DecimalFormat;
public class Decimalformat {
public static void main(String[] args) {
double pi=Math.PI;
System.out.println(pi);//Muestra: 3.141592653589793
DecimalFormat df;
String x;

System.out.println("Redondeo a 3 decimales");
df=new DecimalFormat("#.###");
x=df.format(pi);
System.out.println(x);//Muestra: 3,142
System.out.println("Redondeo a 8 decimales");
df=new DecimalFormat("#.########");
x=df.format(pi);
System.out.println(x);//Muestra: 3,14159265
}
}

8.4.2 REDONDEO CON BIGDECIMAL

import java.math.BigDecimal;
import java.math.RoundingMode;
public class Redondeo_bigdecimal {
public static void main(String[] args) {
double pi=Math.PI;
System.out.println(pi);//Muestra: 3.141592653589793
BigDecimal bd;

System.out.println("Redondeo a 3 decimales");
bd= new BigDecimal(pi).setScale(3, RoundingMode.HALF_EVEN);
pi = bd.doubleValue();
System.out.println(pi);//Muestra: 3.142

System.out.println("Redondeo a 8 decimales");
pi=Math.PI;
bd= new BigDecimal(pi).setScale(8, RoundingMode.HALF_EVEN);
pi = bd.doubleValue();
System.out.println(pi);//Muestra: 3.14159265
}
}
84 José Gonzalo Espejo Cuba
GUIA DE JAVA

8.4.3 REDONDEO CON JAVA.LANG.MATH

//Redondea a 4 digitos decimales

pi=Math.PI;
pi= (double)Math.round(pi * 10000) / 10000;
System.out.println(pi);//Muestra: 3.1416

8.5 LIMITES DE TIPOS DE DATOS PRIMITIVOS

public class Limites {

public static void main(String[] args) {
System.out.println("Valor minimo: "+Byte.MIN_VALUE);//Imprime: -128
System.out.println("Valor maximo: "+Byte.MAX_VALUE);//Imprime: 127
System.out.println("Longitud en bits: "+Byte.SIZE);//Imprime: 8

System.out.println("Valor minimo: "+Short.MIN_VALUE);//Imprime: -32768

System.out.println("Valor maximo: "+Short.MAX_VALUE);//Imprime: 32767
System.out.println("Longitud en bits: "+Short.SIZE);//Imprime: 16

System.out.println("Valor minimo: "+Integer.MIN_VALUE);//Imprime: -2147483648

System.out.println("Valor maximo: "+Integer.MAX_VALUE);//Imprime: 2147483647
System.out.println("Longitud en bits: "+Integer.SIZE);//Imprime: 32

System.out.println("Valor minimo: "+Long.MIN_VALUE);//Imprime: -9223372036854775808

System.out.println("Valor maximo: "+Long.MAX_VALUE);//Imprime: 9223372036854775807
System.out.println("Longitud en bits: "+Long.SIZE);//Imprime: 64

System.out.println("Valor minimo: "+Float.MIN_VALUE);//Imprime: 1.4E-45

System.out.println("Valor maximo: "+Float.MAX_VALUE);//Imprime: 3.4028235E38
System.out.println("Longitud en bits: "+Float.SIZE);//Imprime: 32
System.out.println("Maximo exponente: "+Float.MAX_EXPONENT);//Imprime: 127
System.out.println("Minimo exponente: "+Float.MIN_EXPONENT);//Imprime: -126

System.out.println("Valor minimo: "+Double.MIN_VALUE);//Imprime: 4.9E-324

System.out.println("Valor maximo: "+Double.MAX_VALUE);//Imprime: 1.7976931348623157E308
System.out.println("Longitud en bits: "+Double.SIZE);//Imprime: 64
System.out.println("Maximo exponente: "+Double.MAX_EXPONENT);//Imprime: 1023
System.out.println("Minimo exponente: "+Double.MIN_EXPONENT);//Imprime: -1022

System.out.println("Valor minimo: "+Character.SIZE);//Imprime: 16

}
}

8.6 TRANSFORMACION DE DATOS PRIMITIVOS A BINARIO, OCTAL Y HEXADECIMAL

public class Binario_octal_hexa {

public static void main(String[] args) {
String binario,octal,hexa;
int bits;

int num1=155;
binario=Integer.toBinaryString(num1);
octal=Integer.toOctalString(num1);
hexa=Integer.toHexString(num1).toUpperCase();
bits=Integer.bitCount(num1);
System.out.println(binario);//Imprime: 10011011
System.out.println(octal);//Imprime: 233
System.out.println(hexa);//Imprime: 9B
System.out.println("Bits encendidos: "+bits);//5
 José Gonzalo Espejo Cuba 85
GUIA DE JAVA

long num2=300;
binario=Long.toBinaryString(num2);
octal=Long.toOctalString(num2);
hexa=Long.toHexString(num2).toUpperCase();
bits=Long.bitCount(num2);
System.out.println(binario);//Imprime: 100101100
System.out.println(octal);//Imprime: 454
System.out.println(hexa);//Imprime: 12C
System.out.println("Bits encendidos: "+bits);//4

float num3=(float) Math.PI;

hexa=Float.toHexString(num3).toUpperCase();
System.out.println(hexa);//Imprime: 0X1.921FB6P1

double num4= Math.PI;

hexa=Double.toHexString(num4).toUpperCase();
System.out.println(hexa);//Imprime: 0X1.921FB6P1
}
}

8.7 OPERACIONES DE BITS

public class Operaciones_bits {

public static void main(String[] args) {
int a=12,b=10;
System.out.printf("%d and %d = %d\n",a,b,a&b);//Muestra: 12 and 10 = 8
System.out.printf("%d or %d = %d\n",a,b,a|b);//Muestra: 12 or 10 = 14
System.out.printf("%d xor %d = %d\n",a,b,a^b);//Muestra: 12 xor 10 = 6
System.out.printf("negacion %d\n",(~b));//Muestra: negacion -11
System.out.printf("%d << %d = %d\n",a,1,a<<1);//Muestra: 12 << 1 = 24
System.out.printf("%d << %d = %d\n",a,2,a<<2);//Muestra: 12 << 2 = 48
System.out.printf("%d << %d = %d\n",a,3,a<<3);//Muestra: 12 << 3 = 96
System.out.printf("%d >> %d = %d\n",a,1,a>>1);//Muestra: 12 >> 1 = 6
System.out.printf("%d >> %d = %d\n",a,2,a>>2);//Muestra: 12 >> 2 = 3
System.out.printf("%d >> %d = %d\n",a,3,a>>3);//Muestra: 12 >> 3 = 1
}
}

8.8 PLANTILLA PARA COMPETENCIAS

import java.math.*;
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner leer =new Scanner(System.in);
}
}