Programación Java

jueves, 9 de septiembre de 2021

Clase utilitaria DeString

package util;

import java.util.ArrayList;
import java.util.List;

public class DeString {

    public static Integer aInteger(String s) {
        Integer result = null;

        if (s != null) {
            try {
                result = Integer.valueOf(s);
            } catch (NumberFormatException e) {
            }
        }

        return result;
    }

    public static Double aDouble(String s) {
        Double result = null;

        if (s != null) {
            try {
                result = Double.valueOf(s);
            } catch (NumberFormatException e) {
            }
        }

        return result;
    }

    public static List<Integer> ids(String _ids) {
        List<Integer> list = new ArrayList<>();

        if (_ids != null) {
            String[] v_ids = _ids.split(",");
            for (String v_id : v_ids) {
                Integer id = aInteger(v_id);
                if (id != null) {
                    list.add(id);
                } else {
                    list = null;
                    break;
                }
            }
        }
        return list;
    }

    /*Listas*/
    public static Integer[] aIntegerL(String[] s) {
        Integer[] result = null;

        if ((s != null) && (s.length > 0)) {
            result = new Integer[s.length];

            for (int i = 0; i < result.length; i++) {
                try {
                    result[i] = Integer.valueOf(s[i]);
                } catch (NumberFormatException ex) {
                    result = null;
                    break;
                }
            }
        }

        return result;
    }

    public static Double[] aDoubleL(String[] s) {
        Double[] result = null;

        if ((s != null) && (s.length > 0)) {
            result = new Double[s.length];

            for (int i = 0; i < result.length; i++) {
                try {
                    result[i] = Double.valueOf(s[i]);
                } catch (NumberFormatException ex) {
                    result = null;
                    break;
                }
            }
        }

        return result;
    }

}

domingo, 13 de diciembre de 2020

Manejo de archivos

La lectura y escritura de archivos es una de las funcionalidades que ha proveído Java desde sus inicios, siendo mejorada tras sus diversas versiones

Escribir en un archivo de texto

En el siguiente ejemplo se ingresará un texto por consola y luego se almacenará en un archivo txt llamado datos.txt que se creará en la ruta especificada. Cada vez que se ejecute el programa se reescribirá el valor del texto como si se creara una nuevo.

package test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class WriteTxt {

    public static void main(String[] args) {
    
        // Captura de datos
        Scanner s = new Scanner(System.in);
        System.out.println("Ingrese un texto y luego ENTER...");
        String texto = s.nextLine();
                
        try {
            //Creación del archivo
            FileWriter fw = new FileWriter("/media/jhon/Disco/Documentos/datos.txt");
            
            //Creación del buffer para escritura
            try (BufferedWriter bw = new BufferedWriter(fw)) {
                bw.write(texto);
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
            }
            
        } catch (IOException e) {
            System.err.println("Error: " + e.getMessage());
        }        

    }
}

Añadir texto

Si se desea agregar texto sin reemplazar el original, se debe indicar en el objeto de tipo FileWriter como segundo parámetro el valor lógico TRUE. Además, en el cuerpo del buffer de escritura se añade previo al texto un salto de línea.

package test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class WriteTxt {

    public static void main(String[] args) {
        // Captura de datos
        Scanner s = new Scanner(System.in);
        System.out.println("Ingrese un texto y luego ENTER...");
        String texto = s.nextLine();
                
        try {
            //Se indica TRUE para añadir texto en lugar de reemplazar
            FileWriter fw = new FileWriter("/media/jhon/Disco/Documentos/datos.txt",true);
            
            //Creación del buffer para escritura
            try (BufferedWriter bw = new BufferedWriter(fw)) {
                bw.write("\n"); //Se agrega un salto de línea
                bw.write(texto);
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
            }
            
        } catch (IOException e) {
            System.err.println("Error: " + e.getMessage());
        }        

    }
}

Cargar imagen en Java Swing

Para este ejemplo se emplea NetBeans, una imagen jpg y la biblioteca Java Swing.

