guía básica de java - el blog de skatox · básicos conceptos de java, por tal motivo, no intento...

GUIA BÁSICA DE JAVAPor Miguel Useche

http://www.skatox.com/

GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM

http://www.skatox.co.ve/



INTRODUCCIÓN

Guía realizada por Miguel Useche, al principio consistía en una guía personal para ayudarme en la universidad pero luego al ir creciendo decidí compartirla con el resto de personas.

Esta guía sirve como referencia para el programador que conoce los básicos conceptos de Java, por tal motivo, no intento explicar en mucho detalle todo, sino simplemente poner semi-ejemplos de como hacer las cosas y tener una idea de como hacerlo.

Espero que les guste, la sigan distribuyendo siempre y cuando no la modifiquen y respeten los derechos de autor.

Miguel Useche

www.skatox.com


ARCHIVOS

ARCHIVOS DE TEXTO (Secuenciales)Estos archivos sirven para guardar cadenas de texto principalmente, se leen secuencial, es decir, línea por línea y no sirven para guardar objetos de manera binaria. Aquí observamos como crear un archivo File que es para manejar archivos y carpetas.

File archivo = new File(“ruta)= new File(“/carpeta/”,”archivo.extension”)= new File(“ruta_de_carpeta”) //de esta forma el objeto es una carpeta

Métodos Importantes:

archivo.exists(); //chequea si existe o nó (devuelve booleano)archivo.canWrite() //chequea si tiene permiso de escritura (booleano) archivo.canRead() //chequea si permiso de lectura (devuelve booleano)archivo.isFile() //chequea si es un archivo(devuelve booleano) archivo.isDirectory() //chequea si es una carpeta (devuelve booleano)archivo.lists() //lista los archivos en el directorio del objeto archivoarchivo.renameTo(archivo2) //renombra el archivo al nombre de archivo2

//borra el archivo (devuelve booleano dependiendo si pudo hacerlo)archivo.delete()

Leer línea por línea un archivo:

//Objeto que lee el archivo en la ruta indicada (si no existe lo crea)String linea;

BufferedReader lector = new BufferedReader(new FileReader(“ruta_archivo.extension”));

//Guardo en un string, si llega al final del archivo devuelve NULLlinea = lector.readLine();

//Es recomendado cerra el archivo después de leerlolector.close();

Escribir línea por línea en un archivo:

//Objeto que va a escribir en la ruta indicada (si no existe lo crea)FileWriter escritor = new FileWriter(“ruta_archivo.extension”);

//Aqui le decimos al objeto que escriba en el archivo lo que recibe por parametroescritor.write(“COSA A GUARDAR”);

///DESPUES DE ESCRIBIR TODO RECORDAR CERRAR EL ESCRITOR PA Q SE GUARDEescritor.close();


Método Abrir:

//Este metodo me permite crear un FileDialog para buscar la ruta de un archivo y devolverla, requiere un String para el titulo de la ventana del FileDialog

File ARCHIVOAUSAR = abrir(“TITULO DE LA VENTANA”);

static File abrir(String a){

File archivo = new File(""); //CREA EL ARCHIVO try{

//Crea un frame para pegar el FileDialog Frame cuadro = new Frame(); cuadro.show(); FileDialog abrirarchivo = new FileDialog(cuadro,a, FileDialog.LOAD); abrirarchivo.show(); //Muestra el FileDialog archivo = new

File(abrirarchivo.getDirectory(),abrirarchivo.getFile()); cuadro.hide(); abrirarchivo.hide();

//oculta todo una vez seleccionado el archivo } catch(Exception e){ System.out.println("ERROR AL CARGAR ARCHIVO");

//Aqui se inserta el error en caso de no cargar el archivo

} return archivo; }

ARCHIVOS ALEATORIOS (Secuenciales)Estos archivos guardan bytes de información, no son secuenciales por lo que se puede leer en cualquier parte del archivo de manera instantánea, se suelen usar para guardar objetos de Java. Cabe destacar que para leer de ellos, se debe saber la estructura de como se guardaron los datos.

//Asi se crea en java este tipo de archivo, el segundo parametro es sólo “r”// si desea para pura lectura o “rw” para lectura y escritura.RandomAccessFile archivo = new RandomAccessFile(“ruta_archivo”,”rw”);

Métodos Importantes:

archivo.length() //devuelve el tamaño del archivo (long)

archivo.seek(pos) //ubica el puntero del archivo en pos el cual es long

