Permutaciones: Sin repetición / Importa orden. (forma recursiva)

Codigo:

//* Permutaciones (Forma recursiva)

//- Importa posición

//- Sin repetición

//- Requisito: R >= N

package permutacion2;

public class Permutacion2 {

    public static void main(String[] args) {

        String[] elementos = "a,b,c,d,e".split(",");

        int n = 4;                  //Tipos para escoger

        int r = elementos.length;   //Elementos elegidos

        Perm2(elementos, "", n, r);

    }

    private static void Perm2(String[] elem, String act, int n, int r) {

        if (n == 0) {

            System.out.println(act);

        } else {

            for (int i = 0; i < r; i++) {

                if (!act.contains(elem[i])) { // Controla que no haya repeticiones

                    Perm2(elem, act + elem[i] + ", ", n - 1, r);

                }

            }

        }

    }

}

Resultado:

run:
a, b, c, d,
a, b, c, e,
a, b, d, c,

...

...

...

e, d, b, c,
e, d, c, a,
e, d, c, b,
BUILD SUCCESSFUL (total time: 0 seconds)

Permutaciones: Con repetición / Importa orden. (forma recursiva)

Codigo:

//* Permutaciones (Forma recursiva)
//- Importa posición
//- Con repetición
package permutacion1;

public class Permutacion1 {

    public static void main(String[] args) {
        String[] elementos = "a,b,c,d,e".split(",");
        int n = 4;                  //Tipos para escoger
        int r = elementos.length;   //Elementos elegidos

        Perm1(elementos, "", n, r);

    }

    private static void Perm1(String[] elem, String act, int n, int r) {
        if (n == 0) {
            System.out.println(act);
        } else {
            for (int i = 0; i < r; i++) {
                Perm1(elem, act + elem[i] + ", ", n - 1, r);
            }
        }
    }
}

Resultado:

run:
a, a, a, a,
a, a, a, b,
a, a, a, c,
...

...

...

e, e, e, c,
e, e, e, d,
e, e, e, e,
BUILD SUCCESSFUL (total time: 0 seconds)

Obtener el resultado numérico de una formula contenida en un string: eval.

Codigo:

 

//Obtener el resultado de una formula que esta contenida en una variable de tipo string: eval.

package formula;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class Formula {    
    public static void main(String[] args) {        
        ScriptEngineManager mgr = new ScriptEngineManager();   
        ScriptEngine engine = mgr.getEngineByName("JavaScript");       
        try {
            String formula = "5-3+6*(10/2)";
            System.out.println(formula + " = " + engine.eval(formula));
        } catch (ScriptException ex) {}
    }    
}

Resultado:

run:
5-3+6*(10/2) = 32.0
BUILD SUCCESSFUL (total time: 0 seconds)

Imprimir un jPanel y con todos sus componentes internos.

Usando el Netbeans creamos un jDialog y le agregamos un jPanel. Dentro de ese jPanel le agregamos por ejemplo una jTable, un label y un jButton. Tal y como muestra la siguiente captura:

Codigo:

//Imprimir un jPanel y con todos sus componentes internos.
package imprimir;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;

public class Impresiones extends javax.swing.JDialog implements Printable {
    public Impresiones(java.awt.Frame parent, boolean modal) {
        initComponents();
    }
    private void initComponents() {...}//aqui va codigo generado por Netbeans
    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                        
        try {
            PrinterJob job = PrinterJob.getPrinterJob();
            job.setPrintable(this);
            job.printDialog();
            job.print();
        } catch (PrinterException ex) { }       
    }

    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                Impresiones dialog = new Impresiones(new javax.swing.JFrame(), true);
                dialog.addWindowListener(new java.awt.event.WindowAdapter() {
                    public void windowClosing(java.awt.event.WindowEvent e) {
                        System.exit(0);
                    }
                });
                dialog.setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify                    
    private javax.swing.JButton jButton1;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTable jTable1;
    // End of variables declaration                  
   
    public int print(Graphics graphics, PageFormat pageFormat, int pageIndex) throws PrinterException {
        if (pageIndex > 0) return NO_SUCH_PAGE;
        Graphics2D g2d = (Graphics2D)graphics;
        //Punto donde empezará a imprimir dentro la pagina (100, 50)
        g2d.translate(  pageFormat.getImageableX()+100,
                        pageFormat.getImageableY()+50);
        g2d.scale(0.50,0.50); //Reducción de la impresión al 50%
        jPanel1.printAll(graphics);
        return PAGE_EXISTS;               
    }
}

