Ejercicios Prácticos de Programación en Java: Manipulación de Strings, Matrices y Vectores

Clase Prueba: Concatenación y Manipulación de Strings

En esta sección, exploraremos diferentes métodos para concatenar y manipular cadenas (Strings) en Java.

public class Prueba {
    public static void main(String args[]) {
        int i;
        String s1 = "hola"; //Declaración de cadena s1
        System.out.println("s1=" + s1);
        String s2 = ""; //Declaración de cadena s2
        s1 = s1 + " isc"; //Concatenación opción 1
        System.out.println("s1=" + s1); //Impresión de la cadena ya concatenada
        s1 = "uaa"; //Nuevo valor a s1
        System.out.println("s1=" + s1); //Impresión de s1
        s1 = s1.concat(" tercero"); //Concatenación opción 2
        System.out.println("s1=" + s1); //Impresión
        for (i = 0; i < 3; i++) {
            s2 = s2.concat(" *"); //Concatenación en un ciclo
        }
        System.out.println("s2= " + s2);
        s2 = s1 + " en java"; //Concatenar variables con una literal de cadena
        System.out.println("s2= " + s2);
        System.out.println("caracter x caracter: ");
        for (i = 0; i < s2.length(); i++) {
            System.out.print(s2.charAt(i) + " "); //Recorrer caracter x caracter un String
        }
        char cad[] = s2.toCharArray(); //Pasar un String a un arreglo de char
        System.out.println("\ncaracter x caracter");
        for (i = 0; i < cad.length; i++) {
            System.out.print(cad[i] + " ");
            cad[i] = 'x';
        }
        String s3 = new String(cad); //Pasando un arreglo de char a un String opción 1
        System.out.println("\ns3=" + s3);
        s1 = String.valueOf(cad); //Pasando un arreglo de char a un String opción 2
        System.out.println("\ns1=" + s1);
        String c1 = "hola";
        System.out.println(c1.charAt(2));
        c1 = c1 + c1.charAt(2); //Sumar a una cadena una casilla de una cadena
        System.out.println(c1);
        if (c1.charAt(0) != c1.charAt(2)) //Comparar dos casillas de una cadena
            System.out.println("diferentes");
        char k = c1.charAt(0); //Asignar a un char una casilla de una cadena
        char v[] = new char[5];
        v[0] = c1.charAt(2); //Asignar a una casilla de un vector una casilla de una cadena
        System.out.println("k=" + k);
        System.out.println("v[0]=" + v[0]);
    }
}

Clase VariosString: Métodos Útiles para Strings

Aquí se demuestran varios métodos importantes para la manipulación de Strings en Java.

public class Variosstring {
    public static void main(String[] arg) {
        /*************Metodo Length**************/
        //Length saca la longitud
        System.out.println("Metodo Length");
        String cadena = "universidad";
        System.out.println("La longitud de " + cadena + " es: " + cadena.length());

        /*************Metodo Equals**************/
        //Equals es un if para Strings
        System.out.println("\nMetodo Equals");
        String cad1 = "universidad";
        String cad2 = "uni";
        if (cad1.equals(cad2))
            System.out.println(cad1 + " es igual a " + cad2);
        else
            System.out.println(cad1 + " NO es igual a " + cad2);

        /**************Metodo valueOf*************/
        //valueOf convierte de int a String
        System.out.println("\n Metodo valueOf");
        int numero = 123;
        System.out.println("El numero como entero es " + numero);
        String num = String.valueOf(numero);
        System.out.println("El numero como cadena es");
        for (int i = 0; i < num.length(); i++)
            System.out.println("casilla " + i + " = " + num.charAt(i));

        /************Metodo toCharArray()************/
        //Cambiar string a vector
        System.out.println("\nMetodo toCharArray()");
        String cuidad = "aguascalientes";
        char[] cd = cuidad.toCharArray();
        System.out.println("La cadena es " + cuidad);
        System.out.println("imprimiendo el vector de char");
        for (int i = 0; i < cd.length; i++)
            System.out.println(cd[i] + "-");

        /**************Metodo valueOf()*************/
        //valueOf para pasar un vector de char a una cadena
        System.out.println("\nMetodo valueOf()");
        char[] puesto = {'d', 'i', 'r', 'e', 'c', 't', 'o', 'r'};
        String puestoCad1 = new String(puesto);
        System.out.println("");
        String puestoCad2 = String.valueOf(puesto);
        System.out.println("El vector de char como String opcion 1 " + puestoCad1);
        System.out.println("El vector de char como String opcion 2 " + puestoCad2);

        /**************Metodo trim *****************/
        //Borra espacios en blanco
        System.out.println("\nMetodo trim");
        String nombre = " UVM ";
        System.out.println("Antes de aplicar trim " + "*" + nombre + "*");
        nombre = nombre.trim();
        System.out.println("Despues de aplicar trim " + "*" + nombre + "*");

        /**************Metodo split *****************/
        //elimina un caracter especifico
        System.out.println("\nMetodo split");
        String colores = "rojo,amarillo,verde,azul,morado,marron";

        String[] arrayColores = colores.split(",");

        for (int i = 0; i < arrayColores.length; i++)
            System.out.println(arrayColores[i]);

        /**************Metodo substring**************/
        //toma solo una parte de la cadena especificada
        System.out.println("\nMetodo substring");
        String cad = "anita lava la tina";
        String subcad = cad.substring(6, 10);

        System.out.println("cadena: " + cad);
        System.out.println("subcadena: " + subcad);

        /**************Metodo indexOf()**************/
        //compara si dos cadenas comparten algun patron
        System.out.println("\nMetodo indexOf()");
        System.out.println("Buscando un patron en un cadena");
        String text = "abracadabra";
        String pattern = "cada";
        System.out.println("text: " + text);
        System.out.println("patron: " + pattern);
        int res = text.indexOf(pattern);
        if (res == -1)
            System.out.println("patron NO encontrado");
        else
            System.out.println("patron encontrado en la posicion " + res);
    }
}

