Utilitarias para programar en java

Util.java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

public final class Util {

  /** Representación compilada de una expresión regular para números. */
  private static final Pattern NUMBER = Pattern.compile("-?\\d+.\\d+");
  
  private Util() {
  }
  
  public static boolean isNull(Object o) { return o == null; }
  
  /*
   |--------------------------------------------------------------------------
   | S T R I N G S
   |--------------------------------------------------------------------------
   */
  
  /**
   * Valida si una cadena esta vacia o esta es nula.
   *
   * @param str cadena a evaluar
   * @return boolean
   */
  public static boolean isEmpty(CharSequence str) {
    return (str == null || str.length() == 0);
  }
  
  /**
   * Limpia los espacios en blanco de una cadena.
   *
   * @param str cadena a limpiar
   * @return String
   */
  public static String trim(CharSequence str) {
    return (str == null) ? "" : str.toString().trim();
  }
  
  /**
   * Analiza el objeto como una cadena y devuelve el resultado.
   *
   * @param o objeto
   * @return String
   */
  public static String stringOf(Object o) {
    return (o == null) ? "" : o.toString();
  }
  
  /**
   * Devuelve una representación de cadena del {@code double}
   */
  public static String doubleToStr(double real) {
    int entero = (int) real;
    return (entero - real) == 0 ? String.valueOf(entero) : String.valueOf(real);
  }
  
  /**
   * Funcion para concatenear elementos
   * 
   * @param elements
   * @return String
   */
  public static String concat(Object... elements) {
    if (elements == null)  throw new NullPointerException("elements == null");
    final StringBuilder sb = new StringBuilder();
    for (int i = 0; i < elements.length; i++) {
      sb.append(elements[i]);
    }
    return sb.toString();
  }
  
  /**
   * Devuelve una copia de esta cadena que tiene su primera letra en mayúscula,
   * o la cadena original, si está vacía o ya comienza con una letra mayúscula.
   *
   * @param texto a convertir <code>hello world!</code>
   * @return cadena formateada <code>Hello world!</code>
   */
  public static String capitalize(CharSequence texto) {
    if (texto == null) return "";
    for (int i = 0; i < texto.length(); i++) {
      char c = texto.charAt(i);
      if (Character.isUpperCase(c)) break;
      
      if (Character.isLetter(c)) {
        char[] chars = texto.toString().toCharArray();
        chars[i] = Character.toUpperCase(c);
        return new String(chars);
      }
    }
    return texto.toString();
  }
  
  /*
   |--------------------------------------------------------------------------
   | P A R S E   V A R S 
   |--------------------------------------------------------------------------
   */
  
  /**
   * Una alternativa para comprobar que el String solo posee digitos como 
   * caracter siempre es recorre el String y comprobarlo asi.
   * 
   * @param source
   * @return 
   */
  public static boolean isNumber(CharSequence source) {
    if (isEmpty(source)) return Boolean.FALSE;
    return NUMBER.matcher(source).matches();
  }
  
  /**
   * Analiza la cadena como un número int y devuelve el resultado.
   *
   * @param str cadena <code>"12"</code>
   * @return int <code>12</code>
   */
  public static int intOf(CharSequence str) {
    if (isEmpty(str)) return 0;
    try {
      return Integer.parseInt(str.toString());
    } catch(NumberFormatException ignore) {
      return 0;
    }
  }
  public static int intOf(Object o) {
    if (o == null) return 0;
    return (o instanceof Number) 
            ? cast(o, Number.class).intValue()
            : intOf(o.toString());
  }
  
  /**
   * Analiza la cadena como un número long y devuelve el resultado.
   *
   * @param str cadena <code>"12"</code>
   * @return long <code>12L</code>
   */
  public static long longOf(CharSequence str) {
    if (isEmpty(str)) return 0L;
    try {
      return Long.parseLong(str.toString());
    } catch(NumberFormatException ignore) {
      return 0L;
    }
  }
  public static long longOf(Object o) {
    if (o == null) return 0L;
    return (o instanceof Number) 
            ? cast(o, Number.class).longValue()
            : longOf(o.toString());
  }
  
  /**
   * Analiza la cadena como un número float y devuelve el resultado.
   *
   * @param str cadena <code>"12.50"</code>
   * @return float <code>12.50f</code>
   */
  public static float floatOf(CharSequence str) {
    if (isEmpty(str)) return 0f;
    try {
      return Float.parseFloat(str.toString());
    } catch(NumberFormatException ignore) {
      return 0f;
    }
  }
  public static float floatOf(Object o) {
    if (o == null) return 0f;
    return (o instanceof Number) 
            ? cast(o, Number.class).floatValue()
            : floatOf(o.toString());
  }
  
