Home | Java |C # |SQL |Manuales |Videos |
9

Ejemplos de JFreeChart – Parte 2

charts-excel-2007 En esta oportunidad les traigo otro ejemplo mas …. se trata de la gráfica PieChart que al igual que los anteriores ejemplos si se va a colocar en un proyecto aparte necesita que agreguemos las librerías que previamente configuramos.

Todos estos gráficos se colocan en un JFrame ….si alguien sabe como colocarlo dentro de un JInternalFrame le agradecería que me apoye con esa información. Hay que tener en cuenta que los métodos que estoy usando no son todos ….hay una variedad de métodos para diseñar mejor nuestro gráfico , pero ya depende de cada uno explorar esta parte y descubrir lo que JFreeChart puede y también lo que no soporta.

Una recomendación final para poder usar mejor los métodos es necesaria la documentación , esta se genera a la hora de instalar las librerías … pero yo no pude hacerla trate de hacerla con el ant de apache pero no me funcionó ( si alguien sabe como generar la documentación de JFreeChart le agradeceré que me brinde esa información para actualizar la entrada de instalación y de paso que me ayude a mí). SIn mas que decir vamos a empezar con una clase …yo la he llamado PieChart :

  • Esta clase así como en el anterior ejemplo la hacemos heredar de la clase ApplicationFrame
    public class PieChart extends ApplicationFrame

  • Después de esto vamos a importar las siguientes librerías :
    import java.awt.Color;
    import javax.swing.JPanel;
    import org.jfree.chart.ChartFactory;
    import org.jfree.chart.ChartPanel;
    import org.jfree.chart.JFreeChart;
    import org.jfree.chart.plot.PiePlot;
    import org.jfree.data.general.DefaultPieDataset;
    import org.jfree.data.general.PieDataset;
    import org.jfree.ui.ApplicationFrame;

  • Luego de esto vamos a construir el método constructor
        public PieChart(String titulo)
    {
    super(titulo);
    this.setContentPane(crearDemoPanel());
    }

  • Vamos a crear el método crearDataSet en el que vamos a crear la data del gráfico ; este método lo podemos mejorar colocando un parámetro el cual nos envíe la data a colocar :
        private static PieDataset crearDataSet()
    {
    DefaultPieDataset data=new DefaultPieDataset();
    data.setValue("Uno",new Double(43.2));
    data.setValue("Dos",new Double(10.0));
    data.setValue("Tres",new Double(27.5));
    data.setValue("Cuatro",new Double(17.5));
    data.setValue("Cinco",new Double(11.0));
    data.setValue("Seis",new Double(19.4));
    return data;
    }

  • Luego algo simple,hacemos el método crearChart ( hay que observar que nos pide un parámetro y devuelve un objeto del tipo JFreeChart) , este método lo que hace es crear el frame donde irá el gráfico ( si le en vez de ChartFactory.createPieChart colocamos ChartFactory.createPieChart3D tendremos un gráfico en 3D)  :
        private static JFreeChart crearChart(PieDataset data)
    {
    JFreeChart chart = ChartFactory.createPieChart(
    "Demo de PieChart", //Nombre del gráfico
    data, //data
    true, //Leyenda
    true,
    false);
    //Color de la ventana
    chart.setBackgroundPaint(Color.ORANGE);
    PiePlot plot = (PiePlot)chart.getPlot();
    //Color de las etiquetas
    plot.setLabelBackgroundPaint(Color.ORANGE);
    //Color de el fondo del gráfico
    plot.setBackgroundPaint(Color.WHITE);
    plot.setNoDataMessage("No hay data");

    return chart;
    }

  • Vamos a crear el último método ..este es de dos líneas nada más
        public static JPanel crearDemoPanel()
    {
    JFreeChart chart=crearChart(crearDataSet());
    return new ChartPanel(chart);
    }

  • Y por último en la clase main :
    public class Main
    {
    public static void main(String[] args)
    {
    PieChart demo2= new PieChart("PieChartDemo02");
    demo2.pack();
    RefineryUtilities.centerFrameOnScreen(demo2);
    demo2.setVisible(true);
    }
    }

  • Finalmente este será nuestro resultado : image
  • El ejemplo lo podremos descargar desde aquí :
    btn_6 
... Leer más ...
20

Ejemplos de JFreeChart – Parte 1

image Después de instalar y hacer las configuraciones de la librería jfreechart ahora procedemos a ver los diferentes tipos de gráficos que podemos crear con esta librería ; para ello colocaré algunos ejemplos que se han encontrado en la librería demo de JFreeChart y en la web.

Antes que nada vamos a crear un nuevo proyecto con el NetBeans → luego agregaremos las librerías que anteriormente habíamos configurado a nuestro proyecto , para esto : clic derecho en la carpeta  Libraries → Add Library y agregamos las librerías JFreeChart :

image

Hecho esto ya podemos empezar a crear nuestros gráficos ( esto lo vamos a hacer para cada proyecto en el que queremos usar la librería JFreeChart ).