Resultado:

Impresión de un jTable

Usando Netbeans creamos un jFrame y le agregamos con la "Palette" un jTable y un jButton.

Codigo:

 

// Impresión de un jTable

package imprimirtabla;

import java.awt.print.PrinterException;

public class ImprimirTabla extends javax.swing.JFrame {
    public ImprimirTabla() {
        initComponents();
    }

private void initComponents() {...} // Aqui va el codigo generado por Netbeans.

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                        
        try {
            jTable1.print(); // Imprime el jTable
        } catch (PrinterException ex) { }
    }                                       

    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new ImprimirTabla().setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify                    
    private javax.swing.JButton jButton1;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTable jTable1;
    // End of variables declaration                  
}

Resultado: 

Tabla de selector de colores: JColorChooser

JColorChooser permite mostrar una ventana para que el usuario seleccione un color de entre todas la gama de colores disponibles. Utilizaremos la Ide Netbeans 7.1 para crear la interface grafica (un JFrame con un JButton dentro). Debe quedar algo parecido a esto:




Codigo:

// Tabla de selector de colores: JColorChooser
package colores1;
import java.awt.Color;import javax.swing.JColorChooser;

public class Colores1 extends javax.swing.JFrame {
public Colores1() {
initComponents();
this.setLocationRelativeTo(null); //centrar pantalla
}

private void initComponents() {
//Codigo generado por Netbeans al crear la interface grafica manualmente...
}

private void JButtonCargarColoresActionPerformed(java.awt.event.ActionEvent evt) {
Color c = JColorChooser.showDialog(this, "Seleccion color" , Color.white);
if(c != null) getContentPane().setBackground(c);
}

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable(){
public void run() {
new Colores1().setVisible(true);
}
});
}

// Variables declaration - do not modify
private javax.swing.JButton JButtonCargarColores;
// End of variables declaration
}


Resultado:


·

Gráficos: Dibujar una línea roja.

Código Java (LineaRoja.java):


// Gráficos - Dibujar una línea roja: setColor, drawLine.
 
package linearoja;

import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Color;

public class LineaRoja extends Frame {

    public LineaRoja() {
        this.setSize(200, 150);
        this.setVisible(true);
    }

    @Override
    public void paint(Graphics g) {
        g.setColor(Color.RED);
        g.drawLine(50, 50, 100, 100);
    }

    public static void main(String[] args) {
        LineaRoja p = new LineaRoja();
    }

}



Resultado:


·

Navegar por los directorios: JFileChooser

Descripción:

JFileChooser permite mostrar una ventana para que el usuario navegue por los directorios y elija un fichero. En este ejemplo se muestran ficheros de tipo imagen. Utilizaremos la ide Netbeans 7.1 para crear la interface grafica (un JFrame con un JButton dentro). Debe quedar algo parecido a esto:




Codigo:

// Navegar por los directorios: JFileChooser
package imagenes1;
import java.io.File;
import java.io.FilenameFilter;
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileNameExtensionFilter;

