Contar Vocales y consonantes

Una forma muy simple de contar consonantes y vocales en java, lo hice a pedido de un amigo de República Dominicana. E aquí el código:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author PabloRuiz
 */
public class Contando {

    public static int vocales(Object args0) {
        int consonantes = 0;
        for (int i = 0; i < args0.toString().length(); i++) {
            if (String.valueOf(args0.toString().toLowerCase().charAt(i)).matches("[aeiou]")) {
                consonantes++;
            }
        }
        return consonantes;
    }

    public static int consonantes(Object args0) {
        int consonantes = 0;
        for (int i = 0; i < args0.toString().length(); i++) {
            if (String.valueOf(args0.toString().toLowerCase().charAt(i)).matches("[bcdfghjklmnñpkrstvwxyz]")) {
                consonantes++;
            }
        }
        return consonantes;
    }

    public static void main(String args[]) {

        String[] arreglo_nombres = new String[10];

        arreglo_nombres[0] = "Pedro";
        arreglo_nombres[1] = "Pablo";
        arreglo_nombres[2] = "Andres";
        arreglo_nombres[3] = "Juan";
        arreglo_nombres[4] = "Eliana";
        arreglo_nombres[5] = "Pepe";
        arreglo_nombres[6] = "Jaime";
        arreglo_nombres[7] = "Josue";
        arreglo_nombres[8] = "Maria";
        arreglo_nombres[9] = "Jose";

        for (int i = 0; i < arreglo_nombres.length; i++) {
            System.out.println("El nombre: "+arreglo_nombres[i]+", Contiene; "+vocales(arreglo_nombres[i])+"Vocales y "+consonantes(arreglo_nombres[i])+"Consonantes");
        }
    }
}

Eso es todo, usamos expresiones regulares:

• [aeiou] = Que contenga las letras a,e,i,o,u

Saludos

Validador de Rut en JAVA

Bueno despues de la idea que me a dejado por Twitter @Pablo Videla hice el validador de Rut
E aqui el resultado:

/**
 *
 * @author PabloRuiz
 */
public class ValidadorDeRut {

    /**
     * @param args the command line arguments
     */
    public static Object[] invertir(Object[] array) {
        Object[] invertir_int = new Object[array.length];
        int maximo = array.length;

        for (int i = 0; i < array.length; i++) {
            Object j = array[maximo - 1];
            invertir_int[maximo - 1] = array[i];
            maximo--;
        }
        return invertir_int;
    }

    public boolean isValido(Object rut) throws Exception {
        Object[] array = null;
        int rutSumado = 0;
        boolean is = false;

        if (rut.toString().length() ==  9 ) {</pre>
1            array = new Object[8];
            int b = 1;

            for (int i = 0; i &lt;= 7; i++) {
                array[i] = rut.toString().substring(i, b);
                b++;
            }
            array = invertir(array);

            int a = 2;
            for (int i = 0; i &lt; array.length; i++) {
                array[i] = Integer.parseInt((String) array[i]) * a;
                rutSumado += Integer.parseInt(String.valueOf(array[i]));
                if (a == 7) {
                    a = 1;
                }
                a++;
            }

            int resto = rutSumado % 11;
            String Digito = String.valueOf(11 - resto);

            for (int i = 0; i &lt; array.length; i++) {
                Object object = array[i];
            }

            if (Digito.equals("11")) {
                Digito = "0";
            }
            if (Digito.equals("10")) {
                Digito = "K";
            }

            String digitoIngresado = rut.toString().substring(8, 9);

            if (digitoIngresado.equals(Digito)) {
                is = true;
            } else {
                is = false;
            }

        } else if (rut.toString().length()==8) {
            array = new Object[7];
            int b = 1;

            for (int i = 0; i &lt;= 6; i++) {
                array[i] = rut.toString().substring(i, b);
                b++;
            }
            array = invertir(array);

            int a = 2;
            for (int i = 0; i &lt; array.length; i++) {
                array[i] = Integer.parseInt((String) array[i]) * a;
                rutSumado += Integer.parseInt(String.valueOf(array[i]));
                if (a == 7) {
                    a = 1;
                }
                a++;
            }

            int resto = rutSumado % 11;
            String Digito = String.valueOf(11 - resto);

            for (int i = 0; i &lt; array.length; i++) {
                Object object = array[i];
            }

            if (Digito.equals("11")) {
                Digito = "0";
            }
            if (Digito.equals("10")) {
                Digito = "K";
            }

            String digitoIngresado = rut.toString().substring(7, 8);

            if (digitoIngresado.equals(Digito)) {
                is = true;
            } else {
                is = false;
            }
        } else {
            throw new Exception("Error interno");
        }
        return is;
    }
}

Para usarlo nada mas tienen que hacer la instancia a la clase y listo, retorna TRUE(si es correcto), FALSE(si no es correto)

public static void main(String args[]) throws Exception {
     ValidadorDeRut a = new ValidadorDeRut();
     System.out.println("Es correcto? : " + a.isValido(62820012));
    }

Invertir Arreglo en JAVA

1. Llene un vector de numeros reales, escriba un metodo que ordene los elementos

del vector de mayor a menor.

Respuesta:

Haremos una clase llamada InvertirArray que tendra lo siguiente

Informacion:
• Dos metodos (main(String args[]), invertir(Object[] array))
• El metodo invertir recibe cualquier tipo de dato y lo invierte, puedes usar String, byte, int, etc
• Lo que hace invertir como su nombre lo dice invierte creando una variable invertir_int

  la cual crea un array de object con el largo del arreglo ingresado por parametros

  esto se hace asi para tener la dimension del arreglo que se esta ingresando al momento de

  hacer uso del metodo

• Tenemos una variable maximo que tiene el tamanio maximo de arreglo ingresado por parametros
• Creamos un for para recorrer el arreglo ingresado
• Dentro del for declaramos un object llamado j y le vamos dando el valor que venga de la posicion [maximo-1] (Recordar que maximo tiene la ultima posicion del arreglo ingresado)
• luego a invertir_int le damos la posicion [maximo-1] y vamos dandole el valor del arreglo en la posicion [i] y luego restamos 1 a maximo
• Y como lo explique en el anterior ejemplo hacemos uso de un for, un switch
• Usamos tambien “try” para capturar excepciones que quizas se productan a momento de ejecucion

/**
 *
 * @author PabloRuiz
 */

public class InvertirArray {

    private static Object[] invertir_int;

    public static void invertir(Object[] array) {
        invertir_int = new Object[array.length];
        int maximo = array.length;

        for (int i = 0; i < array.length; i++) {
            Object j = array[maximo - 1];
            invertir_int[maximo - 1] = array[i];
            maximo--;
        }
    }

    public static Object[] getArreglo_invertido() {
        return InvertirArray.invertir_int;
    }

    public static void main(String args[]) {
        Object[] arreglo = new Object[5];
        arreglo[0] = 0;
        arreglo[1] = 1;
        arreglo[2] = 2;
        arreglo[3] = 3;
        arreglo[4] = 4;

        for (int i = 0; i < arreglo.length; i++) {
            Object j = arreglo[i];
            System.out.println("Arreglo Normal: " + j);
        }

        try {
            invertir(arreglo);
        } catch (Exception e) {
             System.out.println("Error: "+e.getMessage());
        }

        for (int i = 0; i < invertir_int.length; i++) {
            Object j = invertir_int[i];
            System.out.println("Arreglo invertido: " + j);
        }
    }

}