archivo.close() //cierra el archivo


Leer y Escritura de archivos de acceso aleatorio:

Lo bueno de estos archivos es que no es necesario crear un objeto para lectura y otro para escritura, ya que el mismo objeto RandomAccessFile tiene los métodos para la lectura y escritura. Por lo que para la lectura sería simplemente:

/****LECTURA******/String buffer= archivo.readUTF();//Leer una cadena de Texto

byte buffer = archivo.readByte(); //Leer un byte

int buffer = archivo.readInt() //Leer Entero

/****ESCRITURA******///Para la escritura se debe tener cuidado al ubicar el cursor del archivo

//ya que hay riesgo de sobreescribir datos, si desean escribir al final del

// archivo abierto (con permisos “rw”) deben hacer:

archivo.seek(archivo.length()) //ubica el cursor al final del archivo

archivo.write(buffer) //escribe buffer en bytes (puede ser un vector)

archivo.writeInt(numero) //escribe el int numero en el archivo

archivo.writeUTF(texto) //escribe una cadena de texto (string) en el archivo

Existen muchas formas mas de leer y escribir en estos archivos de acceso aleatorio, por lo que les recomiendo consultar el API de java para obtener mayor información.


OPERACIONES MATEMÁTICAS

CLASE MATHEsta es la clase en java que permite las operaciones básicas de la matemáticas, al igual que

trae el valor constantes de algunos números importantes para las matemáticas, como PI, Exponencial, entre otros. Para acceder a ella se importa con:

import java.lang.Math;

Constantes que trae la clase:

Math.PI; // Pi π Math.E; //Exponencial

Operaciones matemáticas:

Math.abs(numero); //valor absoluto de un númeroMath.round(numero) //aproximación de un entero

Math.floor(numero) //aproximación de un decimales

Math.min(num1,num2)//halla el menor de 2 números (devuelve el menor)Math.max(num1,num2) //hall el mayor de 2 números (devuelve el mayor)

Math.pow(base,exponente) // Halla la potencia de un numero

Math.random() //devuelve número pseudoaleatorio entre 0.0 y 1.0

Math.sqrt(numero) //devuelve la raíz cuadrada de un número

Math.log(numero) //devuelve el logaritmo de un número

Math.sin(angulo) //da el seno de un ángulo

Math.cos(angulo) //da el coseno de un ángulo

NUMEROS ALEATORIOS

CLASE RANDOMPara ello se utiliza la clase Random (Azar en inglés), y se obtiene mediante:

import java.util.Random;

Se crea un objeto de la clase Random para obtener las funciones (no es necesario pero si recomendable) de la manera siguiente:

Random azar = new Random();

Obtener numeros aleatorios:

int numero=azar.nextInt(limite) // Da un aleatorio desde 0 hasta limite1

float num=azar.nextFloat(); // Da un flotante entre 0.0 y 1.0

double num=azar.nextDouble(); // Da un double entre 0.0 y 1.0

boolean verdad=azar.nextBoolean(); // Método que devuelve true o false


OPERACIONES CON MATRICES (ARREGLOS 2D)

Declaración:

Tipo_de_Objeto [][] nombre_matriz = new Tipo_de_Objeto[tamaño][tamaño] int [][] mat = new int [3][3]; // ejemplo de creacion de una matriz 3x3

Nota: Cuando se crean matrices de objetos, se debe definir la matriz, y luego recorrela toda para instanciar (darle memoria con new) cada objeto de la matriz.

Recorrido:

for(j=0; j<ancho; j++){ for(i=0; i<alto; i++){ //[vertical][horizontals]

mat[i][j]; //[filas][columnas]} }

Lectura de matriz por filas:

//En este ejemplo se lee del teclado los valores a llenar en una matriz:BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));

String buffer;

for(int i=0;i<4;i++) for(int j=0;j<5;j++) { System.out.println("Ingrese un numero"); try{ buffer=teclado.readLine(); Matriz[i][j]=Integer.parseInt(buffer); }catch(IOException e){} } for(int i=0; i<4;i++){ for(int j=0;j<5;j++) { System.out.print(Matriz[i][j]+" "); } System.out.println(); }

Lectura de matriz por columnas for(int j=0;j<5;j++) for(int i=0;i<4;i++) matriz[i][j];

Imprimir matriz en la consola for(int j=0; j<5;j++){ for(int i=0;i<4;i++) System.out.print(Matriz[i][j]+" "); System.out.println(); }


TRANSFORMACIONES ENTRE OBJETOS

Char caracter= Character.forDigit(numero,base); // numero a carácter

int num = Character.digit(caracter,base); // caracter a numero

Character letra =new Character('letra');String texto = objeto.toString(); // caracter a arreglo de texto

char texto[]= string.toCharArray()//cadena de texto a arreglo de caracteresString linea =String.valueOf(numero); //numero a cadenaint numero = Integer.parseInt(Texto); //texto a numerofloat num = Float.parseFloat(Texto); //texto a flotante

float num = Double.parseDouble(Texto); //texto a doble precisión

byte arreglo[]= (byte) Objeto //pasar algo a bytes

MANIPULACIÓN DE BITS//Con signo

Objeto >> n //desplaza a la derecha “n” posiciónes los bits del objeto

Objeto << n //desplaza a la izquierda “n” posiciónes los bits del objeto

//Sin signo

Objeto >>> n //desplaza a la derecha “n” posiciónes los bits del objeto

a & b // operación and entre a y b

a | b // operación or entre a y b

a ^ b // operación or exlusiva entre a y b

Notas:

● Al desplazar a la derecha sin signo, los bits vacios se rellena con 0.● Al desplazar a la izquierda, si se desplaza un 1 al bit mas significativo, el valor se convertirá en

negativo.


METODOS DE ORDENACIÓNAquí simplemente van algunos algoritmos hecho para ordenar un arreglo unidimensional:

QUICKSORT

public class QuickSort{ public static void intercambiar(int arreglo[], int pos, int y) { int temp = arreglo[pos]; arreglo[pos] = arreglo[y]; arreglo[pos] = temp; }

public static int particionar(int arreglo[], int inicio, int limite) { int pivote = arreglo[inicio]; while ( inicio < limite) { while (arreglo[inicio] < pivote) inicio++; while (arreglo[limite] > pivote) limite; intercambiar(arreglo, inicio, limite); } return inicio; }

public static void Quicksort(int arreglo[], int inicio, int limite) { if ( inicio >= limite) return; int pivote = partition(arreglo, inicio, limite); Quicksort(arreglo, inicio, pivote); Quicksort(arreglo,pivote+1, limite); }

//Para usar esta clase, se llama a Quicksort asi:

QuickSort.Quicksort(objeto,0,objeto.length());

METODO DE LA BURBÚJA

public static void burbuja(int[] v) { for(int i=1; i<v.length; i++) { for(int j=0; j<v.lengthi; j++) { if(v[j]>v[j+1]) // Signo: < de Menor a Mayor ó > Mayor a menor. { int aux=v[j]; v[j]=v[j+1]; v[j+1]=aux; } }//fin for j }//fin for i }


SELECCIÓN DIRECTA

for( int i=0; i<v.length 1; i++){ int menor = v[i]; int pos = I;

for(int j=i+1; j<v.length; j++){if(v[i] < menos)

{intaux = v[i];menor = v[j];pos = j;}

}v[pos] = v[i];v[i] = menor;

}}

VALIDACIONES

Validar ciertos caracteres:La validación se hace para que al ingresar datos, no entren datos erróneos que puedan alterar ó

bloquear el funcionamiento del programa. Si queremos validar cierta cantidad de caracteres (sólo números, letras, etc), con esta función se puede hacer todo, sólo se debe cambiar la variable “lista_caracteres” para que incluya sólo los caracteres que puede aceptar de una cadena:

public static boolean aceptar(String cadena){

//en este caso son sólo numeros descomentar la otra linea para letras

String lista_caracteres = "0123456789 ";

// String lista_caracteres = "ABCDEFGHIJKLMNÑOPQURSTUVWXYZ ";

String caracter, aux1;

int i, j;

boolean aceptado = true;

for(i=0; i< cadena.length(); i++) {

caracter = cadena.substring(i, i+1);

for(j=0; j <= (lista_caracteres.length()1); j++){

aux1 = lista_caracteres.substring(j, j+1);

if(aux1.compareTo(caracter) == 0) break;

if(j== 10){

aceptado = false;

break;

}

}

}//end for

return aceptado; //Si es true que lo acepta, false es no válido

}



CADENAS DE TEXTO (String)

Funciones importantes:Cada cadena de texto (String) posee una serie de métodos que nos permite realizar tareas que facilitarán nuestra programación, a continuación le muestro alguna de las mas importantes:

cadena.length() //devuelve el largo de la cadena (cantidad de caracteres en ellacadena.toLowerCase() //devuelve cadena con todas las letras en minúscula

cadena.toUpperCase() //devuelve cadena con todas las letras en mayúscula

cadena.trim() //devuelve la cadena sin espacios

cadena.charAt(posición) //devuelve la letra que esta en la posición indicada

cadena.indexOf(letra) //devuelve la primera posición de la letra en el texto

cadena.lastIndexOf(letra) //devuelve la última posición de la letra en el texto

//sustituye el caracter por caracter_nuevo en la cadena

cadena.replace(caracter,caracter_nuevo)

//sustituye la porcion de texto que coincida con subcadena por nuevo

cadena.replaceAll(subcadena,nuevo)

//separa la cadena en porciones de texto (palabras, ejemplo) delimitadas por // los caracteres indicados en su parametro, por ejemplo:

String texto = “esto es prueba”;

String vector[];

vector = texto.split(“ “);

//guardará en cada posición del vector (en este caso 3) cada palabra, ya que cada palabra esta separada por un espacio.

//otro ejemplo

String texto = “estoes/prueba”;

String vector[];

vector = texto.split(“/“);

//guardaría cada palabra en cada posición de vector porque los delimitadores usados en cadena son los mismos que los pasados por parámetros.


ARREGLO DINÁMICO

Creación:● Se hace con la clase Vector, para ello se debe importar java.util:

import java.util.Vector● Se instancia el objeto:

Vector variable = new Vector();● Se instancia el objeto:

Vector variable = new Vector();

Métodos importantes:

variable.addElement(cosaaaguardar); //agrega un objeto al vector

//NOTA: a veces hay q transformarlo en la variable deseada.variable.get(indice); //obtiene el objeto en el indice pedido

variable.remove(indice) //elimina el objeto que está en el indice

variable.removeElement(Objeto)//elimina el primer objeto que sea igual al parametro

variable.size() //devuelve el tamaño del vector

variable.toArray() //devuelve un vector con los elementos que contiene


INTERFAZ GRAFICA

AGREGAR ALGO AL FRAME

frame.getContentPane().add(loquesea);Layout new FlowLayout()//Sin layout

CANVAS

import java.awt.*;import java.awt.event.*;

public class MyCanvas extends Canvas { public static void main(String[] args) throws Exception { Frame f = new Frame(); f.setBounds(0, 0, 500, 300); MyCanvas can = new MyCanvas(){ public void paint(Graphics g){ int ancho=getSize().width; int alto=getSize().height; String titulo="hola";

g.setColor(Color.BLACK); g.setFont(getFont()); g.fillOval(200, 200, 30,30); g.fillArc(150, 150, 60, 60, 90, 90); g.fillRect(10, 20, 100, 2); } }; f.add(can);

CANVAS (JPANEL)

import java.awt.Graphics;public class JPanelSencillo { public static void main(String args[]) { // // Se crea un nuevo panel por derivación de JPanel // JPanel jp = new JPanel() { // // Se redefine paintComponent() para que // a) ejecute el paintComponent() original // b) ejecute las nuevas instrucciones gráficas // protected void paintComponent(Graphics g) {


super.paintComponent(g); g.drawString("ABRACADABRA.", 20,50); }; }; // // Se fija el tamaño preferido del panel // jp.setPreferredSize(new Dimension(200,200)); // // Se crea un JFrame, se le añade jp // y se registra una clase anónima para que // al cerrar todo vaya bien // JFrame jf = new JFrame("JPanelSencillo"); jf.setContentPane(jp); jf.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); // // Se pide que el JFrame se adapte a su contenido // jf.pack(); // // Con todo preparado, se hace visible // jf.setVisible(true); }}

CERRAR VENTANA (awt)

frame.addWindowListener( new WindowAdapter() { public void windowClosing( WindowEvent evt ) { System.exit( 0 ); }} );

CERRAR VENTANA (swing)

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

CHECKBOXGROUP

frame.setLayout(new FlowLayout()); CheckboxGroup a = new CheckboxGroup(); Checkbox c1 = new Checkbox("Hombre",a,true); Checkbox c2 = new Checkbox("Mujer",a,false);

CREAR UNA LISTA Y AGREGARLE OPCIONES

List lista = new List(3); lista.add("Uno"); lista.add("Dos"); lista.add("Tres"); lista.add("Cuatro");


CREAR UNA LISTA Y AGREGARLE OPCIONES

List lista = new List(3); lista.add("Uno");

FUENTES

Font fuente=new Font("Arial", Font.BOLD, 14);

INSERTAR IMAGEN

import javax.swing.*;

public class principal extends JPanel {

b4.setIcon(new javax.swing.ImageIcon(getClass().getResource("tierra10.GIF")));

INSERTAR IMAGEN(AWT)

public class Prueba extends JFrame {java.awt.Toolkit tk;Image im;public Prueba2(){super();this.setSize(400,400);tk = this.getToolkit();im = tk.getImage("mi_imagen.jpg");Canvas cv = new Canvas(){public void paint(Graphics g){g.drawImage(im, 0, 0, this);}};cv.setSize(200,200);getContentPane().add(cv);}

public static void main(String[] args){new Prueba2().show();}}

LISTADO DE OPCIONES

Choice cg = new Choice (); cg.add("Azul"); cg.add("Blanco");


cg.add("Negro"); frame.add(cg);

LISTADO DE OPCIONES

Dialog d = new Dialog(f, "Ejemplo Cuadro de Dialogo", true); Label dl = new Label("Presione el Botón"); Button db1 = new Button("OK"); d.add(dl); d.add(db1); d.pack();

VENTANA SE AJUSTE A LOS COMPONENTES

frame.pack();


Eventos

frame.addCOSAListener( new ADAPTER CLASS() { public void METODO( COSAEvent evt ) { System.exit( 0 ); }} );Sustiur lo negrita por lo del cuadro.


COMUNICACIÓN TCP/IP

ServerSocket socket = new ServerSocket (35557);//Aceptar clienteSocket cliente = socket.accept();

//DECLARAR OBJETOS INTERCOMUNICADORESInputStream entrada = cliente.getIntputStream();OutputStream salida = cliente.getOutputStream();

///objeto de entradaDataInputStream entradaDatos = new DataInputStream (entrada);//objeto de salidaDataOuputStream salidaDatos = new DataOutputStream (salida);

ObjectInputStream entradaObjetos = new ObjectInputStream (entrada);//recibir obejtosObjectOutputStream salidaObjetos = new ObjectOutputStream (salida);//enviar objetos

Envio/Lectura de datos normales (enteros, flotantes, strings)

El envío/lectura de datos normales se hace con las clases DataInputStream y DataOutputStream. No tienen ningún truco especial, basta usar el metodo adecuado (writeInt(), writeFloat(), readInt(), etc). Para strings usaremos los métodos writeUTF() y readUTF(), que envían/leen las cadenas en formato UTF.

Envio/Lectura de clases enteras

Para el envio/lectura de clases normales usaremos los métodos readObject() y writeObject() de ObjectInputStream y ObjectOutputStream. Para poder usar estos métodos las clases que enviemos deben implementar la interface Serializable.

Cerrar conexionsocket.close() p

COMUNICACION UDP

UDP:import sun.net.*; DatagramSocket socket = (DatagramSocket)null;

DatagramPacket out; DatagramPacket in;

byte buffer[] = new byte[100];


InetAddress IP = (InetAddress)null;

// Crea una petición para enviar bytes. Intenta conseguir socket = new DatagramSocket( puerto_recepcion);

// la dirección IP del host IP = InetAddress.getByName( "10.0.15.3" );

out = new DatagramPacket( buffer,buffer.length,IP,puerto_emision );

socket.send( out);

System.out.println("Paquete enviado!!!");

// Consigue un controlador de fichero de entrada del socket y lee // dicha entrada. Creamos un paquete descriptor para recibir el // paquete UDP

in = new DatagramPacket( buffer,longitud );

// Espera a recibir un paquete socket.receive( in );


Clase Thread Métodos de control:

Crear un thread (constructor Thread).

Iniciar la ejecución (start).

Detener la ejecución (suspend, interrupt, stop, sleep).

Reanudar la ejecución (resume).

Ceder el procesador (yield).

Esperar la terminación de otro thread (join).

Para crear hilo, deben crear una clase, si necesitan heredar algo implenten la clase Runnable, si no, pues hereden la clase Thread, es mas facil, luego creen adentro lo que les de la gana. Pero RECUERDE crear el metodo “public void run(){}” que es el main del hilo, de alli haga lo que quiera.


guía básica de java - el blog de skatox · básicos conceptos de java, por tal motivo, no intento...

Documents