Estructura del proyecto

Se creo un JFrame que llamará a la imagen, se aprovechar esto para mostrar como llamar a la imagen desde una ubicación externa a la aplicación y desde el mismo JAR de la aplicación.

La estructura es la siguiente:	La imagen cat.jgp es:

Llamada desde fuera del JAR

Las líneas de código relevante de todo el JFrame (líneas 10 a 15) son las que declaran el objeto de tipo ImageIcon desde la ruta absoluta o path seguido de un condicional que evalúa si el estado de carga de la imagen es COMPLETO y en cuyo caso procede a borrar el texto del JLabel y asignar la imagen dentro de este.


package images;

import javax.swing.ImageIcon;

public class ImagenView extends javax.swing.JFrame {

    public ImagenView() {
        initComponents();
        //Se carga la imagen en un ImageIcon
        ImageIcon icono = new ImageIcon("/NetBeansProjects/Blog/src/images/cat.jpg");
        if (icono.getImageLoadStatus() == java.awt.MediaTracker.COMPLETE) {
            lblImagen.setText("");
            lblImagen.setIcon(icono); // Se coloca en el JLabel
        }
        
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {
        lblImagen = new javax.swing.JLabel();
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Cargando imagen");
        lblImagen.setText("Sin imagen");
        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(lblImagen, javax.swing.GroupLayout.DEFAULT_SIZE, 
                226, Short.MAX_VALUE)
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(lblImagen, javax.swing.GroupLayout.DEFAULT_SIZE, 
                226, Short.MAX_VALUE)
                .addContainerGap())
        );

        pack();
    }// </editor-fold>                        

    public static void main(String args[]) {
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : 
            javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException | InstantiationException | 
        IllegalAccessException | javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(ImagenView.class.getName())
            	.log(java.util.logging.Level.SEVERE, null, ex);
        }

        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new ImagenView().setVisible(true);
            }
        });
    }

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

Llamada desde dentro del JAR

Se requiere de la clase java.net.URL para indicar la ubicación de la imagen y cargarla posteriormente


package images;

import java.net.URL;
import javax.swing.ImageIcon;

public class ImagenView extends javax.swing.JFrame {

    public ImagenView() {
        initComponents();
        
        //Se carga la imagen en un ImageIcon desde su URL
        URL url = getClass().getResource("cat.jpg");
        ImageIcon icono = new ImageIcon(url);
        
        if (icono.getImageLoadStatus() == java.awt.MediaTracker.COMPLETE) {
            lblImagen.setText("");
            lblImagen.setIcon(icono); // Se coloca en el JLabel
        }
        
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {
        lblImagen = new javax.swing.JLabel();
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Cargando imagen");
        lblImagen.setText("Sin imagen");
        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(lblImagen, javax.swing.GroupLayout.DEFAULT_SIZE, 
                226, Short.MAX_VALUE)
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(lblImagen, javax.swing.GroupLayout.DEFAULT_SIZE, 
                226, Short.MAX_VALUE)
                .addContainerGap())
        );

        pack();
    }// </editor-fold>                        

    public static void main(String args[]) {
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : 
            javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException | InstantiationException | 
        IllegalAccessException | javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(ImagenView.class.getName())
            	.log(java.util.logging.Level.SEVERE, null, ex);
        }

        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new ImagenView().setVisible(true);
            }
        });
    }

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

En ambos casos la salida en pantalla sería:

Lectura de archivos

Manejo de archivos

La lectura y escritura de archivos es una de las funcionalidades que ha proveído Java desde sus inicios, siendo mejorada tras sus diversas versiones.

Lectura de archivos de texto

Para llevar a cabo la lectura de un archivo de texto se pueden emplear diversos métodos de la clase java.io.*, pero se recomienda complementar esta con la clase java.nio.* considerada la clase de reemplazo de la anterior, que contiene entre sus componentes a Files y Paths permitiendo simplificar acciones como copiar un archivo en uno nuevo y brindando el soporte para llevar a cabo las acciones clásicas de la clase original.

