Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.s1.objects;
  
  
 import java.util.*;

Object helper

This class contains static methods to work with java.util.Map containing another maps or lists (java.util.List) or just simple types.

 
 public class Objects {

    

Parameters:
date
format
Returns:
 
     public static Date parseDate(String dateString format) {
         try {
             return new SimpleDateFormat(format).parse(date);
         } catch (ParseException e) {
             throw S1SystemError.wrap(e);
         }
     }

    

Parameters:
date
format
Returns:
 
     public static String formatDate(Date dateString format) {
         return new SimpleDateFormat(format).format(date);
     }

    
Create map from array (must contains even elements count name1,value1,name2,value2...) if contains odd elements - last will be null

Parameters:
args
Returns:
 
     public static <K, V> Map<K, V> newHashMap(Object... args) {
         Map<K, V> m = new HashMap<K, V>();
         for (int i = 0; i < args.lengthi += 2) {
             m.put((K) args[i], i + 1 >= args.length ? null : (V) args[i + 1]);
         }
         return m;
     }

    

Parameters:
k
v
args
<K>
<V>
Returns:
 
     public static <K, V> Map<K, V> newHashMap(Class<K> kClass<V> vObject... args) {
         Map<K, V> m = new HashMap<K, V>();
         for (int i = 0; i < args.lengthi += 2) {
             m.put((K) args[i], i + 1 >= args.length ? null : (V) args[i + 1]);
         }
         return m;
     }

    

Parameters:
args
<T>
Returns:
 
     public static <T> List<T> newArrayList(T... args) {
         List<T> l = new ArrayList<T>();
         for (int i = 0; i < args.lengthi++) {
             l.add(args[i]);
         }
         return l;
     }

    

Parameters:
t
args
<T>
Returns:
 
     public static <T> List<T> newArrayList(Class<T> t, T... args) {
         List<T> l = new ArrayList<T>();
         for (int i = 0; i < args.lengthi++) {
             l.add(args[i]);
         }
         return l;
     }

    

Parameters:
c
cl
<T>
Returns:
    public static <T> T find(Collection<T> cClosure<T, Booleancl) {
        for (T el : c) {
            if (cl.callQuite(el)) {
                return el;
            }
        }
        return null;
    }

    

Parameters:
c
cl
<T>
Returns:
    public static <T> List<T> findAll(Collection<T> cClosure<T, Booleancl) {
        List<T> l = new ArrayList<T>();
        for (T el : c) {
            if (cl.callQuite(el)) {
                l.add(el);
            }
        }
        return l;
    }

    

Parameters:
c
cl
<K>
<V>
Returns:
    public static <K, V> Map.Entry<K, V> find(Map<K, V> cClosure<Map.Entry<K, V>, Booleancl) {
        return find(c.entrySet(), cl);
    }

    

Parameters:
c
cl
<K>
<V>
Returns:
    public static <K, V> List<Map.Entry<K, V>> findAll(Map<K, V> cClosure<Map.Entry<K, V>, Booleancl) {
        return findAll(c.entrySet(), cl);
    }

    
Copy object deeply

Parameters:
orig
Returns:
    public static <T> T copy(T orig) {
        if (orig == null)
            return null;
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(orig);
            oos.flush();
            ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bin);
            return (T) ois.readObject();
        } catch (Exception e) {
            throw S1SystemError.wrap(e);
        }
    }

    
Returns true if object is null or empty

Parameters:
obj
Returns:
    public static boolean isNullOrEmpty(Object obj) {
        if (obj == null)
            return true;
        if (obj instanceof String) {
            return (((Stringobj).isEmpty());
        }
        if (obj instanceof Map) {
            return ((Mapobj).isEmpty();
        }
        if (obj instanceof List) {
            return ((Listobj).isEmpty();
        }
        if (obj instanceof Set) {
            return ((Setobj).isEmpty();
        }
        return false;
    }

    
Returns true if objects are equals by value

Parameters:
o1
o2
Returns:
    public static boolean equals(Object o1Object o2) {
        if (o1 == o2)
            return true;
        if (o1 == null && o2 == null)
            return true;
        if (o1 == null || o2 == null)
            return false;
        //number
        if (!o1.getClass().equals(o2.getClass()) && (o1 instanceof Number || o2 instanceof Number)) {
            try {
                BigDecimal b1 = cast(o1BigDecimal.class);
                BigDecimal b2 = cast(o2BigDecimal.class);
                return b1.compareTo(b2)==0;
            } catch (Throwable e) {
                return false;
            }
        }
        //map
        if (o1 instanceof Map && o2 instanceof Map) {
            return diff((Map<StringObject>) o1, (Map<StringObject>) o2).size() == 0;
        } else if (o1 instanceof List && o2 instanceof List) {
            Map<StringObjectm1 = newHashMap("list"o1);
            Map<StringObjectm2 = newHashMap("list"o2);
            return diff(m1m2).size() == 0;
        } else {
            return o1.equals(o2);
        }
    }


    
Resolves type and returns casted object

Parameters:
obj
type
Returns:
    public static <T> T cast(Object objString type) {
        return (T) cast(objresolveType(type));
    }
    public static <T> T cast(Object objClass<T> type) {
        return ObjectType.cast(objtype);
    }
    public static Class resolveType(String type) {
        return ObjectType.resolveType(type);
    }
    public static void set(Map<StringObjectdataString pathObject val) {
        ObjectPath.set(datapathval);
    }
    public static <T> T get(Class<T> clMap<StringObjectdataString path) {
        return get(cldatapathnull);
    }
    public static <T> T get(Class<T> clMap<StringObjectdataString path, T def) {
        return cast(get(datapathdef), cl);
    }
    public static <T> T get(Map<StringObjectdataString path) {
        return get(datapathnull);
    }
    public static <T> T get(Map<StringObjectdataString path, T def) {
        return ObjectPath.get(datapathdef);
    }
    public static Map<StringObjectmerge(Map<StringObject>... args) {
        return ObjectMerge.merge(args);
    }
    public static Map<StringObjectmerge(List<Map<StringObject>> args) {
        return ObjectMerge.merge(args);
    }
    public static List<ObjectDiff.DiffBeandiff(Map<StringObjectoldObjectMap<StringObjectnewObject) {
        return ObjectDiff.diff(oldObjectnewObject);
    }
    public static Map<StringObjectiterate(Map<StringObjectdataClosure<ObjectIterator.IterateBeanObjectcl) {
        return ObjectIterator.iterate(datacl);
    }
    public static Map<StringObjecttoWire(Map<StringObjectdata) {
        return ObjectWire.toWire(data);
    }
    public static Map<StringObjectfromWire(Map<StringObjectdata) {
        return ObjectWire.fromWire(data);
    }
New to GrepCode? Check out our FAQ X