public class Imagenes1 extends javax.swing.JFrame {

private File[] fotos;
public Imagenes1() {
initComponents();
this.setLocationRelativeTo(null); //centrar pantalla
}

@SuppressWarnings("unchecked")
private void initComponents() {
//Aqui va el codigo generado automaticamente por Netbeans al crear la interface grafica manualmente (un JFrame con un JButton dentro).
}

private void JButtonCargarFotoActionPerformed(java.awt.event.ActionEvent evt) {
JFileChooser fc = new JFileChooser();
fc.setFileFilter(new FileNameExtensionFilter("Archivos de imagen","tif","jpg","jpeg","png","gif"));
int opcion = fc.showDialog(this, "Abrir");
if (opcion == JFileChooser.APPROVE_OPTION) {
File file = fc.getSelectedFile();
this.cargaDirectorio(file.getParent());
}
}

private void cargaDirectorio(String folder){
File dir = new File(folder);
if (dir.isDirectory()){
this.fotos = dir.listFiles(new FilenameFilter(){
public boolean accept(File file, String nombre){
if (nombre.endsWith(".tif" ) || nombre.endsWith(".jpg" ) ||
nombre.endsWith(".jpeg") || nombre.endsWith(".gif" ) ||
nombre.endsWith(".png")) { return true; }
return false;
}
});
} //cierre if
}

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable(){
public void run() {
new Imagenes1().setVisible(true);
}
});
}

// Variables declaration - do not modify
private javax.swing.JButton JButtonCargarFoto;
// End of variables declaration

}


Resultado:


·

Cambio formato de un número decimal: DecimalFormat

Codigo:

//Cambio de formato de números decimales:
package javaapplication;

import java.text.DecimalFormat;
import java.text.ParseException;

public class JavaApplication {
public static void main(String[] args) {
try {
double num = 9999.888888;
DecimalFormat fd = new DecimalFormat("#0.###");
num = fd.parse(fd.format(num)).doubleValue();
System.out.println(num);
} catch (ParseException ex) { }
}
}


Resultado:

run:
9999.889
BUILD SUCCESSFUL (total time: 0 seconds)
·

Conversiones entre tipos de variables.

//Pasar de String a int:
String str = "100";
int num = Integer.parseInt(str);


//Pasar String a double:
String str = "12.35";
double num = Double.parseDouble(str);


//Pasar String a float:
String str = "12.35";
float num = Float.parseFloat(str);


//Pasar cualquier tipo de variable numérica a un String:
int num = 100;
String str = String.valueOf(num);

//O bien:
int num = 100;
String str = "" + num;

·

Hilos. Creando segundo hilo usando Thread.

Codigo:

//Crear un hilo con la clase Thread
package hilos2;

class Hilo2 extends Thread{
Hilo2(){
super("segundo");
start();
}
public void run() {
try {
for(int i=0; i<5; i++){
System.out.println((Thread.currentThread()).getName()+" hilo aqui...");
Thread.sleep(1000);
}
} catch (InterruptedException ex) {}
System.out.println("Final del segundo hilo");
}
}

public class Hilos2 {
public static void main(String[] args) {
new Hilo2();
try {
for(int i=0; i<5; i++){
System.out.println((Thread.currentThread()).getName()+" hilo aqui...");
Thread.sleep(1000);
}
} catch (InterruptedException ex) {}
}
}


Resultado:

run:
main hilo aqui...
segundo hilo aqui...
segundo hilo aqui...
main hilo aqui...
segundo hilo aqui...
main hilo aqui...
main hilo aqui...
segundo hilo aqui...
main hilo aqui...
segundo hilo aqui...
Final del segundo hilo
BUILD SUCCESSFUL (total time: 5 seconds)
·

Hilos: Creando segundo hilo usando Runnable.

Codigo:

//Crear un hilo con interface Runnable
package hilos1;

class Hilo2 implements Runnable {
Thread hilo2;
Hilo2() {
hilo2 = new Thread(this, "segundo");
System.out.println("Inicio segundo hilo");
hilo2.start();//Inicia segundo hilo
}

public void run() {
try {
for(int i=0; i<5; i++){
System.out.println((Thread.currentThread()).getName()+" hilo aqui...");
Thread.sleep(1000);
}
} catch (InterruptedException ex) {}
System.out.println("Final del segundo hilo");
}
}