  /**
   * Analiza la cadena como un número doble y devuelve el resultado.
   *
   * @param str cadena <code>"12.50"</code>
   * @return double <code>12.50d</code>
   */
  public static double doubleOf(CharSequence str) {
    if (isEmpty(str)) return 0d;
    try {
      return Double.parseDouble(str.toString());
    } catch(NumberFormatException ignore) {
      return 0d;
    }
  }
  public static double doubleOf(Object o) {
    if (o == null) return 0d;
    return (o instanceof Number) 
            ? cast(o, Number.class).doubleValue() 
            : doubleOf(o.toString());
  }
  
  /**
   * Analiza la cadena como un booleano y devuelve el resultado.
   *
   * @param str cadena <code>"true"</code>
   * @return boolean <code>true</code>
   */
  public static boolean boolOf(CharSequence str){
    if (isEmpty(str)) return Boolean.FALSE;
    try {
      return Boolean.parseBoolean(str.toString());
    } catch(NumberFormatException ignore) {
      return Boolean.FALSE;
    }
  }
  public static boolean boolOf(Object o) {
    if (o == null) return Boolean.FALSE;
    return (o instanceof Boolean) 
            ? cast(o, Boolean.class)
            : boolOf(o.toString());
  }
  
  /**
   * Redondea la cantidad segun los decimales.
   *
   * @param value valor a redondear <code>948.856099955012</code>
   * @param places numero de decimales <code>2</code>
   * @return double redondeado <code>948.86</code>
   */
  public static double roundAvoid(double value, int places) {
    double scale = Math.pow(10, places);
    return Math.round(value * scale) / scale;
  }
  
  /*
   |--------------------------------------------------------------------------
   | C o l l e c t i o n s
   |--------------------------------------------------------------------------
   */
  
  /**
   * Valida si una array esta vacia o es nulo.
   *
   * @param array a evaluar
   * @return boolean
   */
  public static <T> boolean isEmpty(T... array) {
    return (array == null || array.length == 0);
  }
  
  /**
   * Verifica si el índice existe en el array aunque sea nulo.
   *
   * @param <T> arrayContains
   * @param index índice para verificar.
   * @param array Un array con los índices para verificar
   * @return boolean
   */
  public static <T> boolean arrayHasIndex(int index, T[] array) {
    return (index > -1 && array.length > index);
  }
  
  /**
   * Devuelve un arreglo con los elementos dados.
   *
   * @param <T> tipo de array
   * @param elements <code>1, 2, 3, 4, 5, 6, 7</code>
   * @return
   */
  public static <T> T[] arrayOf(T... elements) { return elements; }
  
  /**
   * Devuelve una nueva lista de elementos dados.
   *
   * @param <T> tipo de lista
   * @param elements <code>1, 2, 3, 4, 5, 6, 7</code>
   * @return
   */
  public static <T> List<T> listOf(T... elements) { 
    return arrayListOf(elements);
  }
  
  /**
   * Devuelve un nuevo ArrayList con los elementos dados.
   *
   * @param <T> tipo de lista
   * @param elements <code>1, 2, 3, 4, 5, 6, 7</code>
   * @return
   */
  public static <T> ArrayList<T> arrayListOf(T... elements) {
    if (elements == null)  throw new NullPointerException("elements == null");
    final ArrayList<T> list = new ArrayList<T>(elements.length);
    for (int i = 0; i < elements.length; i++) {
      list.add(elements[i]);
    }
    return list;
  }
  
  /**
   * Devuelve un nuevo HashSet con los elementos dados.
   *
   * @param <T> tipo de lista
   * @param elements <code>1, 2, 3, 4, 5, 6, 7</code>
   * @return
   */
  public static <T> HashSet<T> hashSetOf(T... elements) {
    if (elements == null)  throw new NullPointerException("elements == null");
    final HashSet<T> list = new HashSet<T>(elements.length);
    for (int i = 0; i < elements.length; i++) {
      list.add(elements[i]);
    }
    return list;
  }
  
