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)