JFrame en java

Hola a todos, espero me tengan algo de paciencia, pues este sera el comienzo de una idea que tengo, tratar de explicar con ejemplos la mayoría de los elementos que componen a java swing comenzando por un lienzo para pintarlos, JFrame.

El JFrame, es un elemento que nos permite agregar en el diversos componentes dejando por un lado la consola de java dando paso al entorno visual o UI de java.

Sin mas vamos al comienzo.




--

//Manejo de JFrame en java

import javax.swing.JFrame;

/**
 *
 * @author oscar martagon
 */
public class Frame extends JFrame{
    public Frame(){
        JFrame f = new JFrame("Inovania.blogspot.com");
        f.setSize(400,400);
        f.setVisible(true);
        f.setLocationRelativeTo(null);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        Frame app = new Frame();
    }
}

--
Lo que estamos haciendo en el código anterior es construir un JFrame con el titulo del blog.

JFrame f = new JFrame("Inovania.blogspot.com");

Un tamaño de 400 por 400.

f.setSize(400,400);

Mostrándolo en el centro de la pantalla.

f.setLocationRelativeTo(null);

Por ultimo agregamos el evento de cierre de la ventana al dar click en la "x" de cierre.

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Cosas que se pueden agregar al JFrame.

Desabilitar el botón de maximizar, para ello solo agregamos la linea.

f.setResizable(false);

Inicializar el JFrame de manera minimizada en la barra de inicio.

f.setExtendedState(1);

Espero les ayude en algo este código, continuare con los demas elementos de JavaSwing mostrando con ejemplos prácticos para su uso... espero sus comentarios y visitas.

hasta la proxima.

Metodo de Ordenamiento en java

Los métodos de ordenamiento nos ayudan a visualizar de manera mas clara un arreglo o lista, ya sea que se requiera de manera ascendente o descendente, en java encontramos tres métodos bastantes conocidos comencemos por el mas básico.

Ordenamiento de burbuja.

Su nombre es básicamente por la manera en como trabaja el algoritmo de ordenamiento ya que se trata de tomar el peso de cada elemento y dejar que de esta manera se vaya pasando hasta que quede ordenado.

El código es el siguiente.

public int[] bubbleSort(int[] n){
   int tmp;
   int t = n.length;
   for( int i = 1; i < t; i ++ ){
        for( int k = t-1; k >= i; k --){
            if( n[k]<n[k-1]){
               tmp=n[k];
               n[k]=n[k-1];
               n[k-1]=tmp;
            }
        }
   }
   return n;
}

La invocacion sera la siguiente
int[] arrInt = {5,6,9,12,48,356,4,1,0,1574};
int[] rtnNumber = bubbleSort(arrInt);
dando como salida
run:
5,6,9,12,48,356,4,1,0,1574
0,1,4,5,6,9,12,48,356,1574
BUILD SUCCESSFUL (total time: 0 seconds)

Como les comentaba hace un momento existen otros dos métodos de ordenamiento muy conocidos entre ellos esta el llamado QickSort:

Basado en la tecnica Divide y Venceras, toma un elemento del arreglo (pivote) dejando los menores a el de un lado mientras que del otro lado los mayores a este. segementando el arreglo hasta que este quede ordenado.

El código es el siguiente.

---

    public void Quicksort(int[] vector, int first, int last) {
        int i = first, j = last;
        int pivote = vector[(first + last) / 2];
        int auxiliar;
        do {
            while (vector[i] < pivote) {
                i++;
            }
            while (vector[j] > pivote) {
                j--;
            }
            if (i <= j) {
                auxiliar = vector[j];
                vector[j] = vector[i];
                vector[i] = auxiliar;
                i++;
                j--;
            }
        } while (i <= j);

        if (first < j) {
            Quicksort(vector, first, j);
        }

        if (last > i) {
            Quicksort(vector, i, last);
        }
    }

---
El llamado sera el siguiente

int[] arr = {6, 5, 1, 3, 8, 4, 9, 7, 12, 45, 16, 83, 128, 0, 45};
Quicksort(arr, 0, arr.length - 1);

