Código (EjemploColecciones.java):
package ejemplocolecciones;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class EjemploColecciones {
public static void main(String[] args) {
List<Integer> cuadrante = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
//mostrar
System.out.println("lista inicial:\n" + cuadrante);
//mezclar
Collections.shuffle(cuadrante);
System.out.println("\nmezclar:\n" + cuadrante);
//ordenar
Collections.sort(cuadrante);
System.out.println("\nordenar\n" + cuadrante);
//rotar hacia la derecha
Collections.rotate(cuadrante, 1);
System.out.println("\ndesplazar hacia la derecha:\n" + cuadrante);
//rotar hacia la izquierda
Collections.rotate(cuadrante, -1);
System.out.println("\ndesplazar hacia la izquierda:\n" + cuadrante);
//invertir
Collections.reverse(cuadrante);
System.out.println("\ninvertir:\n" + cuadrante);
}
}
Resultado:
run:
lista inicial:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
mezclar:
[7, 9, 8, 6, 1, 5, 4, 2, 3]
ordenar
[1, 2, 3, 4, 5, 6, 7, 8, 9]
desplazar hacia la derecha:
[9, 1, 2, 3, 4, 5, 6, 7, 8]
desplazar hacia la izquierda:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
invertir:
[9, 8, 7, 6, 5, 4, 3, 2, 1]
BUILD SUCCESSFUL (total time: 0 seconds)
jueves, 27 de octubre de 2022
Mezlar, ordenar, rotar e invertir un listado. Uso "Collections".
Rotar elementos de una lista. Uso de "Collections.rotate".
El siguiente algoritmo desplaza una posición los elementos de una lista.
Código (ListaRotar.java):
package listarotar;
import java.util.List;
import java.util.Arrays;
import java.util.Collections;
public class ListaRotar {
public static void main(String[] args) {
List<Integer> cuadrante = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
for (int i = 0; i < 9; i++) {
Collections.rotate(cuadrante, 1);
System.out.println(cuadrante);
}
}
}
Resultado:
run:
[9, 1, 2, 3, 4, 5, 6, 7, 8]
[8, 9, 1, 2, 3, 4, 5, 6, 7]
[7, 8, 9, 1, 2, 3, 4, 5, 6]
[6, 7, 8, 9, 1, 2, 3, 4, 5]
[5, 6, 7, 8, 9, 1, 2, 3, 4]
[4, 5, 6, 7, 8, 9, 1, 2, 3]
[3, 4, 5, 6, 7, 8, 9, 1, 2]
[2, 3, 4, 5, 6, 7, 8, 9, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
BUILD SUCCESSFUL (total time: 0 seconds)
domingo, 23 de octubre de 2022
Cola circular. Uso de Queue.
Una cola circular es una estructura de datos que almacena elementos en una lista (en este caso LinkedList) y que permite acceder a los datos por uno de los dos extremos de la lista. Un elemento se inserta en la cola (parte final) y se suprime/elimina por la parte frontal.
Código (colas.java):
package colas;
import java.util.LinkedList;
import java.util.Queue;
public class Colas {
public static void main(String[] args) {
Queue<Integer> cola = new LinkedList<>();
llenar(cola);
desplazar(cola);
}
//llenar cola
private static void llenar(Queue<Integer> cola) {
for (int i = 1; i < 10; i++) {
cola.add(i);
}
}
//correr una posición <-
private static void desplazar(Queue<Integer> cola) {
mostrar(cola);
for (int i = 1; i < 9; i++) {
cola.add(cola.poll());
mostrar(cola);
}
}
private static void mostrar(Queue<Integer> cola) {
System.out.println(cola);
}
}
Resultado:
run:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9, 1]
[3, 4, 5, 6, 7, 8, 9, 1, 2]
[4, 5, 6, 7, 8, 9, 1, 2, 3]
[5, 6, 7, 8, 9, 1, 2, 3, 4]
[6, 7, 8, 9, 1, 2, 3, 4, 5]
[7, 8, 9, 1, 2, 3, 4, 5, 6]
[8, 9, 1, 2, 3, 4, 5, 6, 7]
[9, 1, 2, 3, 4, 5, 6, 7, 8]
BUILD SUCCESSFUL (total time: 0 seconds)
domingo, 16 de octubre de 2022
Mezclar elementos de una lista. Uso de "Collections.shuffle".
package gensudoku;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class GenSudoku {
public static void main(String[] args) {
List<Integer> valores = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
System.out.println("valores no mezclados: " + valores);
Collections.shuffle(valores);
System.out.println("valores si mezclados: " + valores);
}
}
Resultado:
valores no mezclados: [1, 2, 3, 4, 5, 6, 7, 8, 9]
valores si mezclados: [3, 9, 2, 8, 4, 5, 7, 1, 6]
sábado, 15 de octubre de 2022
Arrastrar un gráfico con el mouse dentro de jFrame.
Código Java (ArrastrarGrafico.java):
package arrastrargrafico;
import javax.swing.WindowConstants;
import javax.swing.JFrame;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseEvent;
public class ArrastrarGrafico extends Canvas implements MouseMotionListener {
private int xRectangulo = 0;
private int yRectangulo = 0;
private final int anchoRectangulo = 64;
private final int altoRectangulo = 64;
private int xAnteriorRaton;
private int yAnteriorRaton;
private boolean arrastrando = false;
public static void main(String[] args) {
JFrame v = new JFrame("Arrastrar Grafico");
ArrastrarGrafico c = new ArrastrarGrafico();
v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
v.getContentPane().add(c);
v.setVisible(true);
v.pack();
}
public ArrastrarGrafico() {
addMouseMotionListener(this);
}
private boolean estaDentro(MouseEvent e) {
return (e.getX() > xRectangulo)
&& (e.getX() < (xRectangulo + anchoRectangulo))
&& (e.getY() > yRectangulo)
&& (e.getY() < (yRectangulo + altoRectangulo));
}
@Override
public Dimension getPreferredSize() {
return new Dimension(512, 512);
}
@Override
public void paint(Graphics g) {
g.setColor(Color.BLUE);
g.fillRect(xRectangulo, yRectangulo, anchoRectangulo, altoRectangulo);
}
@Override
public void mouseDragged(MouseEvent e) {
if (!arrastrando) {
if (estaDentro(e)) {
xAnteriorRaton = e.getX();
yAnteriorRaton = e.getY();
arrastrando = true;
}
} else {
xRectangulo = (xRectangulo + e.getX()) - xAnteriorRaton;
yRectangulo = (yRectangulo + e.getY()) - yAnteriorRaton;
xAnteriorRaton = e.getX();
yAnteriorRaton = e.getY();
repaint();
}
}
@Override
public void mouseMoved(MouseEvent e) {
arrastrando = false;
}
}
Resultado:
miércoles, 12 de octubre de 2022
Conversor a código Braille. Uso de HashMap con matriz.
Braille es un sistema de lectura y escritura táctil pensado para personas ciegas.
Un carácter en Braile se puede representar por una matriz de puntos de tamaño 2x3.
Este algoritmo lo que hace es convertir una frase a código en Braille.
Código1 (CodigoBraille.java):
package codigobraille;
public class CodigoBraille {
public static void main(String[] args) {
Braille m = new Braille();
m.braille();
}
}
Código2 (Braille.java):
package codigobraille;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Scanner;
import javax.imageio.ImageIO;
public class Braille {
HashMap<String, Boolean[][]> tablaCodigoBraille = new HashMap<>();
public void braille() {
tablaCodigoBraille = getTablaM();
System.out.println("Escriba un mensaje a convertir a braille:");
Scanner input = new Scanner(System.in);
String mensaje = input.nextLine();
//tamaño lienzo
int res_x = 1024;
int res_y = 1024;
BufferedImage imagen = new BufferedImage(res_x, res_y, BufferedImage.TYPE_INT_RGB);
Lienzo.Dibujar((Graphics2D) imagen.getGraphics(), res_x, res_y, mensaje, tablaCodigoBraille);
try {
ImageIO.write(imagen, "png", new File("Braille.png"));
} catch (IOException e) {
}
}
private static HashMap<String, Boolean[][]> getTablaM() {
//tabla código braille español +- (2x3)
HashMap<String, Boolean[][]> par = new HashMap<>();
par.put(" ", new Boolean[][]{
{false, false},
{false, false},
{false, false}});
par.put("A", new Boolean[][]{
{true, false},
{false, false},
{false, false}});
par.put("B", new Boolean[][]{
{true, false},
{true, false},
{false, false}});
par.put("C", new Boolean[][]{
{true, true},
{false, false},
{false, false}});
par.put("D", new Boolean[][]{
{true, true},
{false, true},
{false, false}});
par.put("E", new Boolean[][]{
{true, false},
{false, true},
{false, false}});
par.put("F", new Boolean[][]{
{true, true},
{true, false},
{false, false}});
par.put("G", new Boolean[][]{
{true, true},
{true, true},
{false, false}});
par.put("H", new Boolean[][]{
{true, false},
{true, true},
{false, false}});
par.put("I", new Boolean[][]{
{false, true},
{true, false},
{false, false}});
par.put("J", new Boolean[][]{
{false, true},
{true, true},
{false, false}});
par.put("K", new Boolean[][]{
{true, false},
{false, false},
{true, false}});
par.put("L", new Boolean[][]{
{true, false},
{true, false},
{true, false}});
par.put("M", new Boolean[][]{
{true, true},
{false, false},
{true, false}});
par.put("N", new Boolean[][]{
{true, true},
{false, true},
{true, false}});
par.put("O", new Boolean[][]{
{true, false},
{false, true},
{true, false}});
par.put("P", new Boolean[][]{
{true, true},
{true, false},
{true, false}});
par.put("Q", new Boolean[][]{
{true, true},
{true, true},
{true, false}});
par.put("R", new Boolean[][]{
{true, false},
{true, true},
{true, false}});
par.put("S", new Boolean[][]{
{false, true},
{true, false},
{true, false}});
par.put("T", new Boolean[][]{
{false, true},
{true, true},
{true, false}});
par.put("U", new Boolean[][]{
{true, false},
{false, false},
{true, true}});
par.put("V", new Boolean[][]{
{true, false},
{true, false},
{true, true}});
par.put("W", new Boolean[][]{
{false, true},
{true, true},
{false, true}});
par.put("X", new Boolean[][]{
{true, true},
{false, false},
{true, true}});
par.put("Y", new Boolean[][]{
{true, true},
{false, true},
{true, true}});
par.put("Z", new Boolean[][]{
{true, false},
{false, true},
{true, true}});
par.put("&", new Boolean[][]{
{true, true},
{true, false},
{true, true}});
par.put(".", new Boolean[][]{
{false, false},
{false, false},
{true, false}});
par.put(",", new Boolean[][]{
{false, false},
{true, false},
{false, false}});
par.put("?", new Boolean[][]{
{false, false},
{true, false},
{false, true}});
par.put(":", new Boolean[][]{
{false, false},
{true, true},
{false, false}});
par.put(";", new Boolean[][]{
{false, false},
{true, false},
{true, false}});
par.put("!", new Boolean[][]{
{false, false},
{true, true},
{true, false}});
par.put("\"", new Boolean[][]{
{false, false},
{true, false},
{true, true}});
par.put("(", new Boolean[][]{
{true, false},
{true, false},
{false, true}});
par.put(")", new Boolean[][]{
{false, true},
{false, true},
{true, false}});
par.put("-", new Boolean[][]{
{false, false},
{false, false},
{true, true}});
par.put("*", new Boolean[][]{
{false, false},
{false, true},
{true, false}});
return par;
}
}
Código3 (Lienzo.java):
package codigobraille;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.util.HashMap;
class Lienzo {
static void Dibujar(Graphics2D g, int x, int y, String msg, HashMap<String, Boolean[][]> map) {
//tamaño bloque
int tCuadroX = 16;
int tCuadroY = 16;
int t = 10; //tamaño punto
Boolean tmp[][] = new Boolean[3][2];
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
//fondo blanco
g.setColor(Color.WHITE);
g.fillRect(0, 0, x, y);
//dibujar escritura Braille
g.setColor(Color.black);
int horizontal = 1, vertical = 3, limit = 0;
for (int k = 0; k < msg.length(); k++) {
//dibujar el caracter en braile
tmp = map.get("" + msg.toUpperCase().charAt(k));
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
if (tmp[j][i]) {
g.fillOval(tCuadroX * (i + horizontal), tCuadroY * (j + vertical), t, t);
}
}
}
//ha llegado al limite de linea?
if (limit++ >= 21) {
horizontal = 1;
vertical += 6;
limit = 0;
} else {
horizontal += 3;
}
}
}
}
Resultado:
run:
Escriba un mensaje a convertir a braille:
En un lugar de la Mancha, de cuyo nombre no quiero acordarme, no hace mucho tiempo que vivia un hidalgo de los de lanza en astillero, adarga antigua, rocin flaco y galgo corredor. (DON QUIJOTE DE LA MANCHA)
BUILD SUCCESSFUL (total time: 3 seconds)
sábado, 8 de octubre de 2022
Emitir notas musicales en formato sintetizado (midi).
Código (PruebaSonidoMidi.java):
package pruebasonidomidi;
import javax.sound.midi.MidiChannel;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.Synthesizer;
public class PruebaSonidoMidi {
public static void main(String[] args) {
try {
Synthesizer synth = MidiSystem.getSynthesizer();
synth.open();
MidiChannel[] channels = synth.getChannels();
for (int i = 5; i < 100; i++) {
channels[0].noteOn(i, 50);
Thread.sleep(200);
}
synth.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
domingo, 2 de octubre de 2022
Conversor a código Morse. Uso de HashMap.
Este algoritmo lo que hace es convertir una frase a código morse. Para ello hace uso de HashMap (un mapa de estructura de datos) para acceder a una "tabla" de códigos morse.
Una de las ventajas de uso de HashMap es que ofrece un acceso a datos más rápido que usando un arreglo.
Código 1 (CodigoMorse2.java):
package codigomorse2;
public class CodigoMorse2 {
public static void main(String[] args) {
Morse m = new Morse();
m.morse();
}
}
Código 2 (Morse.java):
package codigomorse2;
import java.util.HashMap;
import java.util.Scanner;
public class Morse {
HashMap<String, String> tablaCodigoMorse = new HashMap<>();
public void morse() {
tablaCodigoMorse = getTabla();
//añadir nuevos códigos morse a la tabla
tablaCodigoMorse.put(" ", " ");
tablaCodigoMorse.put(".", ".-.-.-");
System.out.println("Escriba un mensaje a convertir:");
Scanner input = new Scanner(System.in);
String mensaje = input.nextLine();
String strMorse = conversorStrToMorse(mensaje);
//resultado
System.out.println("\nEn morse:\n" + strMorse);
}
private String conversorStrToMorse(String frase) {
String arrTmp[] = frase.split("");
String morse = "";
for (String arrTmp1 : arrTmp) {
morse += tablaCodigoMorse.get(arrTmp1.toUpperCase()) + " ";
}
return morse;
}
private static HashMap<String, String> getTabla() {
//tabla código morse internacional
HashMap<String, String> par = new HashMap<>();
par.put("A", ".-");
par.put("B", "-...");
par.put("C", "-.-.");
par.put("D", "-..");
par.put("E", ".");
par.put("F", "..-.");
par.put("G", "--.");
par.put("H", "....");
par.put("I", "..");
par.put("J", ".---");
par.put("K", "-.-");
par.put("L", ".-..");
par.put("M", "--");
par.put("N", "-.");
par.put("O", "---");
par.put("P", ".--.");
par.put("Q", "--.-");
par.put("R", ".-.");
par.put("S", "...");
par.put("T", "-");
par.put("U", "..-");
par.put("V", "...-");
par.put("W", ".--");
par.put("X", "-..-");
par.put("Y", "-.--");
par.put("Z", "--..");
par.put("0", "-----");
par.put("1", ".----");
par.put("2", "..---");
par.put("3", "...--");
par.put("4", "....-");
par.put("5", ".....");
par.put("6", "-....");
par.put("7", "--...");
par.put("8", "---..");
par.put("9", "----.");
return par;
}
}
Resultado:
run:
Escriba un mensaje a convertir:
Esto es una prueba de codigo morse.
En morse:
. ... - --- . ... ..- -. .- .--. .-. ..- . -... .- -.. . -.-. --- -.. .. --. --- -- --- .-. ... . .-.-.-
BUILD SUCCESSFUL (total time: 15 seconds)