Mostrando entradas con la etiqueta java. Mostrar todas las entradas
Mostrando entradas con la etiqueta java. Mostrar todas las entradas

domingo, 8 de mayo de 2022

Creación y lectura de archivo desde java

 Hola a todos, está es una entrada mas al respecto en esta nota, explicare como crear y leer un archivo desde java.

Primero que nada una disculpa por la demora de mis entradas. Siguiendo con lo que nos truje, vamos a nuestro editor de mejor preferencia, en mi caso usare netbeans.

Para ello creamos un nuevo documento que será nuestra toma de decisiones.

Principal.java


package com.diving.inovania;

import java.io.FileWriter;
import java.io.IOException;

/**
 *
 * @author inovania.blogspot.com
 */
public class Principal {
    public static void main(String[] args) {
        Principal app = new Principal();
        app.createFile();
    }
}

El código encargado de la creación y escritura del documento queda de la siguiente manera

public void createFile() {
   FileWriter wr;
     try {
         wr = new FileWriter(path+"filename.txt");
         wr.write("Este es un archivo creado desde java\n");
         wr.write("Continua en\n");
         wr.write("https://inovania.blogspot.com");
         wr.close();
     } catch (IOException e) {
         System.out.println("Ocurrio un error: " + e.getMessage());
     }
}

Pero no siempre estaremos creando y sobre escribiendo el mismo documento. Es decir hay ocasiones en que se requiere abrir un archivo leerlo y agregar algo nuevo o simplemente leerlo. Para ello el siguiente metodo.

public String readFile() {
    Scanner sc;
        StringBuilder sb = new StringBuilder();
    try {
        File f = new File("E:\\Oscar\\blog\\filename.txt");
        sc = new Scanner(f);
        while (sc.hasNextLine()) {
            sb.append(sc.nextLine()).append("\n");
        }
        sc.close();
    } catch (FileNotFoundException e) {
        System.err.println("Erro al leer el archivo: " + e.getMessage());
    }
    return sb.toString();
}

De esta manera tenemos tanto la lectura como escritura del mismo archivo.

Sin mas por el momento me despido, no sin antes pedirles sus comentarios. hasta la proxima.


lunes, 7 de marzo de 2022

Java desde cero

Hola a todos, en esta entrada estaré escribiendo el comienzo de un nuevo tutorial, el cual vamos a ir viendo la creación y ejecución de java desde un editor de texto común hasta las herramientas propias de java.


Para ello es necesario contar con el paquete JRE y JDK, una vez obtenidos continuamos con el editor de texto que deseen y avanzamos.

Comenzamos con un archivo con extensión .java lo llamaremos.

HolaMundo.java


  public class HolaMundo{
  	public static void main(String[] args){
    	System.out.println("Hola Mundo");
    }
  }
  

Una vez que tengamos el archivo continuaremos con cmd posicionándonos en la ubicación del archivo HolaMundo.java ejecutando el siguiente comando.

_>: javac HolaMundo.java

Este comando compila el código en este momento se muestran todos los errores obtenidos durante la compilación, de salir todo bien se estará creando un archivo con el extensión .class.

El siguiente comando a ejecutar.

_>: java HolaMundo

Esta vez sin la extensión java ya que por ahora lo que estaremos ejecutando será el código compilado, de aquí en adelante si se realiza un cambio en el código, se debe de recompilar ejecutando javac seguido de java.






Por el momento es todo, no olvides comentar, que opinas al respecto. al igual que hacerte un seguidor y recibir las notificaciones de las siguientes publicaciones.

martes, 4 de febrero de 2020

Diferencia entre ActionListener, keyListener, MouseListener y focusListener in java

Los eventos action listener, son eventos que se agregan a los diferentes componentes de java, no se confundan con los eventos de mouseListener o keyListener, ya que dichos eventos corresponden a diferentes acciones del usuario.

Un ActionListener, se produce al hacer click sobre el componente, o bien al dar enter siempre y cuando el componente tenga el foco.
--
/*actionListener*/
JMenuItem item = new JMenuItem("salir");
item.addActionCommand("salir");
item.addActionListener(this);

@Override
public void actionPerformed(ActionEvent e ){
   if( e.getActionCommand()=="salir" ){
      JOptionPane.showMessageDialog(null,"Adios");
      System.exit(0);
   }
}

--
Un KeyListener, se ejecuta al precionar una tecla, dependiendo el momento de su ejecucion cambara de metodo interno, tales como
 * KeyTyped(keyEvent e) se ejecuta al presionar y soltar una tecla
 * KeyPressed( keyEvent e ) se ejecuta al presionar una tecla
 * KeyReleased( keyEvent e ) se ejecuta al soltar una tecla

--
        JTextField txt = new JTextField();
        txt.addKeyListener( new KeyListener(){
            @Override
            public void keyTyped(KeyEvent e) {
                System.out.println("keyTyped");
            }
            @Override
            public void keyPressed(KeyEvent e) {
                System.out.println("keyPressed");
            }
            @Override
            public void keyReleased(KeyEvent e) {
                System.out.println("keyReleased");
            }
        });