Clase ListaDeNumeros: Introducción a ArrayList

Esta sección introduce el uso de ArrayList para almacenar una lista de números enteros.

public class ListaDeNumeros {
    public static void main(String[] args) {
        ArrayList listaNumeros = new ArrayList();
        int x = 5;
        int y = 7;
        listaNumeros.add(x);
        listaNumeros.add(34);
        listaNumeros.add(67);
        System.out.println("Total de elementos en la lista =" + listaNumeros.size());
        //recorriendo la lista
        System.out.println("La lista contiene: ");
        for (int i = 0; i < listaNumeros.size(); i++) {
            System.out.println(listaNumeros.get(i));
        }
    }
}

Clase ListaTipoDeUnaClase: ArrayList de Objetos Personalizados

Aquí se muestra cómo crear y manipular un ArrayList que contiene objetos de una clase definida por el usuario (Mascota).

public class ListaTipoDeUnaClase {
    //Mostrando como generar una lista del tipo de una clase
    public static void main(String[] args) {
        ArrayList listaMascotas = new ArrayList();
        Mascota obj;
        Scanner leer = new Scanner(System.in);
        char resp = 's';
        String nombre, tipo;
        int edad;
        String nombres[] = {"fifi", "daysi", "kiara", "poof", "cosita", "rocki", "cofi", "luna", "margarito"};
        String tipos[] = {"perro", "gato", "conejo", "pato", "pez", "tortuga", "pajaro", "huron", "cuyo"};
        while (resp == 's') {
            System.out.println("\nGenerando aleatoriamente los datos .....");
            nombre = nombres[(int) (Math.random() * (nombres.length - 1 - 0 + 1) + 0)]; //generando un aleatorio para seleccionar un indice del vector de nombres
            tipo = tipos[(int) (Math.random() * (tipos.length - 1 - 0 + 1) + 0)]; //generando un aleatorio para seleccionar un indice del vector de tipos
            edad = (int) (Math.random() * (5 - 0 + 1) + 0); //generando un aleatorio para seleccionar una edad
            obj = new Mascota(nombre, tipo, edad); //generando una instancia de la clase mascota
            listaMascotas.add(obj); //agregando el objeto a la lista
            System.out.println("Guardando ... nombre:" + nombre + " tipo:" + tipo + " edad:" + edad);
            System.out.println("\nDeseas guardar los datos de otra mascota s/n");
            resp = leer.next().charAt(0);
        }
        //imprimiendo la lista de mascotas
        System.out.println("\nLista de mascotas \n");
        for (int i = 0; i < listaMascotas.size(); i++) {
            System.out.println("\nMascota #" + i);
            System.out.println("nombre: " + listaMascotas.get(i).getNombre()); //se recupera el indice con get(i) y luego se llama al metodo getNombre()
            System.out.println("tipo: " + listaMascotas.get(i).getTipo());
            System.out.println("edad: " + listaMascotas.get(i).getEdad());
        }
        //Para cambiar el valor de algun atributo de un objeto de la lista
        System.out.println("El nombre de la posicion #2 es " + listaMascotas.get(2).getNombre());
        //1 Recuperar el objeto de la lista, a un objeto del tipo de la lista
        Mascota objeto;
        objeto = listaMascotas.get(2);
        //2 cambiar el valor del atributo que se desea con los metodos set
        objeto.setNombre("perico");
        //3 volver a colocar el objeto en la lista
        listaMascotas.set(2, objeto);
        System.out.println("El nombre de la posicion #2 es " + listaMascotas.get(2).getNombre());
    }
}

