Guía básica de Java

GUIA BÁSICA DE JAVA
Por Miguel Useche
http://www.skatox.com/
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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
GUÍA BÁSICA DE JAVA POR 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 archivo
archivo.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 NULL
linea = lector.readLine();
//Es recomendado cerra el archivo después de leerlo
lector.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 parametro
escritor.write(“COSA A GUARDAR”);
///DESPUES DE ESCRIBIR TODO RECORDAR CERRAR EL ESCRITOR PA Q SE GUARDE
escritor.close();
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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.
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
OPERACIONES MATEMÁTICAS
CLASE MATH
Esta 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úmero
Math.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 pseudo­aleatorio 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 RANDOM
Para 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 limite­1
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
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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++){ mat[i][j];
}
}
//[vertical][horizontals]
//[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 Imprimir matriz en la consola
for(int j=0;j<5;j++)
for(int j=0; j<5;j++){
for(int i=0;i<4;i++)
matriz[i][j]; for(int i=0;i<4;i++)
System.out.print(Matriz[i][j]+" ");
System.out.println();
}
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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 caracteres
String linea =String.valueOf(numero); //numero a cadena
int numero = Integer.parseInt(Texto); //texto a numero
float 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.
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
METODOS DE ORDENACIÓN
Aquí 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.length­i; 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
}
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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
}
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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 ella
cadena.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 = “esto­es/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.
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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) {
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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");
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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");
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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(); GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
Eventos
frame.addCOSAListener( new ADAPTER CLASS() {
public void METODO( COSAEvent evt ) {
System.exit( 0 ); }} );
Sustiur lo negrita por lo del cuadro.
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
COMUNICACIÓN TCP/IP
ServerSocket socket = new ServerSocket (35557);
//Aceptar cliente
Socket cliente = socket.accept();
//DECLARAR OBJETOS INTERCOMUNICADORES
InputStream entrada = cliente.getIntputStream();
OutputStream salida = cliente.getOutputStream();
///objeto de entrada
DataInputStream entradaDatos = new DataInputStream (entrada);
//objeto de salida
DataOuputStream salidaDatos = new DataOutputStream (salida);
ObjectInputStream entradaObjetos = new ObjectInputStream (entrada);//recibir obejtos
ObjectOutputStream 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 conexion
socket.close() p
COMUNICACION UDP
UDP:
import sun.net.*;
DatagramSocket socket = (DatagramSocket)null;
DatagramPacket out;
DatagramPacket in;
byte buffer[] = new byte[100];
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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 );
GUÍA BÁSICA DE JAVA POR MIGUEL USECHE – WWW.SKATOX.COM
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 POR MIGUEL USECHE – WWW.SKATOX.COM