  /**
   * Devuelve un mapa con los contenidos especificados, dado como una lista de
   * pares donde el primer componente es la clave y el segundo es el valor.
   *
   * @param <K> tipo de clave
   * @param <V> tipo de valor
   * @param namesAndValues contenidos <code>"nombre", "jesus"</code>
   * @return HashMap
   */
  public static <K, V> Map<K, V> mapOf(Object... namesAndValues) {
    return hashMapOf(namesAndValues);
  }
  
  /**
   * Devuelve un nuevo HashMap con los contenidos especificados, dado como una
   * lista de pares donde el primer componente es la clave y el segundo es el
   * valor.
   *
   * @param <K> tipo de clave
   * @param <V> tipo de valor
   * @param namesAndValues contenidos <code>"nombre", "jesus"</code>
   * @return HashMap
   */
  public static <K, V> HashMap<K, V> hashMapOf(Object... namesAndValues) {
    if (namesAndValues == null)  throw new NullPointerException("namesAndValues == null");
    if (namesAndValues.length % 2 != 0) {
      throw new IllegalArgumentException("Expected alternating header names and values");
    }
    final HashMap<K, V> map = new HashMap<K, V>(namesAndValues.length / 2);
    for (int i = 0; i < namesAndValues.length; i += 2) {
      K name = (K) namesAndValues[i];
      V value = (V) namesAndValues[i + 1];
      map.put(name, value);
    }
    return map;
  }
  
  /**
   * Devuelve un nuevo LinkedHashMap con los contenidos especificados, dado como
   * una lista de pares donde el primer componente es la clave y el segundo es
   * el valor.
   *
   * @param <K> tipo de clave
   * @param <V> tipo de valor
   * @param namesAndValues contenidos <code>"nombre", "jesus"</code>
   * @return LinkedHashMap
   */
  public static <K, V> LinkedHashMap<K, V> linkedHashMapOf(Object... namesAndValues) {
    if (namesAndValues == null)  throw new NullPointerException("namesAndValues == null");
    if (namesAndValues.length % 2 != 0) {
      throw new IllegalArgumentException("Expected alternating header names and values");
    }
    final LinkedHashMap<K, V> map = new LinkedHashMap<K, V>(namesAndValues.length / 2);
    for (int i = 0; i < namesAndValues.length; i += 2) {
      K name = (K) namesAndValues[i];
      V value = (V) namesAndValues[i + 1];
      map.put(name, value);
    }
    return map;
  }
  
  /** Covierte un objecto en un mapa. */
  public static LinkedHashMap<String, Object> toMap(Object obj) {
    java.lang.reflect.Field[] fields = obj.getClass().getDeclaredFields();
    LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>(fields.length);
    try {
      for (java.lang.reflect.Field field : fields) {
        map.put(field.getName(), field.get(obj));
      }
    } catch (Exception e){
    }
    return map;
  }
  
  /**
   * Hace un cast del objeto.
   *
   * @param <T> tipo de dato
   * @param obj objeto a mapear
   * @param type tipo de clase
   * @return T
   */
  public static <T> T cast(Object obj, Class<T> type) {
    try {
      return type.cast(obj);
    } catch(ClassCastException ignore) {
      return null;
    }
  }
  public static <T> T cast(Object obj) { 
    return obj == null ? null : (T) obj; 
  }
 
  public static void println() { System.out.println(); }
  public static void println(Object o) { System.out.println(o); }
  public static void print(Object o) { System.out.print(o); }
  public static void printf(String format, Object... values) {
    System.out.printf(format, values);
  }
  
  /** Obtiene la extencion de un archivo. */
  public static String getExtencion(File file) {
    String fileName = file.getName();
    int i = fileName.lastIndexOf('.');
    int p = Math.max(fileName.lastIndexOf('/'), fileName.lastIndexOf('\\'));
    if (i > p) return fileName.substring(i + 1);
    return null;
  }

  public static void closeQuietly(Closeable closeable) {
    if (closeable == null) return;
    try {
      closeable.close();
    } catch (IOException ignore) {
      // empty
    }
  }
  
  public static void main(String[] args) {
    String number = "-892768237.50";
    println(number);
    if (isNumber(number)) {
      printf("ok: %f\n", doubleOf(number));
    } else {
      println("no");
    }
     
    String[] array = {"a","b", "c"};
    if (arrayHasIndex(2, array)) {
      System.out.println(array[2]);
    }
  }
}

Utilitarias para programar cómodamente en Java
° Validar nulos
° Validar cadenas
° Conversiones
° Mapas
° Listas
° Concatenar