class Mascota {
    private String tipo;
    private String nombre;
    private int edad;

    public Mascota() {
    }

    public Mascota(String tipo, String nombre, int edad) {
        this.tipo = tipo;
        this.nombre = nombre;
        this.edad = edad;
    }

    public String getTipo() {
        return tipo;
    }

    public void setTipo(String tipo) {
        this.tipo = tipo;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }
}

Clase ListaTipoString: ArrayList de Strings

Esta sección demuestra el uso de ArrayList para almacenar y manipular cadenas.

public class ListaTipoString {
    public static void main(String[] args) {
        ArrayList listaCadenas = new ArrayList();
        // Añade el elemento al ArrayList
        listaCadenas.add("azul");
        listaCadenas.add("amarillo");
        listaCadenas.add("blanco");
        System.out.println("La lista va asi: " + listaCadenas);
        // Añade el elemento al ArrayList en la posición indicada y desplaza elementos a la derecha
        listaCadenas.add(0, "rojo");
        System.out.println("La lista va asi: " + listaCadenas);
        listaCadenas.add("verde");
        System.out.println("La lista va asi: " + listaCadenas);
        // Devuelve el numero de elementos del ArrayList
        System.out.println("Total de elementos en la lista " + listaCadenas.size());
        // Devuelve el elemento que esta en la posición '2' del ArrayList
        System.out.println("El dato en la posicion 2 es: " + listaCadenas.get(2));
        listaCadenas.set(2, "morado"); //este metodos sustituye el valor de la posicion 2 por el valor indicado
        System.out.println("El dato en la posicion 2 es: " + listaCadenas.get(2));
        //Mostrar una Lista con ciclo
        //Mostrando los valores de la lista ...
        System.out.println("\n Mostrando los valores de la lista ");
        for (int i = 0; i < listaCadenas.size(); i++) {
            System.out.println("En la posicion " + i + ": " + listaCadenas.get(i));
        }
    }
}

Clase Matriz: Operaciones con Matrices

Esta sección cubre la creación, llenado, impresión y diversas operaciones con matrices, incluyendo la impresión en zigzag, suma por renglones y columnas, búsqueda de elementos y ordenamiento.

public class Matriz {
    private int[][] m;

    public Matriz(int ren, int col) {
        this.m = new int[ren][col];
    }

    public int generaUnAleatorio() {
        return (int) (Math.random() * (90 - 0 + 1) + 0);
    }

    public void llenaMatriz() {
        for (int i = 0; i < this.m.length; i++) {
            for (int j = 0; j < this.m[i].length; j++) {
                this.m[i][j] = this.generaUnAleatorio();
            }
        }
    }

    public void imprimeMatriz() {
        int a = 1;
        for (int i = 0; i < this.m.length; i++) {
            for (int j = 0; j < this.m[i].length; j++) {
                if (a == m[i].length + 1) {
                    System.out.println();
                    a = 1;
                }
                System.out.print(this.m[i][j] + " - ");
                a++;
            }
        }
    }

    public void imprimeMatrizZigZag() {
        for (int i = 0; i < this.m.length; i++) {
            int a = i;
            if (a % 2 == 0) {
                System.out.println();
                for (int j = 0; j < this.m[i].length; j++) {
                    System.out.print(this.m[i][j] + " - ");
                }
            }
            if (a % 2 != 0) {
                System.out.println();
                for (int j = this.m[i].length - 1; j >= 0; j--) {
                    System.out.print(this.m[i][j] + " - ");
                }
            }
        }
    }

