Validación de Campos en JAVA

Dentro de la clase UtilValidate podrás encontrar multiples métodos que facilitan la validación de campos, dónde se pueden validar largos de campos, números, R.U.T y correo. Esta clase cuenta con expresiones regulares las cuales facilitan la validación de correo y de caracteres extraños dentro de las cadenas.

Clase Util Validate

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Clase que contiene métodos que permite la validación de campos.
 * 
 * @author GRIVAS
 * @version 0.1
 */
public class UtilValidate {

 /**
  * Expresión regular que permite validar el correo/e-mail.
  */
 private static final String PATTERN_EMAIL = "^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
            + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
 /**
  * Expresión regular que permite validar alfanumericos y además contenga puntos o # o @
  */
 private static final String PATTERN_TEXT  = "[^\\w \\xC0-\\xFF\\.\\#\\-\\@\\,]";
 /**
  * Método que indica si el String trae sólo números.
  * 
  * @author GRIVAS
  * @param str String con números.
  * @return true: si el string contiene sólo números.

  *         false: si el string posee algún caracter que no sea número.
  */
 public static boolean esNumero(String str) 
 {
  try {
   Long.parseLong(str);
   return true;
  } catch (Exception e) {
   return false;
  }
 }
 
 /**
  * Método que permite validar un R.U.T
  * 
  * @author GRIVAS
  * @param rut R.U.T a validar.
  * @param dv Digito verificador del R.U.T
  * @return true: si el R.U.T es valido.

  *         false: si el R.U.T no es valido.
  */
    public static boolean validarRut(int rut, char dv)
    {
        int m = 0, s = 1;
        for (; rut != 0; rut /= 10)
        {
            s = (s + rut % 10 * (9 - m++ % 6)) % 11;
        }
        return dv == (char) (s != 0 ? s + 47 : 75);
    }
    
    /**
     * Método que permite validar un correo/e-mail.
     * 
     * @author GRIVAS
     * @param email Cadena de texto con el correo/e-mail.
     * @return true: correo/e-mail es valido. 
 false: correo/e-mail  no es valido.
     */
    public static boolean validarEmail(String email) {
        if(email != null && !email.isEmpty())
        {
         Pattern pattern = Pattern.compile(PATTERN_EMAIL);
            Matcher matcher = pattern.matcher(email);
            return matcher.matches();
        }
        return false;
 
    }
    
    /**
     * Método que permite validar que el largo minimo del campo sea mayor al
     * entregado por parametros y que el largo maximos sea menor o igual que el entregado por parametros.
     * 
 Ejemplo: UtilValidate.validarLargo("1234567890", 0, 10) retorna TRUE.
     * 
 (10 >= "1234567890" > 0 )
     * @author GRIVAS
     * @param cadena Cadena de texto a validar.
     * @param largoMinimo Largo minimo del campo.
     * @param largoMaximo Largo maximo del campo.
     * @return
     */
    public static boolean validarLargo(String cadena,int largoMinimo, int largoMaximo){
     if(cadena != null && !cadena.isEmpty() && validarCadena(cadena)){
      if( largoMaximo >= cadena.length() && cadena.length() > largoMinimo)
       return true;
      }
     return false;
    }
    
    /**
     * Método que permite validar que una cadena de texto
     * solo contenga Letras y Números.
     * 
     * @author GRIVAS
     * @param cadena texto a validar
     * @return
     */
    private static boolean validarCadena(String cadena){
     try {
      Pattern p = Pattern.compile(PATTERN_TEXT);
      Matcher m = p.matcher(cadena);
      return (!m.find());
  } catch (Exception e) {
   return false;
  }
    }
}