/** * 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); }