GRÁFICO BARCHART
  • Creamos una clase y hacemos que herede de la clase Application frame , para ello debemos importar la librería : import org.jfree.ui.ApplicationFrame ; esto debe quedar así :
    public class BartChart extends ApplicationFrame


  • Hecho esto vamos a importar las siguientes librerías :
    import java.awt.Color;
    import java.awt.Dimension;
    import java.awt.GradientPaint;
    import org.jfree.chart.ChartFactory;
    import org.jfree.chart.ChartPanel;
    import org.jfree.chart.JFreeChart;
    import org.jfree.chart.axis.CategoryAxis;
    import org.jfree.chart.axis.CategoryLabelPositions;
    import org.jfree.chart.axis.NumberAxis;
    import org.jfree.chart.plot.CategoryPlot;
    import org.jfree.chart.plot.CategoryPlot;
    import org.jfree.chart.plot.PlotOrientation;
    import org.jfree.chart.renderer.category.BarRenderer;
    import org.jfree.data.category.CategoryDataset;
    import org.jfree.data.category.DefaultCategoryDataset;
    import org.jfree.ui.ApplicationFrame;



  • Vamos a crear nuestro método constructor :

        public BartChart(String title)
    {
    super(title);
    CategoryDataset dataset= crearDataset();
    JFreeChart chart=crearChart(dataset);
    ChartPanel panel = new ChartPanel(chart,false);
    panel.setPreferredSize(new Dimension(700,500));
    this.setContentPane(panel);
    }



  • Hecho esto NetBeans nos pedirá que creemos dos métodos : crearDataset y crearChart que son métodos propios que nosotros crearemos y que mas adelante iremos completando :

        private static CategoryDataset crearDataset()
    {
    ........
    ........
    return dataset;
    }

    private static JFreeChart crearChart(CategoryDataset data)
    {
    ........
    ........
    return chart;
    }



  • Ahora vamos a llenar nuestro método crearDataset :

        private static CategoryDataset crearDataset()
    {
    //Nombre de las filas
    String serie1 ="Primero";
    String serie2 ="Segundo";
    String serie3 ="Tercero";
    //Nombre de las columnas
    String categoria1="Categoria1";
    String categoria2="Categoria2";
    String categoria3="Categoria3";
    String categoria4="Categoria4";
    String categoria5="Categoria5";

    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    //Aquí vamos a llenar nuestra data
    //pero esta data la podemos pasar por parámetros
    dataset.addValue(1.0, serie1,categoria1);
    dataset.addValue(4.0, serie1,categoria2);
    dataset.addValue(3.0, serie1,categoria3);
    dataset.addValue(5.0, serie1,categoria4);
    dataset.addValue(5.0, serie1,categoria5);

    dataset.addValue(5.0, serie2,categoria1);
    dataset.addValue(7.0, serie2,categoria2);
    dataset.addValue(6.0, serie2,categoria3);
    dataset.addValue(8.0, serie2,categoria4);
    dataset.addValue(4.0, serie2,categoria5);

    dataset.addValue(4.0, serie3,categoria1);
    dataset.addValue(3.0, serie3,categoria2);
    dataset.addValue(2.0, serie3,categoria3);
    dataset.addValue(3.0, serie3,categoria4);
    dataset.addValue(6.0, serie3,categoria5);

    dataset.addValue(1.0, serie1,categoria1);
    dataset.addValue(4.0, serie1,categoria2);
    dataset.addValue(3.0, serie1,categoria3);
    dataset.addValue(5.0, serie1,categoria4);
    dataset.addValue(5.0, serie1,categoria5);
    return dataset;
    }



  • Vamos a llenar el siguiente método, espero que los comentarios sean claros (si se desea cambiar la dirección de las barras debemos colocar PlotOrientation.VERTICAL por la que se encuentra en el ejemplo ) : 

        private static JFreeChart crearChart(CategoryDataset data)
    {
    JFreeChart chart= ChartFactory.createBarChart(
    "Demo de BartChart", //Nombre de la gráfica
    "Categorías", //Nombre del eje Horizontal
    "Valores", //Nombre del eje vertical
    data, //Data
    PlotOrientation.HORIZONTAL, //Orientación
    true, //Incluir leyenda
    true, //Información al pasar el mouse
    true); //URls
    //Dar color al fondo del panel
    chart.setBackgroundPaint(Color.ORANGE);
    //Dar color a cada categoria
    CategoryPlot plot =(CategoryPlot) chart.getPlot();
    plot.setBackgroundPaint(Color.BLUE);
    //Color del fondo del gráfico
    plot.setBackgroundPaint(Color.WHITE);
    //Lineas divisorias
    plot.setDomainGridlinesVisible(true);
    plot.setRangeGridlinePaint(Color.BLACK);
    //Calculo de los valores en el eje x
    final NumberAxis rangeAxis=(NumberAxis) plot.getRangeAxis();
    rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());

    BarRenderer renderer = (BarRenderer) plot.getRenderer();
    renderer.setDrawBarOutline(false);
    //Dar color a cada barra
    GradientPaint gp0= new GradientPaint(0.0f,0.0f,Color.blue,0.0f,0.0f,new Color(0,0,64));
    GradientPaint gp1= new GradientPaint(0.0f,0.0f,Color.green,0.0f,0.0f,new Color(0,64,0));
    GradientPaint gp2= new GradientPaint(0.0f,0.0f,Color.red,0.0f,0.0f,new Color(64,0,0));
    renderer.setSeriesPaint(0,gp0);
    renderer.setSeriesPaint(1,gp1);
    renderer.setSeriesPaint(2,gp2);

    CategoryAxis domainAxis = plot.getDomainAxis();
    domainAxis.setCategoryLabelPositions(
    CategoryLabelPositions.createUpRotationLabelPositions(Math.PI/6.0));
    return chart;
    }



  • Finalmente en nuestra clase main escribiremos lo siguiente :

    import org.jfree.ui.RefineryUtilities;
    public class Main
    {
    public static void main(String[] args)
    {
    BartChart demo1 = new BartChart("BarChartDemo01");
    demo1.pack();
    RefineryUtilities.centerFrameOnScreen(demo1);
    demo1.setVisible(true);
    }
    }



  • Este es el resultado final :

    image




  • El ejemplo lo pueden descargar de aquí :