    public void imprimeSumaPorRenglones() {
        int[] v = new int[this.m.length];
        for (int i = 0; i < this.m.length; i++) {
            int p = 0;
            for (int j = 0; j < this.m[i].length; j++) {
                p += this.m[i][j];
            }
            v[i] = p;
        }
        for (int i = 0; i < v.length; i++) {
            System.out.println("La suma del renglon " + i + " es: " + v[i]);
        }
    }

    public void imprimeSumaPorColumnas() {
        int[] v = new int[this.m[0].length];
        for (int i = 0; i < this.m[0].length; i++) {
            int p = 0;
            for (int j = 0; j < this.m.length; j++) {
                p += this.m[j][i];
            }
            v[i] = p;
        }
        for (int i = 0; i < v.length; i++) {
            System.out.println("La suma de la columna " + i + " es: " + v[i]);
        }
    }

    public int totalVeces(int num) {
        int cont = 0;
        for (int i = 0; i < this.m.length; i++) {
            for (int j = 0; j < this.m[i].length; j++) {
                if (num == this.m[i][j])
                    cont++;
            }
        }
        return cont;
    }

    public int[] pasarDeMatrizAVector() {
        int v[] = new int[this.m.length * this.m[0].length];
        int cont = 0;
        for (int i = 0; i < this.m.length; i++) {
            for (int j = 0; j < this.m[i].length; j++) {
                v[cont] = this.m[i][j];
                cont++;
            }
        }
        return v;
    }