--

un focusListener, se ejecuta cuando un componente pierde o gana el foco ( es seleccionado o desseleccionado ). sus eventos son:
 * focusGained se ejecuta al recibir o perder el foco
 * focusLost se ejecuta al perder el foco

--
  
        JTextField txt = new JTextField();
        txt.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
                System.out.println("FocusGained");
            }

            @Override
            public void focusLost(FocusEvent e) {
                System.out.println("focusLost");
            }
        });

--

Por ultimo tenemos mouseListener, que como su nombre lo dice, los eventos del mouse, estos eventos se relacionan a las acciones que se ejecutan directamente por el mouse, La descripcion de cada uno de ello lo pueden encontrar en la entrada MouseEvent donde se puedes encontrar mas a detalle el uso del mouseListener.

--
        JTextField txt = new JTextField();
        txt.addMouseListener(new MouseListener() {
            @Override
            public void mouseClicked(MouseEvent e) {
            }

            @Override
            public void mousePressed(MouseEvent e) {
            }

            @Override
            public void mouseReleased(MouseEvent e) {
            }

            @Override
            public void mouseEntered(MouseEvent e) {
            }

            @Override
            public void mouseExited(MouseEvent e) {
            }
        });


--

Sin mas por el momento es todo por hoy, dejen su comentario y nos leemos en la proxima.

martes, 28 de enero de 2020

JMenuBar en java

Un menú siempre es necesario en nuestras aplicaciones ya que nos permiten seleccionar e ir directo a una tarea en particular que realiza nuestra aplicación, en este caso agregar el menubar a nuestra aplicación puede resultar bastante sencillo.


Para ello requerimos de las importaciones de javax.swing.JMenuBar, JMenu, y JMenuItem, correspondientemente.

Sin mas vamos al grano.



--
//clase Menu, para mostrar la implementaicon de un menu 

import javax.swing.JApplet;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;

/**
 *
 * @author oscar martagon
 */
public class Menu extends JApplet{
    JFrame f;
    public void createFrame(){
        f=new JFrame("Inovania.blogspot.com");
        f.setSize(400,400);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        createMenu();
    }
    public void createMenu(){
        JMenu menuPadre = new JMenu("Inicio");
        JMenuItem nuevo = new JMenuItem("Nuevo");
        menuPadre.add(nuevo);
        menuPadre.add(new JMenuItem("Salir"));
        
        JMenuBar mb = new JMenuBar();
        mb.add(menuPadre);
        f.setJMenuBar(mb);
    }
    public static void main(String[] args) {
        Menu m = new Menu();
        m.createFrame();
    }
}


--

Explicando el codigo...

Como ya lo explique en la entrada anterior JFrame en este caso se agrega el método createMenu() en el cual se agrega la linea.

JMenu menuPadre = new JMenu("Inicio");

Nos permite crear el nodo del cual saldran los diferentes submenus o menus items, Con la linea

JMenuItem nuevo = new JMenuItem("Nuevo");
menuPadre.add(nuevo);

Construimos un menu item con el texto de Nuevo y posteriormente se agrega al menuPadre, tambien se puede agregar un submenu o menuItem directamente al menu padre como se ve en la siguiente linea.

menuPadre.add( new JMenuItem("Salir");

Por ultimo se construye el Menu Bar al cual se agrega el menu padre y posteriormente se setea al frame con las lineas.

JMenuBar mb = new JMenuBar();
mb.add( menuPadre );
f.setJMenuBar( mb );

Por el momento es todo, espero te sea de ayuda, posteriormente veremos como agregar eventos al menu.

Espero tus comentarios, nos vemos pronto.

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.

jueves, 23 de enero de 2020

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.

martes, 21 de enero de 2020

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.

lunes, 27 de mayo de 2019

Open Browse width java

Recientemente me vi en la necesidad de agregar un hipervinculo desde un JFrame mediante un JLabel, tras buscar y buscar una solucion me encuentro con la siguiente caracteristica de java.


Desktop:

El cual aparte de poder abrir un un archivo en su programa predeterminado puede mandarnos en este caso a una ruta en especifico de búsqueda en mi caso en chrome.

El código es el siguiente


   try{
      if( Desktop.isDesktopSupported() ){
         Desktop dt = Desktop.getDesktop();
         if( dt.isSupported(Desktop.Action.BROWSE)){
            dt.browse( new URI( "www.google.com" ));
         }
      }
   }catch( IOException | URISyntaxException x ){
      System.err.println( x.getMessage() );
   }


De esta manera al agregar este código en el evento mouseClicked al JLabel, nos abrirá en la direxion espesificada.


Otras opciones de Descktop.


Open file

El código queda de la siguiente manera.


    try{
        if( Desktop.isDesktopSupported() ){
            File file = new File( "archivo.txt");
            Desktop dt = Desktop.getDesktop();
            dt.open( file );
        }
    }catch( IOException ){
        System.err.println( x.getMessage() );
    }

Por el momento es todo.


Espero sus comentarios, nos vemos pronto.