btn_6

... Leer más ...
10

Tablas y gráficos dinámicas en Excel 2007

chart

Una tabla dinámica es una tabla interactiva que contiene campos , los que se usan para resumir y analizar atendiendo a varios criterios de agrupación,representado como una tabla de doble entrada que nos facilita la interpretación de dichos datos. Es dinámica porque nos permite ir obteniendo diferentes totales, filtrando datos, cambiando la presentación de los datos, visualizando o no los datos origen, etc. La tabla dinámica se puede actualiza conforme se vayan actualizando los datos de la tabla origen. A partir de esta tabla nosotros podemos crear un gráfico dinámico el cual al igual que la tabal dinámica se relaciona con los datos  a propia tabla dinámica ; es decir si se modifican los datos en cualquiera de los lados el  gráfico también se modifica. Sin mas preámbulo vamos a ver como crear una tabla dinámica :

  • Para empezar debemos contar con una tabla simple como esta (obviamente puede tener mas datos)  :image
  • El siguiente paso es seleccionar la tabla CTTRL + E ( o simplemente dejar el cursor dentro de la tabla ) y nos vamos a  Insertar y elegimos tabla dinámica ( ojo que también podemos elegir crear un gráfico dinámico , pero eso lo vamos a hacer luego) : image
  • Hecho esto nos saldrá una ventana en la que vemos que toda la tabla origen ha sido seleccionada ; en esta ventana podremos dar la opción de colocar la tabla dinámica en la actual hoja de trabajo o sino podemos colocarla en una nueva : image
  • Hecho esto, se creará una nueva hoja como la que se muestra :image
  • Ahora solo tenemos que agregar un check a las cabeceras que queremos aparezcan en la tabla dinámica , y veremos como se irá creando la tabla :image
  • Podemos usar la pestaña de opciones de la tabla dinámica para realizar múltiples opciones como la de crear un gráfico dinámico ,para ello hacemos clic en la tabla dinámica y automáticamente aparecerá la opción en  la parte superior  :image
  • Hacemos clic en gráficos dinámicos y automáticamente se creará nuestro gráfico dinámico (elegimos el tipo de gráfico que deseamos usar): image
  • Y ya tendremos nuestro gráfico dinámico , el cual podremos actualizar moviendo los datos de el origen y luego actualizamos :image
  • Podemos usar la pestaña del gráfico así como la pestaña presentación para darle una mejor presentación a nuestro gráfico : image image
  • Podemos guiarnos mejor con este video :

PARA EXCELL 2007

 

PARA EXCELL 2003

... Leer más ...
1

Cambiar la ubicación la carpeta de favoritos en IE y Firefox

favorite_user Cuando instalamos Firefox , IE o Google Chrome en nuestro PC, estos crean automáticamente perfiles predeterminados para su navegador.
Estas carpeta contiene toda la información relacionada con el navegador : Para firefox (marcadores, historial de navegación, extensiones instaladas, etc.) , IE (favoritos), etc. El inconveniente de esta carpeta es que se encuentra en la partición donde está el sistema operativo .Si por algún problema no pudiéramos acceder al sistema operativo, perderíamos toda esta información.
Para evitar esta pérdida de datos ( que en muchos casos son valiosos ) modificaremos el lugar donde se guardan todos estos marcadores , para ello tenemos que tener en cuenta el navegador que usamos :