Dejando como salida el siguiente resultado
run:
6,5,1,3,8,4,9,7,12,45,16,83,128,0,45,
0,1,3,4,5,6,7,8,9,12,16,45,45,83,128,
BUILD SUCCESSFUL (total time: 0 seconds)

Ya por ultimo tenemos el siguiente método de ordenamiento HeapSort.

Este método se desarrolla de manera recursiva, no estable, consiste en almacenar todo el arreglo o elementos dentro de un vecotr a ordenar formando algo similar a un monticulo, llevando los menores de un lado y pasandolos  de derecha a izquierda en una estructura de tipo arbol.

El codigo es el siguiente

---

    public void fnSortHeap(int arr[], int arr2) {
        int i, o;
        int lCh, rCh, mCh, root, tmp;
        root = (arr2 - 1) / 2;
        for (o = root; o >= 0; o--) {
            for (i = root; i >= 0; i--) {
                lCh = (2 * i) + 1;
                rCh = (2 * i) + 2;
                if ((lCh <= arr2) && (rCh <= arr2)) {
                    if (arr[rCh] >= arr[lCh]) {
                        mCh = rCh;
                    } else {
                        mCh = lCh;
                    }
                } else {
                    if (rCh > arr2) {
                        mCh = lCh;
                    } else {
                        mCh = rCh;
                    }
                }

                if (arr[i] < arr[mCh]) {
                    tmp = arr[i];
                    arr[i] = arr[mCh];
                    arr[mCh] = tmp;
                }
            }
        }
        tmp = arr[0];
        arr[0] = arr[arr2];
        arr[arr2] = tmp;
    }

---
Quedando el llamado de la siguiente manera

int arr[] = {6, 5, 1, 3, 8, 4, 9, 7, 12, 45, 16, 83, 128, 0, 45};
for (i = arr.length; i > 1; i--) {
      app.fnSortHeap(arr, i - 1);
}

Dejando como salida el siguiente resultado
run:
---------------
6,5,1,3,8,4,9,7,12,45,16,83,128,0,45
0,1,3,4,5,6,7,8,9,12,16,45,45,83,128
---------------
BUILD SUCCESSFUL (total time: 0 seconds)

Sin mas por el momento espero esto les aya servido de ayuda en algo, de ser así me gustaria saber de tu experiencia con estos métodos, comparte con tus amigos este blog y no olvides seguirme para estar al día con las siguientes entradas.

Expresiones regulares en java

Las expresiones regulares nos ayudan a buscar desde un numero, signo, palabra o segmentar una cadena según sea el caso.

En javascript, php, python o java, el como invocar una expresión puede variar dependiendo del lenguaje, en este caso hablaremos solo de java.


Comenzando con nuestra clase ExpresionRegular

public class ExpresionRegular{

    public static void main(String[] args) {
    }
}

String cadena = "Lorem ips43um dolor sit amet, conse2342ctetur adipisicing elit. Suscipit voluptatum at ape459/*-5riam voluptas tenetur temporibus vero q321uisquam 23laudantium sint debitis, veniam reprehenderit consequu132ntur autem aut aspernatur? Dolores aperiam praesentium ad.";

De la cadena lorem ipsum la modificaremos tantito. ahora buscaremos solo las palabras que contengan números, con la siguiente expresión.

/*Create by Inovania.blogspot.com*/
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ExpresionRegular{

    public static void main(String[] args) {
     String cadena = "Lorem ips43um dolor sit amet, conse2342ctetur adipisicing elit. Suscipit voluptatum at ape459/*-5riam voluptas tenetur temporibus vero q321uisquam 23laudantium sint debitis, veniam reprehenderit consequu132ntur autem aut aspernatur? Dolores aperiam praesentium ad.";
     Pattern p = Pattern.compile("([a-z]+[0-9]+[a-z]+)" );
     Matcher m = p.matcher(cadena);

        while( m.find() ){
            System.out.println( m.group() );
        }
    }
}

Dandonos como resultado lo siguiente.

ips43um
conse2342ctetur
q321uisquam
consequu132ntur

Dejando así las palabras que contengan letras + numeros + letras ignorando el resto.


Sin mas por el momento me despido como siempre , quedando en espera de sus comentarios, dudas o sugerencias.

No olvides recomendarme.
hasta pronto.