    public int[][] pasarDeVectorAMatriz(int v[], int ren, int col) {
        int cont = 0;
        int[][] matriz = new int[ren][col];
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[i].length; j++) {
                matriz[i][j] = v[cont];
                cont++;
            }
        }
        return matriz;
    }

    public int[] ordenaInsercion(int[] v) {
        //Metodo para ordenar el vector
        int aux;
        for (int i = 1; i < v.length; i++) {
            aux = v[i];
            for (int j = i - 1; j >= 0 && v[j] > aux; j--) {
                v[j + 1] = v[j];
                v[j] = aux;
            }
        }
        return v;
    }

    public void ordenarMatriz() throws InterruptedException {
        int v[] = new int[this.m.length * this.m[0].length];
        int vo[] = new int[this.m.length * this.m[0].length];
        Thread.sleep(1000);
        System.out.println("Convirtiendo Matriz a Vector...");
        v = this.pasarDeMatrizAVector();
        System.out.println("Ordenacion de datos.... ");
        vo = this.ordenaInsercion(v);
        Thread.sleep(1000);
        System.out.println("Convirtiendo Vector a Matriz\n\n");
        this.m = this.pasarDeVectorAMatriz(v, m.length, m[0].length);
        int a = 1;
        Thread.sleep(1000);
        System.out.println("Imprimiendo Matriz ordenada... ");
        for (int i = 0; i < this.m.length; i++) {
            for (int j = 0; j < this.m[i].length; j++) {
                if (a == m[i].length + 1) {
                    System.out.println();
                    a = 1;
                }
                System.out.print(m[i][j] + " - ");
                a++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Matriz obj;
        char res = 's', res1;
        Scanner teclado = new Scanner(System.in);
        do {
            System.out.println("Ingrese el numero de renglones y columnas de la matriz respectivamente: ");
            int ren = teclado.nextInt();
            int col = teclado.nextInt();
            System.out.println("Creando nueva matriz");
            Thread.sleep(1000);
            obj = new Matriz(ren, col);
            System.out.println("Generando datos para incrustar a la matriz...");
            Thread.sleep(1000);
            obj.llenaMatriz();
            Thread.sleep(1000);
            System.out.println("\nImprimiendo Matriz...");
            obj.imprimeMatriz();
            Thread.sleep(1000);
            System.out.println("\n\nImprimiendo Matriz en Zig Zag...");
            obj.imprimeMatrizZigZag();
            Thread.sleep(1000);
            System.out.println("\n\nGenerando suma de datos por renglon....");
            obj.imprimeSumaPorRenglones();
            Thread.sleep(1000);
            System.out.println("Generando suma de datos por columna....");
            obj.imprimeSumaPorColumnas();
            Thread.sleep(1000);
            System.out.println("\nDesea buscar un dato?");
            res1 = teclado.next().charAt(0);
            if (res1 == 's') {
                System.out.println("Ingrese el dato de referencia:");
                int num = teclado.nextInt();
                Thread.sleep(1000);
                if (obj.totalVeces(num) != 0) {
                    System.out.println("Dato encontrado en el vector...");
                    System.out.println("# de ocasiones encontrado: " + obj.totalVeces(num));
                }
                if (obj.totalVeces(num) == 0) {
                    System.out.println("Dato no encontrado... ");
                }
            }
            Thread.sleep(1000);
            System.out.println("\n\nOrdenando Matriz por Insercion....");
            obj.ordenarMatriz();
            System.out.println("\n\nDesea crear una nueva matriz?");
            res = teclado.next().charAt(0);
        } while (res != 'n');
    }
}

Clase Vector: Operaciones con Vectores y Métodos de Ordenamiento

Esta sección explora la creación, llenado, impresión y ordenamiento de vectores utilizando los métodos de selección y burbuja. También incluye la búsqueda de datos y el cálculo del promedio.

public class Vector {
    private int v[];
    private int ls, li;

    public Vector(int n) {
        this.v = new int[n];
    }

    public void ordenaSeleccion() {
        int i, j, menor, pos, tmp;
        for (i = 0; i < v.length - 1; i++) { //Tomamos como menor el primero
            menor = v[i]; //de los elementos que quedan por ordenar
            pos = i; //y guardamos su posición
            for (j = i + 1; j < v.length; j++) { //Buscamos en el resto
                if (v[j] < menor) { //del array algún elemento
                    menor = v[j]; //menor que el actual
                    pos = j;
                }
            }
            if (pos != i) { //Si hay alguno menor se intercambia
                tmp = v[i];
                v[i] = v[pos];
                v[pos] = tmp;
            }
        }
    }

    public void ordenaBurbuja() {
        int i, j, aux;
        for (i = 0; i < v.length - 1; i++) {
            for (j = 0; j < v.length - 1; j++) {
                if (v[j + 1] < v[j]) {
                    aux = v[j + 1];
                    v[j + 1] = v[j];
                    v[j] = aux;
                }
            }
        }
    }

    public int generaUnAleatorio(int ls, int li) {
        return (int) ((Math.random() * ls - li + 1) + li);
    }

    public void llenarVector() {
        for (int i = 0; i < v.length; i++) {
            this.v[i] = generaUnAleatorio(ls, li);
        }
    }

    public void imprimeVector() {
        for (int i = 0; i < this.v.length; i++) {
            System.out.println(this.v[i]);
        }
    }

    public boolean buscaDato(int num) {
        boolean r = false;
        for (int i = 0; i < this.v.length; i++) {
            if (this.v[i] == num) {
                r = true;
                break;
            }
        }
        return r;
    }

    public double promedio() {
        int aux = 0;
        for (int i = 0; i < v.length; i++) {
            aux += v[i];
        }
        return (double) aux / v.length;
    }

    public int getLs() {
        return ls;
    }

    public void setLs(int ls) {
        this.ls = ls;
    }

    public int getLi() {
        return li;
    }

    public void setLi(int li) {
        this.li = li;
    }

    public static void main(String[] args) {
        Scanner leer = new Scanner(System.in);
        int n, r, d, num, ls, li;
        System.out.println("Dame el numero de espacios que tendra el vector");
        n = leer.nextInt();
        Vector v1 = new Vector(n);
        System.out.println("vamos a llenar los vectores, por favor escriba los valores superiores e inferirores ");
        ls = leer.nextInt();
        li = leer.nextInt();
        v1.ls = ls;
        v1.li = li;
        v1.llenarVector();
        System.out.println("Vector 1");
        v1.imprimeVector();
        System.out.println("Ahora Ordenaremos el vector con el metodo de seleccion");
        v1.ordenaSeleccion();
        v1.imprimeVector();
        System.out.println("Crearemos un nuevo vector y lo ordenaremos con el metodo de burbuja ");
        Vector v2 = new Vector(n);
        v2.li = li;
        v2.ls = ls;
        v2.llenarVector();
        System.out.println("Vector 2");
        v2.imprimeVector();
        v2.ordenaBurbuja();
        v2.imprimeVector();
        System.out.println("Teclee un numero que buscaremos en el vector 1 y en el vector 2");
        num = leer.nextInt();
        System.out.println("El numero en el vector v1 existe?:" + v1.buscaDato(num));
        System.out.println("El numero en el vector v2 existe?:" + v2.buscaDato(num));
        System.out.println("Por ultimo sacaremos el promedio de los vectores v1 y v2");
        System.out.println("El promedio en el vector 1 es:" + v1.promedio());
        System.out.println("El promedio en el vector 2 es:" + v2.promedio());
    }
}