I.- PARA FIREFOX
  1. MOVIENDO LA CARPETA DE LOS FAVORITOS :
    • Antes que nada debemos mostrar los archivos ocultos , esto depende del sistema operativo en el que nos encontremos  :
    1. En Xp es simple : Abrimos cualquier carpeta → Herramientas → Opciones de carpeta → Nos vamos a la pestaña Ver y seleccionamos la opción de mostrar archivos , carpetas y unidades ocultas.
    2. Windows Vista y Windows 7 : no traen por defecto la barra de herramientas así que abrimos cualquier carpeta  nos vamos a Organizar → Diseño y le damos check a la barra de menús y hacemos el punto anterior.
    3. Para Linux : es algo similar  , abrimos la carpeta Home → nos vamos a Ver → y activamos la opción para ver las carpetas ocultas.
    • Ahora vamos a mover el contenido de la carpeta por defecto a una nueva ubicación que hemos creado :
    1. Para XP : C:\Documents and Settings\NOMBRE_DE_USUARIO\ApplicationData\Mozilla \Firefox\Profiles
    2. Para Windows 7 y Vista : C:\users\NOMBRE_DE_USUARIO\ApplicationData\Local\Mozilla \Firefox\Profiles
    3. Para Linux : /home/ NOMBRE_DE_USUARIO/.mozilla/firefox/
    • En esta carpeta encontraremos una carpeta con el siguiente nombre : xxxx.default ; es esta carpeta la que vamos a mover pues esta representa el perfil por defecto que Firefox crea al momento de la instalación (copiamos esta carpeta a una nueva dirección) . image
  2. CREANDO UN NUEVO PERFIL :
    • Nos aseguramos de cerrar todas las ventanas de Firefox ( para ello Abrimos el administrador de tareas) , vamos a la pestaña Procesos y buscamos aquellos procesos que digan firefox.exe los seleccionamos y pulsamos terminar proceso .
    • Ahora debemos abrir el editor de perfiles , para lo cual hay varias opciones según el sistema operativo en que nos encontremos :
    1. Para XP : Menú →  Inicio → Ejecutar →  firefox.exe ––profilemanager (son dos “-” antes de profilemanager)
    2. Para Windows Vista y Windows 7 : En la barra de búsqueda del menú inicio escribimos firefox.exe -–profilemanager
    3. Para cualquier distro de Linux : Abrimos el terminal → firefox –-profilemanager
    • Nos saldrá la siguiente ventana :image
    • Es aquí donde crearemos un perfil ; para ellos hacemos clic en crear perfil y nos saldrá una ventana en la cual le damos Siguiente .
    • A continuación colocaremos el nombre de nuestro perfil , elegimos la ubicación de nuestra carpeta ( La que elegimos en el paso anterior) y le damos clic en finalizar :image
    • Hecho esto ya tenemos nuestra perfil creado :image
    • Ahora solo nos queda seleccionar el perfil “default” y eliminarlo.
II.- PARA IEXPLORER
  1. Para Internet Explorer es aún mas sencillo, primero vamos a crear una carpeta llamada favoritos en la unidad que queramos.
  2. Ahora nos ubicamos en la carpeta por defecto → Clic derecho → Ubicación → Mover y seleccionamos la carpeta que habíamos creado anteriormente :image
  3. Y listo eso es todo .. ahora tenemos nuestros favoritos en una unidad diferente.
numcommentsR

No es recomendable usar unidades externas (como USB) como unidades para guardar os favoritos , temas , etc. , se debe elegir como unidad a un disco duro interno.

... Leer más ...
23

Como Programar Java – Deitel & Deitel

Bueno aquí les dejo los links para que puedan descargar el libro de Como Programar Java de Deitel & Deitel ; estos están divididos en 3 partes las cuales lo pueden descargar de mi SkyDrive haciendo clic en el siguiente ícono  :

 

 

El libro contiene los siguientes capítulos :

  • CAP 00 : PREFACIO
  • CAP 01 : INTRODUCCIÓN A LAS COMPUTADORAS
  • CAP 02 : INTRODUCCIÓN A LAS APLICACIONES EN JAVA
  • CAP 03 : INTRODUCCIÓN A LOS APPLETS
  • CAP 04 : INSTRUCCIONES DE CONTROL - PARTE 01
  • CAP 05 : INSTRUCCIONES DE CONTROL - PARTE 02
  • CAP 06 : MÉTODOS
  • CAP 07 : ARREGLOS
  • CAP 08 : PROGRAMACION BASADA EN OBJETOS
  • CAP 09 : POO
  • CAP 10 : POLIMORFISMO
  • CAP 11 : CADENAS Y CARACTERES
  • CAP 12 : GRAFICOS Y JAVA 2D
  • CAP 13 : GUI - PARTE 01
  • CAP 14 : GUI - PARTE 02
  • CAP 15 : MANEJO DE EXCEPCIONES
  • CAP 16 : SUBPROCESAMIENTO MULTIPLE
  • CAP 17 : ARCHIVOS Y FLUJOS
  • CAP 18 : REDES
  • CAP 19 : IMAGENES Y SONIDOS EN LOS APPLETS
  • CAP 20 : ESTRUCTURA DE DATOS
  • CAP 21 : PAQUETES
  • CAP 22 : COLEECCIONES
  • CAP 23 : CONECTIVIDAD A BASES DE DATOS
  • CAP 24 : SERVLETS
  • CAP 25 : JSP
  • CAP 26 : PARTE FINAL