Por ejemplo, supongamos un archivo txt con el siguiente contenido:

-A: Hola
-G: Hola, ¿cómo estas?
-A: Bien, y tú
-G: Igualmente
-A: Debo irme, hasta luego
-G: Hasta luego, saludos a doña Dana

Ahora una clase "main" de Java con el siguiente código que mostrará el contenido del archivo en consola empleando diversas formas:

package test;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.List;

public class Test {

    public static void main(String[] args) throws IOException {
        //Archivo indicando la ruta
        File archivo = new File("/media/ruta/data.txt");
        //Definición de caracteres UTF-8
        Charset cs = StandardCharsets.UTF_8;
        
        /*Lectura de datos*/
        //USANDO Files.readAllLines
        try {
            List<String> lines = Files.readAllLines(archivo.toPath(), cs);
            lines.forEach(l -> {
                System.out.println(l);
            });
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }
        
        System.out.println("====================================");
        
        //USANDO BufferedReader
        try (BufferedReader br = Files.newBufferedReader(archivo.toPath(), cs)) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }
        
        System.out.println("====================================");
        
        //USANDO InputStream
        try (InputStream is = Files.newInputStream(archivo.toPath())) {
            byte[] bytes = new byte[(int) archivo.length()];
            is.read(bytes);
            String content = new String(bytes, cs);
            System.out.println(content);
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }

    }
}

Mostrará el siguiente resultado:

-A: Hola
-G: Hola, ¿cómo estas?
-A: Bien, y tú
-G: Igualmente
-A: Debo irme, hasta luego
-G: Hasta luego, saludos a doña Dana
====================================
-A: Hola
-G: Hola, ¿cómo estas?
-A: Bien, y tú
-G: Igualmente
-A: Debo irme, hasta luego
-G: Hasta luego, saludos a doña Dana
====================================
-A: Hola
-G: Hola, ¿cómo estas?
-A: Bien, y tú
-G: Igualmente
-A: Debo irme, hasta luego
-G: Hasta luego, saludos a doña Dana

Lectura de archivos multimedia

Además, se pueden cargar archivos como:

Imágenes