class Hilos1 {
public static void main(String[] args) { //Hilo principal (main)
new Hilo2(); //Segundo hilo (segundo)
try {
for(int i=0; i<5; i++){
System.out.println((Thread.currentThread()).getName()+" hilo aqui...");
Thread.sleep(1000);
}
} catch (InterruptedException ex) {}
}
}


Resultado:

run:
Inicio segundo hilo
main hilo aqui...
segundo hilo aqui...
segundo hilo aqui...
main hilo aqui...
segundo hilo aqui...
main hilo aqui...
main hilo aqui...
segundo hilo aqui...
main hilo aqui...
segundo hilo aqui...
Final del segundo hilo
BUILD SUCCESSFUL (total time: 5 seconds)
·

Llamar a los constructores de una superclase.

Codigo:

//Llamar a los constructores de la superclase.
package javaapplication63;

class a{
a(){
System.out.println("En el constructor de a...");
}
a (String s){
System.out.println("En el constructor String de a...");
System.out.println(s);
}
}

class b extends a{
b(String s){
super(s);
System.out.println("En el constructor String de b...");
System.out.println(s);
}
}

public class JavaApplication63 {
public static void main(String[] args) {
b obj = new b("Hola");
}
}


Resultado:

run:
En el constructor String de a...
Hola
En el constructor String de b...
Hola
BUILD SUCCESSFUL (total time: 1 second)
·

Devolver arrays desde métodos.

Código Java:

//Devolver arrays desde métodos.
package pasomatrizes;

public class PasoMatrizes {

   public static class ArrayFactory {
      public int[] getNewArray() {
         int array[] = {1, 2, 3, 4, 5};
         return array;
      }
   }

   public static void main(String[] args) {
      ArrayFactory af = new ArrayFactory();
      int array[] = af.getNewArray();
      for (int i = 0; i < array.length; i++) {
         System.out.println("Array[" + i + "] = " + array[i]);
      }
   }

}

Resultado:

run:
Array[0] = 1
Array[1] = 2
Array[2] = 3
Array[3] = 4
Array[4] = 5
BUILD SUCCESSFUL (total time: 0 seconds)

Devolver objetos desde métodos.

Código Java:

//Devolver objetos desde métodos.
package pasoobjeto;

class ObjectFactory {
   public CreatedClass getNewObject() {
      return new CreatedClass();
   }
}

class CreatedClass {
   public String tag = "Esta es la etiqueta de datos";
}

public class PasoObjeto {
   public static void main(String[] args) {
      ObjectFactory of = new ObjectFactory();
      CreatedClass cc = of.getNewObject();
      System.out.println(cc.tag);
   }
}


Resultado:

run:
Esta es la etiqueta de datos
BUILD SUCCESSFUL (total time: 0 seconds)

Uso de la palabra clave this.

Codigo:

//Usar la palabra clave this.
package javaapplication60;

class Data{
private String data_string;
Data (String s){
data_string = s;
}

public String getData(){
return data_string;
}

public void printData(){
printer p = new printer();
p.print(this);
}
}

class printer{
void print(Data d){
System.out.println(d.getData());
}
}

public class JavaApplication60 {
public static void main(String[] args){
(new Data("Hola")).printData();
}
}


Resultado:

run:
Hola
BUILD SUCCESSFUL (total time: 0 seconds)
·

Interfaces para herencia múltiple (estructura básica).

Codigo:

//Interfaces para herencia múltiple (estructura básica).
//Uso de las claves: interface e implement.

package main;

interface b{
//codigo
}

interface c{
//codigo
}

class a implements b, c {
//codigo
}

public class Main {
public static void main(String[] args) {
a obj = new a();
}
}
·

Clase interna anónima.

Código Java (ClaseInternaAnonima.java):

package claseinternaanonima;

class a {
    a() {
        (new b() {
            public void print() {
                System.out.println("Hola");
            }
        }).print();
    }
}

class b {}

public class ClaseInternaAnonima {
    public static void main(String[] args) {
        a obj = new a();
    }
}


Resultado:

run:
Hola
BUILD SUCCESSFUL (total time: 0 seconds)