ACTUALIZACIÓN : Gracias a un mensaje que me llegó a mi correo de Génesis Cabrera , pues me indicó que existe en internet la 7ma Edición y esta disponible en : taringa en donde la podrán descargar . Lo interesante de esto es que las páginas son a full color no escaneadas , es decir la calidad de la imagen es muy buena …jejeje lo único malo =’( es que está en ingles .

image

... Leer más ...
48

Instalación de JFreeChart

partition El Proyecto JFreeChart que vio la luz en el año 2000 es una librería de código abierto (Open Source) para Java, que permite crear diagramas de forma práctica y sencilla. Con JFreeChart podremos hacer diferentes tipos de gráficos que van desde los tipos comunes tales como gráficos circulares , gráficos de barras , áreas , gráficos de línea , histogramas , diagramas de Gantt y más específicos y menos frecuentemente utilizados como tipos Candlestick , Viento y Wafer Map . Para mas información sobre esto revisar la documentación Javadoc de las clases JFreeChart y ChartFactory.

I.- REQUISITOS

Es necesario descargar descargar el paquete JFreeChart ; opcionalmente se recomienda descargar también el paquete JCommon. Aunque una versión parcial del mismo ya viene incluido dentro de JFreeChart.

II- CONFIGURACIÓN DE EL JFREECHART Y EL JCOMMON

A continuación iniciaremos los pasos para poder configurar JFreeChart en la IDE NetBeans :

  1. Una vez que descargamos el paquete JFreeChart  y el paquete JCommon lo descomprimimos en un directorio de la PC .image
  2. Ahora abriremos el NetBeans  para configurar las librerías de JFreeChart y JCommon  , por lo tanto en NetBeans nos vamos al menú Tools y Seleccionamos Libraries :image
  3. Hacemos clic en New Library y escribimos “JCommon-1.0.16” como nombre de la librería luego iremos a  la pestaña Classpath → Add Jar/Folder y luego buscamos la dirección del JCommon descargado anteriormente y seleccionamos el archivo JCommon-1.0.16.jar :image image
  4. Hacemos lo mismo con el jar que descargamos del JfreeChart , OJo que el jar que seleccionamos en este caso es el de la carpeta lib .image
  5. Hecho esto ya tenemos configurado las librerías de JFreechart y JCommon en el NetBeans ; hora ya podremos generar un gráfico .
numcommentsAM OBSERVACIÓN : Hay que tener en cuenta que solo hemos agregado los JAR mas no hemos generado la documentación de los archivos que hemos colocado en las librerías, una forma es mediante el archivo ant que ofrece apache pero no lo coloco porque aún estoy revisándolo, cuando me corra actualizaré el blog o si alguien sabe como hacerlo(generar el javadoc) le agradecería me apoye con la info.

III.- CREANDO UN GRÁFICO EN NETBEANS USANDO JFREECHART

  • Creamos un nuevo proyecto , para ello vamos al menú File → New Projct → Java Application y dejamos el Create Main Class activado para que nos pueda generar la clase main (esto no es indispensable pues se puede colocar la generación de los gráficos en una clase aparte – solo que para efectos del ejemplo lo vamos a hacer así – )
  • Ahora vamos a agregar las librerías que hemos agregado anteriormente a este nuevo proyecto , para ello vamos a la pestaña Projects → En el nodo Libraries → Clic derecho add Library y seleccionamos las librerías JFreeChart y jCommon .image
  • Y ahora en la clase Main colocaremos lo siguiente :
    package jfreechart;

    import org.jfree.chart.ChartFactory;
    import org.jfree.chart.ChartFrame;
    import org.jfree.chart.JFreeChart;
    import org.jfree.data.general.DefaultPieDataset;

    public class Main
    {
    public static void main(String[] args)
    {
    //Crear un dataset
    DefaultPieDataset data = new DefaultPieDataset();
    data.setValue("Categría 1",43.2);
    data.setValue("Categría 2",27.9);
    data.setValue("Categría 3",79.5);
    //Creamos un Chart
    JFreeChart chart = ChartFactory.createPieChart(
    "Ejemplo de JFreeChart", //Títrulo del gráfico
    data,
    true,//Leyenda
    true,//ToolTips
    true);
    //Creamos una especie de frame y mostramos el JFreeChart en él
    //Este constructor nos pide el título del Chart y el chart creado
    ChartFrame frame=new ChartFrame("Primer Chart para javax0711",chart);
    frame.pack();
    frame.setVisible(true);
    }
    }



  • Compilamos , ejecutamos la aplicación y listo ya tenemos nuestro primer gráfico generadoimage

... Leer más ...
3

Macros en Excel

Sin título Bueno ahora vamos a tomar uno de los tantos cursos publicados en aulaclic.com el cual se recomienda porque y aquí podrás encontrar excelente material .

Cuando trabajamos con un libro personalizado, es decir, que nos hemos definido con una serie de características específicas como puedan ser el tipo de letra, el color de ciertas celdas, los formatos de los cálculos y características similares, perdemos mucho tiempo en formatear todo el libro si disponemos de muchas hojas.

Con las macros lo que se pretende es automatizar varias tareas y fusionarlas en una sola, añadiendo por ejemplo un botón en nuestro libro que al pulsar sobre él realice todas esas tareas.

La forma más fácil e intuitiva de crear macros es crearlas mediante el grabador de macros del que dispone Excel.

Este grabador de macros te permite grabar las acciones deseadas que posteriormente las traduce a instrucciones en VBA, las cuales podemos modificar posteriormente si tenemos conocimientos de programación.

 

Para grabar una macro debemos acceder a la pestaña Vista y despliega el submenú Macros y dentro de este submenu seleccionar la opción Grabar macro...

Además de esta opción en el menú podemos encontrar las siguientes opciones:

Ver Macros... - Donde accedemos a un listado de las macros creadas en ese libro.

Usar referencias relativas - Con esta opcion utilizaremos referencias reativas para que las macros se graben con acciones relativas a la celda inicial seleccionada.

 

Al seleccionar la opción Grabar macro..., lo primero que vemos es el cuadro de diálogo Grabar macro donde podemos dar un nombre a la macro (no está permitido insertar espacios en blanco en el nombre de la macro).

Podemos asignarle un Método abreviado: mediante la combinación de las tecla CTRL + "una tecla del teclado". El problema está en encontrar una combinación que no utilice ya Excel.

En Guardar macro en: podemos seleccionar guardar la macro en el libro activo, en el libro de macros personal o en otro libro.

En Descripción: podemos describir cuál es el cometido de la macro o cualquier otro dato que creamos conveniente.

Para comenzar la grabación de la macro pulsamos el botón Aceptar y a continuación, si nos fijamos en la barra de estado, encontraremos este botón en la barra de estado  donde tenemos la opción de detener la grabación.

A partir de entonces debemos realizar las acciones que queramos grabar, es conveniente no seleccionar ninguna celda a partir de la grabación, ya que si seleccionamos alguna celda posteriormente, cuando ejecutemos la macro, la selección nos puede ocasionar problemas de celdas fuera de rango.

Una vez concluidas las acciones que queremos grabar, presionamos sobre el botón Detener  de la barra de estado, o accediendo al menú de Macros y haciendo clic en .

... Leer más ...
1

Activar el menú de Ubuntu con la tecla de Windows

ubuntu-keys-laptop-924 Quizás a la mayoría de gente como yo que recién nos estamos iniciando en el software libre ( es nuestra primera vez ]:) jejeje ) , nos cuesta mucho adaptarnos , ya que si en Windows queríamos ir al menu inicio pues solo era cuestión de presionar una tecla y ya estábamos en el menú; en Ubuntu esto no esta configurado por defecto , entonces habría que configurarlo de la siguiente manera :
  • Vamos a Sistemas → Preferencias → Combinaciones de teclas ().

  • Una vez allí buscamos la acción : Mostrar el menú del panel ; le hacemos clic y a continuación presionamos la tecla de Windows ; y esta automáticamente se asignará.Nos quedará algo así :