En la web (https://javajhon.blogspot.com/2020/06/imagenes-servlet.html)
En una aplicación de escritorio (https://javajhon.blogspot.com/2020/12/imagen-swing.html)

Audio
Video
Documentos

Cada uno de estos tiene sus particularidades y diferentes formas de llamado dependiendo del entorno donde se desee mostrarlos, es diferente cargar una imagen en una aplicación WEB que en una aplicación de escritorio.

viernes, 27 de noviembre de 2020

Conectar SQLite con Eclipse

Programas o Software requerido

Para realizar la conexión necesitamos tener los siguientes programas:

Eclipse (Pueden elegir la versión que deseen así como la arquitectura de su Pc o Mac): http://www.eclipse.org/downloads/packages/
El driver JDBC de SQLite (sqlite-jdbc-3.30.1).
Un programa que administre bases de datos de SQLite para crear las bases de datos y opcionalmente comprobar si los cambios realizados en el programa JAVA realizan cambios en la base de datos.

SQLiteStudio: https://sqlitestudio.pl/
DB Browser for SQLite: https://sqlitebrowser.org/

Paso 1 - La base de datos

Si ya posee la base de datos, solo basta conocer la dirección exacta de esta. Si no posee la base de datos, puede seguir el siguiente tutorial para generar una: https://inlearningcode.blogspot.com/2020/11/sqlite-tabla.html

Paso 2 - El proyecto en Eclipse

Ahora procedemos a Eclipse donde creamos un nuevo proyecto, colocamos el nombre del proyecto como queramos llamarlo. Luego continuamos y vamos a la pestaña Libraries (Bibliotecas) y dentro de ella agregamos una nueva (Add Library).

Despliega una nueva ventana y elegimos la opción Add External JARs y luego seleccionar el archivo JAR correspondiente, en mi caso el sqlite-jdbc-3.30.1.jar, y aceptar.

Dentro del proyecto se observa las bibliotecas del Jdk y el driver de conexión.

package util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Conectabd {
	private final String URL = "jdbc:sqlite:D:\\bd\\blog.db";
    private final String DRIVER = "org.sqlite.JDBC";

    
    public Connection conexionDB() throws SQLException{
    Connection c = null;
        try {
            Class.forName(DRIVER).newInstance();
            c = DriverManager.getConnection(URL);
        } catch (ClassNotFoundException | 
                 IllegalAccessException | 
                 InstantiationException | 
                 SQLException e) {
            throw new SQLException(e.getMessage());
        }
    
    return c;
    }
    		
	}
	
}

La constante URL es una combinación del JDBC y la ubicación real de la base de datos SQLite que es un archivo en sí. Mientras el DRIVER es para este caso "org.sqlite.JDBC"

Al ser una base de datos de SQLite un archivo, no requiere de usuario ni de contraseña, pero mantiene la misma lógica para llevar a cabo la conexión.

Paso 3 - Probando la clase de conexión

Creamos la siguiente clase Test.java

package test;

import java.sql.Connection;

import util.Conectabd;

public class Test {

	public static void main(String[] args) {

		Conectabd conectabd = new Conectabd();
		try (Connection c = conectabd.getConexion()) {
			System.out.print("Conexión exitosa");
		} catch (Exception e) {
			System.err.print("Error: "+e.getMessage());
		}
	}

}

Al ser ejecutada la clase devolverá: "Conexión exitosa" o indicará si ocurrió una excepción. Generalmente suelen ser un error en la redacción de la URL o el driver.

miércoles, 25 de noviembre de 2020

Métodos de búsqueda

Búsqueda secuencial o lineal

Consiste en recorrer una estructura de datos comparando cada elemento con el valor buscado, si el elemento buscado se encuentra al inicio, el tiempo de búsqueda será muy corto, pero será cada vez más largo mientras el elemento se encuentre más cerca del final o no se encuentre.

Algoritmo de implementación

package busqueda;

public class Busca {

    public static Integer Secuencial(Integer[] data, int valor) {
        Integer pos = null;
        for (int i = 0; i < data.length; i++) {
            if (valor == data[i]) {
                pos = i;
                break;
            }
        }
        return pos;
    }
}

Aplicando el algoritmo a un Array

package test;

import busqueda.Busca;

public class TestBusqueda {

    public static void main(String[] args) {
        Integer[] datos = {2, 255, 10, 0, 11, 1172, 1};
        System.out.println("Array: " + Arrays.toString(datos));
        
        //Búsqueda de la posición de forma secuencial		
        Integer index = Busca.Secuencial(datos, 11); // Busca 11
        System.out.println("Buscando 11 ...");
        //Mostrar resultado
        if (index != null) {
            System.out.println("Elemento encontrado en la posición " + index);
        } else {
            System.out.println("Elemento no encontrado");
        }
		
        index = Busca.Secuencial(datos, 12); // Busca 12
        System.out.println("Buscando 12 ...");
        //Mostrar resultado
        if (index != null) {
            System.out.println("Elemento encontrado en la posición " + index);
        } else {
            System.out.println("Elemento no encontrado");
        }
    }
}

El resultado sería el siguiente:

Array: [2, 255, 10, 0, 11, 1172, 1]

Buscando 11 ...
Elemento encontrado en la posición 4

Buscando 12 ...
Elemento no encontrado

Búsqueda binaria

Consiste en recorrer una estructura de datos dividiéndola constantemente en dos partes hasta encontrar la coincidencia de búsqueda. Este método requiere que la estructura de datos este previamente ordenada de forma ascendente o descedente.

Algoritmo de implementación

package busqueda;

public class Busca {

    public static Integer Binario(Integer[] data, Integer valor) {
        int li = 0;
        int ls = data.length;
        while (li <= ls) {
            int lm = (ls - li) / 2 + li;
            if (data[lm] < valor) {
                li = lm + 1;
            } else if (data[lm] > valor) {
                ls = lm - 1;
            } else {
                return lm;
            }
        }
        return null;
    }
}

Aplicando el algoritmo a un Array

package test;

import busqueda.Busca;
import java.util.Arrays;

public class TestBusqueda {

    public static void main(String[] args) {
        Integer[] datos = {2, 255, 10, 0, 11, 1172, 1};
        System.out.println("Array: " + Arrays.toString(datos));
        
        //Búsqueda de la posición por búsqueda binaria
        Arrays.sort(datos); // Ordenamiento de datos
        System.out.println("Array ordenado: " + Arrays.toString(datos));
        
        Integer index = Busca.Binario(datos, 172); 
        System.out.println("Buscando 172 ..."); 
        //Mostrar resultado
        if (index != null) {
            System.out.println("Elemento encontrado en la posición " + index);
        } else {
            System.out.println("Elemento no encontrado");
        }
        
        index = Busca.Binario(datos, 255);
        System.out.println("Buscando 255 ...");
        //Mostrar resultado
        if (index != null) {
            System.out.println("Elemento encontrado en la posición " + index);
        } else {
            System.out.println("Elemento no encontrado");
        }
    }
}

El resultado sería el siguiente:

Array: [2, 255, 10, 0, 11, 1172, 1]
Array ordenado: [0, 1, 2, 10, 11, 255, 1172]

Buscando 172 ...
Elemento no encontrado

Buscando 255 ...
Elemento encontrado en la posición 5

miércoles, 18 de noviembre de 2020

Métodos de ordenamiento

Los problemas más comunes en la informática son la búsqueda y el ordenamiento. El proceso de ordenar consiste en recolocar los elementos de un array o colección ya sea de mayor a menor o viceversa con el fin de acelerar la búsqueda de la información.

En este aspecto existe una multitud de algoritmos de ordenamiento clasificados de diversas formas como la estabilidad, su complejidad, ubicación del proceso al ordenar, etc.

Entre los múltiples algoritmos tenemos:

Ordenamiento por burbuja
Ordenamiento por montículos
Ordenamiento por selección
Ordenamiento por inserción
Ordenamiento rápido (QuickSort)
Ordenamiento shell

Ordenamiento por burbuja

La clase con el siguiente código permite ordenar los elementos de un array unidimensional mediante este método.

package ordenamiento;

public class Ordena {
    
    //Ordenamiento de burbuja
    public static void burbuja(Integer[] data) {
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data.length - 1; j++) {
                if (data[j] > data[j + 1]) {
                    Integer temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }
    }
}

Para comprobar el funcionamiento se utiliza lo siguiente:

package test;

import ordenamiento.Ordena;

public class TestOrdenar {

    public static void main(String[] args) {
        Integer[] vals = {15, 60, 8, 16, 44, 27, 12, 35};
        Ordena.burbuja(vals);
        for (Integer val : vals) {
            System.out.println(val);
        }

    }
}

La salida del resultado sería:

Se comprueba el funcionamiento de este algoritmo.

Ordenamiento por selección

La clase con el siguiente código permite ordenar los elementos de un array unidimensional mediante este método.

package ordenamiento;

public class Ordena {
    
    //Ordenamiento por selección
    public static void seleccion(Integer[] data) {
        for (int i = 0; i < data.length; i++) {
            for (int j = i; j < data.length; j++) {
                if (data[i] > data[j]) {
                    Integer aux = data[j];
                    data[j] = data[i];
                    data[i] = aux;
                }
            }
        }
    }
}

Para comprobar el funcionamiento se utiliza lo siguiente:

package test;

import ordenamiento.Ordena;

public class TestOrdenar {

    public static void main(String[] args) {
        Integer[] vals = {15, 60, 8, 16, 44, 27, 12, 35};
        Ordena.seleccion(vals);
        for (Integer val : vals) {
            System.out.println(val);
        }

    }
}

La salida del resultado sería:

Se comprueba el funcionamiento de este algoritmo.

Ordenamiento por inserción

La clase con el siguiente código permite ordenar los elementos de un array unidimensional mediante este método.

package ordenamiento;

public class Ordena {
    
    //Ordenamiento por inserción
    public static void insercion(Integer[] data) {
        for (int i = 1; i < data.length; i++) {
            Integer aux = data[i];
            int j = i - 1;
            while (j >= 0 && data[j] > aux) {
                data[j + 1] = data[j];
                j--;
            }
            data[j + 1] = aux;
        }
    }
}

Para comprobar el funcionamiento se utiliza lo siguiente:

package test;

import ordenamiento.Ordena;

public class TestOrdenar {

    public static void main(String[] args) {
        Integer[] vals = {15, 60, 8, 16, 44, 27, 12, 35};
        Ordena.insercion(vals);        
        for (Integer val : vals) {
            System.out.println(val);
        }

    }
}

La salida del resultado sería:

Se comprueba el funcionamiento de este algoritmo.

Ordenamiento por montículos (HeapSort)

La clase con el siguiente código permite ordenar los elementos de un array unidimensional mediante este método.

package ordenamiento;

public class Ordena {
    
    //Ordenamiento por montículos
    public static void heapsort(Integer[] data) {
        data = monticulo(data, data.length);
        for (int i = 0; i < data.length; i++) {
            data = eliminarRaiz(data, data.length - i);
            data = monticulo(data, data.length - i - 1);
        }
    }
    
    //Función para construir montículo
    private static Integer[] monticulo(Integer[] data, int n) {
        for (int i = 0; i < n; i++) {
            if (padre(i) != -1) {
                int p = data[padre(i)];
                if (data[i] > p) {
                    data[padre(i)] = data[i];
                    data[i] = p;
                    monticulo(data, n);
                }
            }
        }
        return data;
    }        
    
    //Función para determinar padres
    private static int padre(int index) {
        return (index == 0) ? -1 : (index - 1) / 2;
    }

    //Función para eliminar las raices
    private static Integer[] eliminarRaiz(Integer[] data, int n) {
        Integer aux;
        aux = data[n - 1];
        data[n - 1] = data[0];
        data[0] = aux;
        return data;
    }
}

Para comprobar el funcionamiento se utiliza lo siguiente:

package test;

import ordenamiento.Ordena;

public class TestOrdenar {

    public static void main(String[] args) {
        Integer[] vals = {15, 60, 8, 16, 44, 27, 12, 35};
        Ordena.heapsort(vals);
        for (Integer val : vals) {
            System.out.println(val);
        }

    }
}

La salida del resultado sería:

Se comprueba el funcionamiento de este algoritmo.

Programación Java

Páginas

jueves, 9 de septiembre de 2021

Clase utilitaria DeString

domingo, 13 de diciembre de 2020

Escritura en archivos

Manejo de archivos

Escribir en un archivo de texto

Añadir texto

Cargar imagen en Java Swing

Estructura del proyecto

Llamada desde fuera del JAR

Llamada desde dentro del JAR

Lectura de archivos

Manejo de archivos

Lectura de archivos de texto

Lectura de archivos multimedia

viernes, 27 de noviembre de 2020

Conectar SQLite con Eclipse

Programas o Software requerido

Paso 1 - La base de datos

Paso 2 - El proyecto en Eclipse

Paso 3 - Probando la clase de conexión

miércoles, 25 de noviembre de 2020

Métodos de búsqueda

Búsqueda secuencial o lineal

Algoritmo de implementación

Aplicando el algoritmo a un Array

Búsqueda binaria

Algoritmo de implementación

Aplicando el algoritmo a un Array

miércoles, 18 de noviembre de 2020

Métodos de ordenamiento

Ordenamiento por burbuja

Ordenamiento por selección

Ordenamiento por inserción

Ordenamiento por montículos (HeapSort)