Determinar la clase de un objeto: getClass.

Codigo:

//Determinar la clase de un objeto: getClass.
package clasedelobjeto;

class a{
public void print(){
System.out.println("Aqui esta a...");
}
}

class b extends a{
public void print(){
System.out.println("Aqui esta b...");
}
}

class c extends a{
public void print(){
System.out.println("Aqui esta c...");
}
}

public class ClaseDelObjeto {
public static void main(String[] args) {

a primera = new a(); //objeto de la clase base a
b segunda = new b(); //objeto de la subclase b
c tercera = new c(); //objeto de la subclase c

a ref_a;

ref_a = primera;
System.out.println("La clase ref_a es: "+ref_a.getClass());
ref_a.print();

ref_a = segunda;
System.out.println("La clase ref_a es: "+ref_a.getClass());
ref_a.print();

ref_a = tercera;
System.out.println("La clase ref_a es: "+ref_a.getClass());
ref_a.print();

}
}


Resultado:

run:
La clase ref_a es: class clasedelobjeto.a
Aqui esta a...
La clase ref_a es: class clasedelobjeto.b
Aqui esta b...
La clase ref_a es: class clasedelobjeto.c
Aqui esta c...
BUILD SUCCESSFUL (total time: 1 second)
·

Crear una clase abstracta: abstract.

Codigo:

package claseabstracta;

abstract class a{
abstract String getData();
public void print(){
System.out.println(getData());
}
}

class b extends a{
String getData(){
return "Hola";
}
}

public class JavaApplication69 {
public static void main(String[] args) {
b b1 = new b();
b1.print();
}
}


Resultado:

run:
Hola
BUILD SUCCESSFUL (total time: 0 seconds)
·

Acceso a los miembros sobreescritos: uso de super.

Codigo:

//Acceso a los miembros sobreescritos
package usarsuper;

class animal{
public void breathe(){
System.out.println("Respirar");
}
}

class pez extends animal{
public void breathe(){
System.out.println("Burbujear");
}
public void newbreathe(){
breathe(); //coge el breathe de la subclase "pez"
super.breathe(); //coge el breathe de la clase base "animal"
}
}

public class JavaApplication68 {
public static void main(String[] args) {
System.out.println("Crear un animal...");
animal a = new animal();
a.breathe();
System.out.println("Crear pez...");
pez p = new pez();
p.newbreathe();
}
}


Resultado:

run:
Crear un animal...
Respirar
Crear pez...
Burbujear
Respirar
BUILD SUCCESSFUL (total time: 0 seconds)
·

Cálculo letra del DNI.

Codigo:

package dni1;
import java.util.Scanner;
public class Dni1 {
public static void main(String[] args) {
String letras = "TRWAGMYFPDXBNJZSQVHLCKE";
System.out.println("Introduce DNI sin letra: ");
Scanner leer = new Scanner(System.in);
int dni = Integer.parseInt(leer.next());
int index = dni - (Math.abs(dni/23)*23);
System.out.println("Su letra de DNI es: "+ letras.charAt(index));
}
}

Resultado:

run:
Introduce DNI sin letra:
12345678
Su letra de DNI es: Z
BUILD SUCCESSFUL (total time: 4 seconds)
·

Gestión multiniveles de constructores.

Codigo:

//Gestion Multiniveles de Constructores
package jerarquia2;

class a{
a(){ System.out.println("a"); }
}

class b extends a{
b(){ System.out.println("b"); }
}

class c extends b{
c(){ System.out.println("c"); }
}

class d extends c{
d(){ System.out.println("d"); }
}

//Principal
public class Jerarquia2 {
public static void main(String[] args) {

System.out.println("1- objeto: ");
d objeto = new d();

System.out.println("2- objeto2: ");
b objeto2 = new b();

}
}


Resultado:

run:
1- objeto:
a
b
c
d
2- objeto2:
a
b
BUILD SUCCESSFUL (total time: 1 second)

Multiniveles de herencia. (subclases de subclases).

Codigo:

//Multiniveles de herencia. (subclases de subclases)
package jerarquia;

//nivel 1 (base)
class papel{
public void start(){
System.out.println("Coger tipo puntero...");
}
}

//nivel 2 (pincel)
class pincel extends papel{
public void usarpincel(){
System.out.println("Usar pincel...");
}
}

//nivel 2 (brocha)
class brocha extends papel{
public void usarbrocha(){
System.out.println("Usar brocha...");
}
}

//nivel 3 (escribir con pincel)
class escribir extends pincel{
public void escritura(){
System.out.println("Escribiendo...");
}
}

//nivel 3 (dibujar con pincel)
class dibujar extends pincel{
public void dibujo(){
System.out.println("Dibujando...");
}
}

//nivel 3 (pintar con brocha)
class pintar extends brocha{
public void pinta(){
System.out.println("Pintando...");
}
}

//nivel 3 (colorear con brocha)
class colorear extends brocha{
public void colorea(){
System.out.println("Coloreando...");
}
}

//Principal
public class Jerarquia {
public static void main(String[] args) {

System.out.println("1- ");
escribir e = new escribir();
e.start();
e.usarpincel();
e.escritura();

System.out.println("2- ");
dibujar d = new dibujar();
d.start();
d.usarpincel();
d.dibujo();

System.out.println("3- ");
pintar p = new pintar();
p.start();
p.usarbrocha();
p.pinta();

System.out.println("4- ");
colorear c = new colorear();
c.start();
c.usarbrocha();
c.colorea();
}
}


Resultado:

run:
1-
Coger tipo puntero...
Usar pincel...
Escribiendo...
2-
Coger tipo puntero...
Usar pincel...
Dibujando...
3-
Coger tipo puntero...
Usar brocha...
Pintando...
4-
Coger tipo puntero...
Usar brocha...
Coloreando...
BUILD SUCCESSFUL (total time: 0 seconds)

Crear una subclase usando la herencia.

Código (EjemploSubClase.java):

package ejemplosubclase;

// Clase base
class Vehiculo {
    // Método
    public void arrancar() {
        System.out.println("Arrancar");
    }
}

// Subclase de la clase base
class Coche extends Vehiculo {
    // Método
    public void conducir() {
        System.out.println("Conducir");
    }
}

public class EjemploSubClase {
    public static void main(String[] args) {
        System.out.println("Crear coche...");
        Coche c = new Coche();
        c.arrancar();
        c.conducir();
    }
}


Resultado:

run:
Crear coche...
Arrancar
Conducir
BUILD SUCCESSFUL (total time: 0 seconds)

Math.random: Generar números aleatorios.

Codigo:
package aleatorio1;
public class Aleatorio1 {
public static void main(String[] args) {
int numAleatorio = (int) Math.floor(Math.random()*1000+1);
System.out.println("Nº aleatorio 0-1000: " + numAleatorio);
}
}

Resultado:
run:
Nº aleatorio 0-1000: 577
BUILD SUCCESSFUL (total time: 0 seconds)

Applets 1: Ejecución de una aplicación desde un navegador Web.

Usando el Ide Netbeans 7.1.
1- Creamos nuevo proyecto de tipo "Java Aplication", con nombre "Applet1".
2- Eliminamos el "Applet1.java" y añadimos un "JApplet Form...".
3- En "Source Packages" añadimos un "HTML File..." con nombre "index1".
4- La estructura de nuestro proyecto debe quedar algo parecido a esto:


5- Nos dirigimos al "JApplet1.java" pestaña "Design" y añadimos botones, labels etc... tal y como muestra la siguiente captura:


// Codigo generado automaticamente por Netbeans:
package applet1;
public class JApplet1 extends javax.swing.JApplet {
public void init() {
try {
java.awt.EventQueue.invokeAndWait(new Runnable() {
public void run() {
initComponents();
}
});
} catch (Exception ex) {;}
}
@SuppressWarnings("unchecked")
private void initComponents(){...}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JComboBox jComboBox1;
private javax.swing.JLabel jLabel1;
private javax.swing.JList jList1;
private javax.swing.JProgressBar jProgressBar1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JTextArea jTextArea1;
// End of variables declaration
}