... Leer más ...
12

La Clase String

java_programmers_brain_screensaver_preview La clase String representa una cadena de caracteres. Todos los literales de la cadena tales como “abc” son implementados como instancias de ésta clase.
La clase String incluye métodos que permiten examinar los caracteres individuales de una cadena para compararlos, ubicarlos extraerlos como sub cadenas y para crear copias de una cadena convirtiendo todos sus caracteres a mayúsculas o minúsculas.
Java provee un soporte especial para la concatenación (unión) de cadenas con el operador (+). y para convertir otros objetos a cadenas.La concatenación de cadenas es implementada a través de la clase StringBuffer y su método append(). Las conversiones son implementadas a través del método toString() definido en la clase Object la cual es heredada por todas las clases en Java.

I.- PARA TENER EN CUENTA :
  1. La clase String pertenece al paquete java.lang.
  2. Existen diferentes formas para crear objetos String como las siguientes :
    • String str =”abc”;
    • char str[] = {‘a’,’b’,’c’};  //arreglo de caracteres
    • String str = new String (“abc”) ;  //objeto con valor inicial “abc”

  3. El lenguaje java proporciona el operador “+” para concatenar (unir) objetos String.

  4. Un objeto String representa una cadena de caracteres no modificable;por lo tanto, una operación como convertir a mayúsculas o minúsculas no modificará el objeto original sino que devolverá un nuevo objeto con la cadena resultante de esa operación el cual deberá ser guardado en otro objeto string.
II.- JERARQUÍA DE CLASES
image
III.- MÉTODOS MAS IMPORTANTES
  1. String (String valor) .- Se usa cuando se desea crear una cadena de caracteres :
    • String cadena = “Hola”
    • String cadena = new String (“Hola”); //Constructor de la clase String


  2. cadena.concat(string txt) .- Devuelve como resultado un nuevo objeto String resultado de concatenar dos cadena :

  3. String cadena = “Hola”         
    String result= cadena.concat(" Mundo");//El resultado será Hola mundo

  4. cadena.compareTo(String otra cadena) .- Compara lexicográficamente la cadena con otra cadena , esta comparación es caracter por caracter  teniendo en cuenta que las mayúsculas son mayores que las minúsculas – esto es de acuerdo al código ASCII o UNICODE – según esto devuelve :


    • < 0 : si cadena < otra cadena
    • = 0 : si cadena = otra cadena
    • > 0 : si cadena > otra cadena
    • Ejemplo :
    • JUAN > juan
    • Juan > Carlos
    • JUAN > JUAn
    • abcde > abcdefg

  5. cadena.toIgnoreCase(String otra cadena) .- Hace lo mismo que compareTo pero con la única diferencia que no se hace diferencia entre mayúsculas y minúsculas ; es decir : JUAN = juan
  6. cadena.length() .- Devuelve la longitud o número de caracteres de la cadena :

    String cad="Hola Mundo";
    int cant = cad.length();// El valor de cant será 10
  7. cadena.toLowerCase() .- Convierte a minúsculas las letras mayúsculas de la cadena
  8. cadena.toUpperCase().- Convierte en mayúsculas las letras minúsculas de la cadena.


    String cad1="Esto Es Una Prueba";
    String cad2=cad1.toUpperCase();//cad2 será igual a : ESTO ES UNA PRUEBA.

  9. cadena.trim () .- Elimina los espacios en blanco que puedan haber al principio o al final de la cadena.


    String cad1="     Esto Es Una Prueba   ";
    String cad2=cad1.toLowerCase();//cad2=Esto Es Una Prueba.

