ConvertUtil数据转化工具类

你的名字 2023-10-08 09:46 58阅读 0赞 
  1. import java.io.ByteArrayInputStream;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.math.BigDecimal;
  7. import java.math.BigInteger;
  8. import java.text.ParseException;
  9. import java.text.SimpleDateFormat;
  10. import java.util.ArrayList;
  11. import java.util.Arrays;
  12. import java.util.Date;
  13. import java.util.HashSet;
  14. import java.util.List;
  15. import java.util.Set;
  17. import com.google.common.collect.Lists;
  19. public class ConvertUtil {
  21.     public static void main(String[] args) {
  22.         List<String> list = Lists.newArrayList();
  23.         list.add(null);
  25.         for (int i = 0; i < 10; i++) {
  26.             list.add(String.valueOf(i));
  27.         }
  29.         System.out.println(list2String(list, ","));
  31.         System.out.println(obj2Double(""));
  32.     }
  34.     @SuppressWarnings("unchecked")
  35.     public static <T> List<T> array2List(T... src) {
  36.         if (src == null || src.length <= 0) {
  37.             return null;
  38.         }
  40.         // return Stream.of(src).collect(Collectors.toList());
  41.         List<T> result = new ArrayList<T>();
  42.         for (T t : src) {
  43.             if (t == null) {
  44.                 continue;
  45.             }
  46.             result.add(t);
  47.         }
  48.         return result;
  49.     }
  51.     @SuppressWarnings("unchecked")
  52.     public static <T> Set<T> array2Set(T... src) {
  53.         if (src == null || src.length <= 0) {
  54.             return null;
  55.         }
  57.         // return Stream.of(src).collect(Collectors.toSet());
  58.         Set<T> result = new HashSet<T>();
  59.         for (T t : src) {
  60.             if (t == null) {
  61.                 continue;
  62.             }
  63.             result.add(t);
  64.         }
  65.         return result;
  66.     }
  68.     public static byte[] obj2bytes(Object src) throws IOException {
  69.         if (src == null) {
  70.             return null;
  71.         }
  72.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  73.         ObjectOutputStream output = new ObjectOutputStream(out);
  74.         output.writeObject(src);
  75.         byte[] result = out.toByteArray();
  76.         output.close();
  77.         out.close();
  78.         return result;
  79.     }
  81.     public static Object bytes2obj(byte[] src) throws IOException, ClassNotFoundException {
  82.         if (src == null) {
  83.             return null;
  84.         }
  85.         ByteArrayInputStream in = new ByteArrayInputStream(src);
  86.         ObjectInputStream input = new ObjectInputStream(in);
  87.         Object result = input.readObject();
  88.         input.close();
  89.         in.close();
  90.         return result;
  91.     }
  93.     public static long date2sec(Date src) {
  94.         if (src == null) {
  95.             return 0;
  96.         }
  97.         return src.getTime() / 1000;
  98.     }
  100.     public static Date sec2Date(Long src) {
  101.         if (src == null) {
  102.             return null;
  103.         }
  104.         return new Date(src * 1000);
  105.     }
  107.     public static long yuan2cent(Double src) {
  108.         if (src == null) {
  109.             return 0;
  110.         }
  111.         BigDecimal bd1 = BigDecimal.valueOf(src);
  112.         BigDecimal bd2 = BigDecimal.valueOf(100);
  113.         return bd1.multiply(bd2).longValue();
  114.     }
  116.     public static double cent2yuan(Long src) {
  117.         if (src == null) {
  118.             return 0;
  119.         }
  120.         BigDecimal bd1 = BigDecimal.valueOf(src);
  121.         BigDecimal bd2 = BigDecimal.valueOf(100);
  122.         return bd1.divide(bd2).doubleValue();
  123.     }
  125.     public static List<String> string2List(String src, String separator) {
  126.         if (src == null) {
  127.             return null;
  128.         }
  129.         if (separator == null) {
  130.             return null;
  131.         }
  132.         String[] strings = src.split(separator);
  133.         return Arrays.asList(strings);
  134.         // return Stream.of(strings).collect(Collectors.toList());
  135.     }
  137.     public static String list2String(List<String> src, String delimiter) {
  138.         if (src == null) {
  139.             return null;
  140.         }
  141.         if (delimiter == null) {
  142.             return null;
  143.         }
  144.         return String.join(delimiter, src);
  145.     }
  147.     public static String obj2String(Object src) {
  148.         if (src == null) {
  149.             return null;
  150.         }
  151.         return src.toString();
  152.     }
  154.     public static Date obj2Date(Object src) throws ParseException {
  155.         if (src == null) {
  156.             return null;
  157.         }
  158.         if (src instanceof Date) {
  159.             return (Date) src;
  160.         }
  161.         if (src instanceof String) {
  162.             String s = src.toString();
  163.             if ("".equals(s)) {
  164.                 return null;
  165.             }
  166.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  167.             return sdf.parse(s);
  168.         }
  169.         return null;
  170.     }
  172.     public static BigInteger obj2BigInteger(Object src) {
  173.         if (src == null) {
  174.             return null;
  175.         }
  176.         if (src instanceof BigInteger) {
  177.             return (BigInteger) src;
  178.         }
  179.         if (src instanceof String) {
  180.             String s = src.toString();
  181.             if ("".equals(s)) {
  182.                 return null;
  183.             }
  184.             return new BigInteger(s);
  185.         }
  186.         return null;
  187.     }
  189.     public static byte obj2byte(Object src) {
  190.         Byte n = obj2Byte(src);
  191.         if (n == null) {
  192.             return 0;
  193.         }
  194.         return n.byteValue();
  195.     }
  197.     public static Byte obj2Byte(Object src) {
  198.         if (src == null) {
  199.             return null;
  200.         }
  201.         if (src instanceof Number) {
  202.             return ((Number) src).byteValue();
  203.         }
  204.         if (src instanceof String) {
  205.             String s = src.toString();
  206.             if ("".equals(s)) {
  207.                 return null;
  208.             }
  209.             return Byte.parseByte(s);
  210.         }
  211.         return null;
  212.     }
  214.     public static short obj2short(Object src) {
  215.         Short n = obj2Short(src);
  216.         if (n == null) {
  217.             return 0;
  218.         }
  219.         return n.shortValue();
  220.     }
  222.     public static Short obj2Short(Object src) {
  223.         if (src == null) {
  224.             return null;
  225.         }
  226.         if (src instanceof Number) {
  227.             return ((Number) src).shortValue();
  228.         }
  229.         if (src instanceof String) {
  230.             String s = src.toString();
  231.             if ("".equals(s)) {
  232.                 return null;
  233.             }
  234.             return Short.parseShort(s);
  235.         }
  236.         return null;
  237.     }
  239.     public static int obj2int(Object src) {
  240.         Integer n = obj2Integer(src);
  241.         if (n == null) {
  242.             return 0;
  243.         }
  244.         return n.intValue();
  245.     }
  247.     public static Integer obj2Integer(Object src) {
  248.         if (src == null) {
  249.             return null;
  250.         }
  251.         if (src instanceof Number) {
  252.             return ((Number) src).intValue();
  253.         }
  254.         if (src instanceof String) {
  255.             String s = src.toString();
  256.             if ("".equals(s)) {
  257.                 return null;
  258.             }
  259.             return Integer.parseInt(s);
  260.         }
  261.         return null;
  262.     }
  264.     public static long obj2long(Object src) {
  265.         Long n = obj2Long(src);
  266.         if (n == null) {
  267.             return 0;
  268.         }
  269.         return n.longValue();
  270.     }
  272.     public static Long obj2Long(Object src) {
  273.         if (src == null) {
  274.             return null;
  275.         }
  276.         if (src instanceof Number) {
  277.             return ((Number) src).longValue();
  278.         }
  279.         if (src instanceof String) {
  280.             String s = src.toString();
  281.             if ("".equals(s)) {
  282.                 return null;
  283.             }
  284.             return Long.parseLong(s);
  285.         }
  286.         return null;
  287.     }
  289.     public static float obj2float(Object src) {
  290.         Float n = obj2Float(src);
  291.         if (n == null) {
  292.             return 0;
  293.         }
  294.         return n.floatValue();
  295.     }
  297.     public static Float obj2Float(Object src) {
  298.         if (src == null) {
  299.             return null;
  300.         }
  301.         if (src instanceof Number) {
  302.             return ((Number) src).floatValue();
  303.         }
  304.         if (src instanceof String) {
  305.             String s = src.toString();
  306.             if ("".equals(s)) {
  307.                 return null;
  308.             }
  309.             return Float.parseFloat(s);
  310.         }
  311.         return null;
  312.     }
  314.     public static double obj2double(Object src) {
  315.         Double n = obj2Double(src);
  316.         if (n == null) {
  317.             return 0;
  318.         }
  319.         return n.doubleValue();
  320.     }
  322.     public static Double obj2Double(Object src) {
  323.         if (src == null) {
  324.             return null;
  325.         }
  326.         if (src instanceof Number) {
  327.             return ((Number) src).doubleValue();
  328.         }
  329.         if (src instanceof String) {
  330.             String s = src.toString();
  331.             if ("".equals(s)) {
  332.                 return null;
  333.             }
  334.             return Double.parseDouble(s);
  335.         }
  336.         return null;
  337.     }
  339.     public static Boolean obj2Boolean(Object src) {
  340.         if (src == null) {
  341.             return null;
  342.         }
  343.         if (src instanceof Boolean) {
  344.             return (Boolean) src;
  345.         }
  346.         Integer n = obj2Integer(src);
  347.         if (n == null) {
  348.             return null;
  349.         }
  350.         if (n > 0) {
  351.             return Boolean.TRUE;
  352.         }
  353.         return Boolean.FALSE;
  354.     }
  355. }

发表评论

表情：
评论列表 （有 0 条评论，58人围观）

还没有评论，来说两句吧...

相关阅读