6- Nos dirigimos al "index1.html" y añadimos la siguiente etiqueta:


7- Observamos el codigo index1.html tal y como quedaria:


8- Para ver el resultado desde Netbeans pulsamos Shift + F6
9- Y para ver el resultado desde un navegador web, primero buscamos el archivo "index1.html". En nuestro caso Netbeans nos lo ha ubicado en:
D:\MIS DOCUMENTOS\NetBeansProjects\Applet1\build\classes\index1.html


10- Finalmente le damos a index1.html para ver el resultado final:

Expresiones Regulares II: Ejemplo práctico. Búsqueda de patrones dentro de un texto.

Codigo:

package expresion_regular;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Expresion_regular {
public static void main(String[] args) {

try {

BufferedReader teclado;
teclado = new BufferedReader (new InputStreamReader(System.in));

String texto = "Cuando utilice cart@uchos.es de impresión que no "
+ "de email@mail.tk, es que algunas características impresión de "
+ "los datos del ej. http://blogspot.com volumen restante, estén "
+ "disponibles por 192.168.1.1 usar suministro que no sea de api.";

System.out.println("Inserta expresion regular: ");
String ex_regular = teclado.readLine();

Pattern pat=Pattern.compile(ex_regular);
Matcher mat=pat.matcher(texto);

while(mat.find()){
String aux = mat.group();
System.out.println("Encontrado: " + aux);
}

} catch (IOException ex) {}

}
}


Resultado 1:
run:
Inserta expresion regular:
[0-9]+ (aquí ponemos manualmente la Expresión Regular deseada)
Encontrado: 192
Encontrado: 168
Encontrado: 1
Encontrado: 1
BUILD SUCCESSFUL (total time: 16 seconds)

Resultado 2:
run:
Inserta expresion regular:
\b(?:\d{1,3}\.){3}\d{1,3}\b
Encontrado: 192.168.1.1
BUILD SUCCESSFUL (total time: 2 seconds)

Resultado 3
run:
Inserta expresion regular:
((\w-)+(\.\w+)?)+@\w+\.\w+
Encontrado: cart@uchos.es
Encontrado: email@mail.tk
BUILD SUCCESSFUL (total time: 3 seconds)

Expresiones Regulares I: Tabla de referencia.

Las Expresiones Regulares son un mecanismo muy potente para realizar búsquedas o manipulaciones de cadenas dentro de un texto. Normalmente utilizadas para validación de formularios.

Tabla de referencia para la generación de estas expresiones:

*Caracteres:
x ................... Carácter
x\\ ................. Carácter de barra invertida
\0n ................. Carácter con valor octal 0n (0 <= n <= 7)
\0nn ................ Carácter con valor octal 0nn (0 <= n <= 7)
\0mnn ............... Carácter con valor octal 0mnn (0 <= m <= 3, 0 <= n <= 7)
\xhh ................ Carácter con valor hexadecimal 0xhh
\uhhhh .............. Carácter con valor hexadecimal 0xhhhh
\t .................. Carácter de tabulación ('\u0009')
\n .................. Carácter salto de línea('\u000A')
\r .................. Carácter de retorno de carro ('\u000D')
\f .................. Carácter de avance ('\u000C')
\a .................. Carácter de alerta ('\u0007')
\e .................. Carácter de escape ('\u001B')
\cx ................. Carácter de control correspondiente a x

*Grupo de caracteres:
[abc] ............... "a", "b", o "c" (clase simple)
[^abc] .............. Cualquier carácter excepto "a", "b", o "c" (negación)
[a-zA-Z] ............ de "a" a "z" o de "A" a "Z" (rango)
[a-d[m-p]] .......... "a" a "d", o "m" a "p" través de: [a-DM-p] (unión)
[a-z&&[def]] ........ "D", "E" o "F" (intersección)
[a-z&&[^bc]] ........ "a" a "z", con excepción de "b" y "c": [ad-z] (resta)