IV.- MÉTODOS

CONSTRUCTORES
Constructor
Descripción
String( )
Crea un nuevo objeto String vacío sin caracteres.
String (byte[ ] bytes)
Crea un nuevo objeto String inicializado con los caracteres equivalentes a cada número guardado en el arreglo de bytes.
String (char[ ] value)
Crea un nuevo objeto String inicializado con los caracteres contenidos en el arreglo dado como parámetro.
String (String cadena)
Crea un nuevo objeto String inicializado con el valor dado como parámetro.
MÉTODOS
Tipo de retorno
Método
Descripción
char
charAt(int index)
Retorna el carácter correspondiente al índice dado como parámetro.
int
compareTo(String otraCadena)
Retorna como entero el resultado de la comparación entre la cadena que lo llama con otraCadena. Si el parámetro devuelto es "0" significa que las dos cadenas son iguales; realizándose la comparación carácter con carácter diferenciándose las mayúsculas con las minúsculas.
int
compareToIgnoreCase(String otraCadena)
Retorna como entero el resultado de la comparación de la cadena que lo llama con otraCadena. Si éste entero es 0 significa que ambas cadenas son iguales; siendo la comparación carácter con carácter pero ignorando la diferencias entre mayúsculas y minúsculas.
String
concat(String otraCadena)
Retorna el resultado de la concatenación de la cadena con otraCadena dada como parámetro.
boolean
equals(Object otroObjeto )
Retorna true si la cadena que lo llama es igual al objeto enviado como parámetro.
boolean
equalsignoreCase(String otraCadena)
Retorna true si la cadena que lo llama es igual a la cadena dad  como parámetro ignorando las diferencias entre mayúsculas y minúsculas.
int
indexOf (String cad)
Retorna la posición de la primera ocurrencia encontrada de la cadena dada como parámetro dentro de la cadena que llama al método.
int
indexOf (String cad, int ini)
Retorna la posición de la primera ocurrencia encontrada de la cadena dada como parámetro pero comenzando la búsqueda desde la posición ini dada como parámetro.
int
lastIndexOf (String cad)
Retorna la posición de la ultima ocurrencia de la cadena dada como parámetro.
int
lastIndexOf (String cad,int ini)
Retorna la posición de la última ocurrencia de la cadena dada como parámetro buscando en retroceso a partir de la posición dada como parámetro.
int
length ( )
Retorna el número de caracteres que contiene la cadena.
String
replace (char car1,char car2)
Retorna una nueva cadena como resultado de reemplazar todas las ocurrencias del carácter "car1" por el carácter "car2" dados como parámetros.
String
replaceAll (String cad1,String cad2)
Retorna una nueva cadena como resultado de reemplazar todas las concurrencias de la sub cadena cad1 por la sub cadena cad2 dada como parámetro.
boolean
startsWith (String cad)
Retorna true si la cadena que llama al método empieza con la subcadena cad dada como parámetro.
String
subString(int posIni)
Retorna una subcadena cuyo primer carácter empieza en la posición posIni dada como parámetro.
String
subString(int posIni,int posFin)
Retorna una subcadena cuyo primer carácter empieza en la posición posIni y  termina con el carácter de la posición  posFin.
String
toLowerCase( )
Retorna una nueva cadena como resultado de convertir todos los caracteres a minúsculas.
String
toUpperCase ( )
Retorna una nueva cadena como resultado de convertir todos los caracteres a mayúsculas.
String
trim ( )
Retorna una nueva cadena como resultado de omitir los espacios en blanco al inicio y al final de la cadena.

