/**
* Verifica se o valor informado e vazio. O valor e considerado vazio se for nulo ou se seguir uma
* das condicoes a seguir: se for uma colecao, e considerado vazio se nao tiver elementos; se for
* uma String, e considerada vazia se for igual a um espaco em branco.
*
* @param valor
* @return boolean
*/
public static boolean isValorVazio(Object valor) {
boolean retorno = false;
if (valor instanceof Collection) {
retorno = UtilColecao.isColecaoVazia((Collection) valor);
} else {
retorno =
valor == null || (valor instanceof String && UtilString.isStringVazia(valor.toString()));
}
return retorno;
}
/**
* Retorna uma String com a data formatada de acordo com o formato informado. Para detalhes de
* como deve ser o formato veja a classe java.text.DateFormat
*
* @param data
* @param formato
* @return String
*/
public static String formatar(Date data, String formato) {
synchronized (UtilFormatacao.class) {
String formatoUtilizado = null;
if (UtilString.isStringVazia(formato)) {
formatoUtilizado = FORMATO_DATA_PADRAO;
} else {
formatoUtilizado = formato;
}
formatoData.applyPattern(formatoUtilizado);
return formatoData.format(data);
}
}
/**
* Converte a matricula informada como argumento, removendo consoantes, vogais e caracteres
* especiais, e retorna a parte númerica da matricula.
*
* <p>Retorna o valor numérico da matrícula informada. Se ela começa com "F", "B" ou "A", então o
* primeiro caracter é removido e o restante é convertido em número. Se não começar com uma destas
* letras, é esperado que já seja um número.
*
* @param matriculaString
* @return Integer
*/
public static Integer getMatriculaNumerica(String matriculaString) {
String matricula = matriculaString;
if (!UtilString.isStringVazia(matricula)) {
matricula = matricula.trim();
Pattern pattern = Pattern.compile("\\d");
Matcher matcher = pattern.matcher(matricula);
String codigo = "";
while (matcher.find()) {
codigo = codigo.concat(matcher.group());
}
return Integer.parseInt(codigo);
}
return null;
}
/**
* Converte uma String para Date, de acordo com o formato passado. Se o formato especificado for
* nulo, é assumido como padrão "dd/MM/yyyy".
*
* @param data A data no formato String a ser convertida.
* @param formatoDaData O formato da data.
* @return Valor nulo "null" se a data for nula, ou se ocorrer problemas na conversão. Caso
* contrário, a data de acordo com o formato.
*/
public static Date getStringComoDate(String data, String formatoDaData) {
if (data == null) {
return null;
}
String formato = formatoDaData;
if (UtilString.isStringVazia(formato)) {
formato = FORMATO_DATA_PADRAO;
}
try {
SimpleDateFormat dateFormat = new SimpleDateFormat(formato);
return dateFormat.parse(data);
} catch (ParseException e) {
return null;
}
}
/**
* Verifica se o CPF informado é válido.
*
* @param cpf
* @return boolean
*/
public static boolean isCPFValido(String cpf) {
int dig1;
int dig2;
int digito1;
int digito2;
int resto;
int digitoCPF;
String nDigResult = "";
dig1 = 0;
dig2 = 0;
digito1 = 0;
digito2 = 0;
resto = 0;
for (int nCount = 1; nCount < cpf.length() - 1; nCount++) {
digitoCPF = Integer.valueOf(cpf.substring(nCount - 1, nCount));
// multiplique a ultima casa por 2 a seguinte por 3 a
// seguinte por 4
// e assim por diante.
dig1 = dig1 + (11 - nCount) * digitoCPF;
// para o segundo digito repita o procedimento incluindo o
// primeiro
// digito calculado no passo anterior.
dig2 = dig2 + (12 - nCount) * digitoCPF;
}
// Primeiro resto da divisão por 11.
resto = (dig1 % 11);
// Se o resultado for 0 ou 1 o digito é 0 caso contrário o
// digito é 11
// menos o resultado anterior.
if (resto < 2) {
digito1 = 0;
} else {
digito1 = 11 - resto;
}
dig2 += 2 * digito1;
// Segundo resto da divisão por 11.
resto = (dig2 % 11);
// Se o resultado for 0 ou 1 o digito é 0 caso contrário o
// digito é 11
// menos o resultado anterior.
if (resto < 2) {
digito2 = 0;
} else {
digito2 = 11 - resto;
}
// Digito verificador do CPF que está sendo validado.
String nDigVerific = cpf.substring(cpf.length() - 2, cpf.length());
// Concatenando o primeiro resto com o segundo.
nDigResult = UtilString.concatenar(nDigResult, digito1, digito2); // NOPMD
// comparar o digito verificador do cpf com o primeiro resto + o segundo
// resto.
return nDigVerific.equals(nDigResult);
}