*Grupo de caracteres ya predefinidos:
\d .................. Caracteres numéricos [0-9]
\D .................. Cualquier caracter no numérico: [^0-9]
\s .................. Espacio en blanco: [\t\n\x0B\f\r]
\S .................. Cualquier caracter menos espacio: [^\s]
\w .................. Caracteres alfanumericos: [a-zA-Z_0-9]
\W .................. Caracteres no-alfanumericos: [^\w]

*Comparadores de límites:
^ ................... Principio de línea
$ ................... Final de línea
\b .................. Límite de palabra
\B .................. Límite de no-palabra
\A .................. Comienzo de la entrada
\G .................. Final del limite anterior
\z .................. Final de la entrada

*Greedy quantifiers:
X? .................. Una vez o cero
X* .................. Cero o más veces
X+ .................. Una o más veces
X{n} ................ Exactamente n veces
X{n,} ............... Mínimo de n veces
X{n,m} .............. Mínimo de n veces pero con un máximo de m veces

*Reluctant quantifiers:
X?? ................. Una vez o cero
X*? ................. Cero o más veces
X+? ................. Una o más veces
X{n}? ............... Exactamente n veces
X{n,}? .............. Mínimo de n veces
X{n,m}? ............. Mínimo de n veces pero con un máximo de m veces

*Possessive quantifiers:
X?+ ................. Una vez o cero
X*+ ................. Cero o más veces
X++ ................. Una o más veces
X{n}+ ............... Exactamente n veces
X{n,}+ .............. Mínimo de n veces
X{n,m}+ ............. Mínimo de n veces pero con un máximo de m veces

*Operadores lógicos:
XY .................. "X" seguida por "Y"
XIY ................. Ya sea "X" o "Y"
(X) ................. "X" como un grupo de captura

*Referencias anteriores:
\n .................. Cualquiera que sea el grupo enésimo coincidente

*Quotation:
\ ................... Ninguno, pero cita el siguiente carácter
\Q .................. Ninguno, pero cita a todos los caracteres hasta \E
\E .................. Ninguno, pero termina citando iniciado por \Q

*Construcciones especiales (sin captura):
(?:X) ............... X como un grupo sin captura
(?idmsux-idmsux) .... Ninguna, pero con indicadores de coincidencia ON-OFF
(?idmsux-idmsux:X) .. Como grupo sin captura con los indicadores ON-OFF
(?=X) ............... Vía de ancho cero positivo preanálisis
(?!X) ............... Vía de ancho cero anticipado negativo
(?<=X) .............. Vía ancho cero "lookbehind" positivo
(?>X) ............... Como independiente, no captura el grupo

Para puesta en práctica de ese tipo de estas expresiones muy recomendamble entrar en http://www.gskinner.com/RegExr/

Lectura desde teclado: Scanner

Codigo:

package leer_teclado;
import java.util.Scanner;

public class Leer_teclado {
public static void main(String[] args) {
System.out.println("Escribe tu nombre: ");
Scanner leer = new Scanner(System.in);
String nombre = leer.next();
System.out.println("Hola " + nombre);
}
}


Resultado:

run:
Escribe tu nombre:
Juan (aquí ponemos manualmente un nombre y pulsamos enter)
Hola Juan
BUILD SUCCESSFUL (total time: 7 seconds)

Hacer un "ping" a una máquina remota.

package jping;

import java.io.IOException;
import java.net.InetAddress;

public class JPing {
public static void main(String[] args) {
InetAddress ping;
String ip = "192.168.1.10"; // Ip de la máquina remota
try {
ping = InetAddress.getByName(ip);
if(ping.isReachable(5000)){
System.out.println(ip+" - responde!");
}else {
System.out.println(ip+" - no responde!");
}
} catch (IOException ex) { System.out.println(ex); }
}
}

Resultado:

run:
192.168.1.10 - responde!
BUILD SUCCESSFUL (total time: 4 seconds)