V.- EJEMPLOS

  1. Diseñe una aplicación que permita manipular los caracteres de una subcadena a través de los métodos vistos.

    image

    • Creamos un nuevo proyecto al cual colocaremos en un paquete; en este nuevo paquete vamos a imageagregar un JFrame al cual le daremos el tipo de distribución GridLayout con 2 columnas ; hecho esto en la primera columna colocamos un JPanel (jPanel1) y le damos una distribución de BorderLayout ( en este panel colocamos en el NORTE una caja de texto , en el CENTRO un ScrollPane y encima un txtArea …por último en el SUR colocamos una etiqueta) ; en la segunda columna colocamos otro JPanel (JPanel2) con distribución GridLayout on 2 columnas y 7 filas y simplemente arrastramos botones hacia este panel y veremos que se irán ordenando como se ve en la imagen anterior. Se les recuerda que visiten esta entrada para tener mas información sobre los tipos de distribución y esta entrada para ver como crear un proyecto con NetBeans. Bien , hecho todo esto la vista de objetos se verá de esta forma (Observar la forma de como se esta distribuido)



    • Ahora vamos a programar cada botón , para esto solo basta con darle doble clic y enseguida NetBeans nos llevará al método correspondiente :



      • Vamos a programar el botón longitud el cual nos dirá la cantidad de caracteres de la cadena que ingresaremos en el textArea ; para poder obtener el valor escrito en la caja de texto usaremos el método getText y para escribir el resultado en el área de texto usaremos el método setText.


        private void btnLongitudActionPerformed(java.awt.event.ActionEvent evt) {                                            
        // lee el mensaje
        String cadena=txtMensaje.getText();
        
        // obtiene la longitud
        int longi = cadena.length();
        
        // imprime longitud
        txtSalida.setText("El texto ingresado tiene: "+longi+" caracteres.");
        }


      • Regresamos al diseñador y le hacemos doble clic al botón Separar Palabras y ingresamos el siguiente código :


        private void btnSeparaPalabrasActionPerformed(java.awt.event.ActionEvent evt) {                 
        // lee el mensaje
        String cadena=txtMensaje.getText();
        // obtiene la longitud
        int longi = cadena.length();
        // limpia area
        txtSalida.setText("");
        // inicializa contador de palabras
        int contpala=0;
        // separa palabras por el espacio en blanco
        do {
        // no considera espacios al inicio ni al final
        cadena=cadena.trim();
        // ubica posicion del primer caracter blanco
        int pos=cadena.indexOf(' ');
        // obtiene palabra encontrada
        String palabra="";
        if (pos>0)
        palabra=cadena.substring(0,pos+1);
        else
        palabra=cadena;
        // imprime palabra encontrada
        txtSalida.append(palabra+"\n");
        // ignora palabra encontrada
        cadena=cadena.substring(palabra.length());
        // actualiza contador de palabras
        contpala++;
        } while(cadena.length()>0);
        // imprime contador de palabras
        txtSalida.append("\n"+contpala+" palabras encontradas.");
        }



      • Hacemos lo mismo con el botón de mayúsculas

        private void btnMayusculasActionPerformed(java.awt.event.ActionEvent evt) {                                              
        // TODO add your handling code here:
        // lee el mensaje
        String cadena=txtMensaje.getText();
        // lo convierte a mayúsculas
        cadena = cadena.toUpperCase();
        // imprime nueva cadena en mayusculas
        txtSalida.setText("Texto convertido a mayúsculas:\n"+cadena);
        }

      • Y con el botón de minúsculas :

        private void btnMinusculasActionPerformed(java.awt.event.ActionEvent evt) {                         
        // lee el mensaje
        String cadena=txtMensaje.getText();
        // lo convierte a minúsculas
        cadena = cadena.toLowerCase();
        // imprime nueva cadena en minusculas
        txtSalida.setText("Texto convertido a minúsculas:\n"+cadena);
        }


      • Lo propio con el botón de caracteres y los demás botones ( que por motivo de tiempo y espacio no se van a colocar pero lo pueden descargar pulsando el botón descargar )


      image
    • Por ultimo ejecutamos con F6
btn_6
... Leer más ...
24

Como cambiar el ícono a un JFrame




los pasos son los seguientes:


1)El ícono debe ser una imagen de extensión PNG. Esto se hace más fácil, ya que conseguir una figura y convertirlo en formato .ico es muy complicado. Los PNG nos ayudan bastante.

2)La imagen que será el ícono debe estar dentro del paquete de fuentes, como si fuera una clase más. Si estuviera dentro de un paquete, sería mucho mejor.




3)En el código del JFrame que vamos a poner el ícono, sobreescribimos el método getIconImage() conteniendo el siguiente código: (notar cómo se está llamando a la imagen .png)

public Image getIconImage() {
Image retValue = Toolkit.getDefaultToolkit().
getImage(ClassLoader.getSystemResource("resources/icono.png"));


return retValue;
}


4)En la vista de diseño del JFrame, lo seleccionamos y vamos sus propiedades, buscamos la propiedad "iconImagen" y hacemos clic en el botón de puntos suspensivos. Se mostrará una ventana de diálogo como esta:




De la lista desplegable, seleccionamos "Valor de componente existente". Esto hará que cambie la ventana a la siguiente forma:





Seleccionamos la opción "Propiedad" y hacemos clic en el botón de puntos suspendidos. Aparecerá una ventana de diálogo más pequeña, y seleccionamos la propiedad "iconImage" que aparece ahí.





le damos Clic en Aceptar, y se verá así:




y nuevamente clic en "Aceptar" para cerrar la ventana de selección de imagen.


Ahora, veremos que las propiedades del JFrame ya tiene un nuevo valor



Ejecutamos la aplicación con el JFrame y veremos nuestro JFrame con un ícono diferente.


... Leer más ...