Java常用工具方法及工具类

Love The Way You Lie 2022-02-24 12:48 451阅读 0赞

在平时开发中遇到的各种格式化工具类，整理还在继续中......

**目录**

二、数值类型保留小数点

三、List去重方式

四、使用AES加解密

五、数字的加、减、乘、除操作

六、Map转实体类

七、获取周或月的开始&结束日期

八、Java8日期时间类（LocalDate）

九、判断是否是数字字符串

--------------------

一、时间工具类

1.  字符串时间格式后返回字符串
2.  返回某个时间段内的时分整点时间段

package com.example.demo.date;
    
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.List;
    
    /**
     * 路径：com.example.demo.date
     * 类名：DateFormatUtils.java
     * 功能：常用日期类型转换工具类
     * 创建人：typ
     * 创建时间：2019/4/9 22:10
     * 修改人：
     * 修改备注：
     * 修改时间：
     */
    public class DateFormatUtils {
    
        public static void main(String[] args) {
            System.out.println(currentTime());
        }
    
        /**
         * 方法名：currentTime
         * 功能：获取当前时间
         * 描述：返回值为当前的Date值
         * 创建人：typ
         * 创建时间：2019/4/9 22:20
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static Date currentTime(){
            Calendar calendar = Calendar.getInstance();
            return calendar.getTime();
        }
    
        /**
         * 方法名：format
         * 功能：String时间格式化为标准时间格式：yyyy-MM-dd HH:mm:ss
         * 描述：返回值为时间String
         * 创建人：typ
         * 创建时间：2019/4/9 22:14
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static String format(String date) {
            try {
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                return format.format(format.parse(date));
            } catch (Exception e) {
                e.printStackTrace();
            }
            return "";
        }
    
        /**
         * 方法名：formatHour
         * 功能：获取某个时间内的时间段
         * 创建人：typ
         * 创建时间：2019/4/3 9:22
         * 入参：startDate：开始时间,endDate：结束时间
         * 出参：[07:00, 08:00, 09:00, 10:00, 11:00, 12:00, 13:00, 14:00, 15:00, 16:00, 17:00, 18:00, 19:00, 20:00, 21:00]
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static List<String> formatHour(String startStr, String endStr) {
            List<String> list = new ArrayList<>();
            try {
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
                Date startDate = sdf.parse(startStr);
                Date endDate = sdf.parse(endStr);
                SimpleDateFormat format = new SimpleDateFormat("HH:00");
                list.add(format.format(startDate));
                // 设置开始时间
                Calendar start = Calendar.getInstance();
                start.setTime(startDate);
                // 设置结束时间
                Calendar end = Calendar.getInstance();
                end.setTime(endDate);
                while (endDate.after(start.getTime())) {
                    start.add(Calendar.HOUR, 1);
                    list.add(format.format(start.getTime()));
                }
                return list;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return list;
        }
    }

### 二、数值类型保留小数点 ###

将double类型的数值或String类型的数值转为double类型或String类型，四舍五入并保留两位小数。

package com.example.demo.number;
    
    import java.math.BigDecimal;
    import java.text.DecimalFormat;
    
    /**
     * 路径：com.example.demo.number
     * 类名：DecimalPointUtils.java
     * 功能：数值保留小数点
     * 创建人：typ
     * 创建时间：2019/4/9 21:29
     * 修改人：
     * 修改备注：
     * 修改时间：
     */
    public class DecimalPointUtils {
    
        /**
         * 方法名：formatToDouble
         * 功能：double类型数值保留两位小数
         * 描述：返回值为double
         * 创建人：typ
         * 创建时间：2019/4/9 21:44
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static double formatToDouble(double number) {
            BigDecimal bigDecimal = new BigDecimal(number);
            return bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /**
         * 方法名：formatToString
         * 功能：double类型的数值保留两位小数
         * 描述：返回值为String
         * 创建人：typ
         * 创建时间：2019/4/9 21:47
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static String formatToString(double number) {
            DecimalFormat df = new DecimalFormat("#.00");
            return df.format(number);
        }
    
        /**
         * 方法名：formatToStr
         * 功能：double 类型的数值保留两位小数
         * 描述：返回值为String
         * 创建人：typ
         * 创建时间：2019/4/9 21:52
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static String formatToStr(double number) {
            return String.format("%.2f", number);
        }
    
        /**
         * 方法名：formatToStr
         * 功能：String 类型的数值保留两位小数
         * 描述：返回值为String
         * 创建人：typ
         * 创建时间：2019/4/9 22:05
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static String formatToStr(String str){
            if(str != null && str.length() > 0){
                DecimalFormat format = new DecimalFormat("0.00");
                BigDecimal bigDecimal = new BigDecimal(str);
                return format.format(bigDecimal);
            }
            return "0.00";
        }
    
        public static void main(String[] args) {
            System.out.println(formatToStr("0"));
        }
    }

### 三、List去重方式 ###

List去重几种常见方式。

package com.example.demo.number;
    
    import java.util.*;
    
    /**
     * 路径：com.example.demo.number
     * 类名：DuplicateRemovalList
     * 功能：List对象去除重复值
     * 备注：
     * 创建人：typ
     * 创建时间：2019/4/15 20:56
     * 修改人：
     * 修改备注：
     * 修改时间：
     */
    public class DuplicateRemovalUtils {
    
        public static void main(String[] args) {
            List<List<Integer>> list = list();
            removeDuplicateWithOrder(list);
        }
    
        /**
         * 方法名：removeDuplicate
         * 功能：循环list中的所有元素然后删除重复
         * 描述：
         * 创建人：typ
         * 创建时间：2019/4/15 21:50
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static List removeDuplicate(List list) {
            for (int i = 0; i < list.size() - 1; i++) {
                for (int j = list.size() - 1; j > i; j--) {
                    if (list.get(j).equals(list.get(i))) {
                        list.remove(j);
                    }
                }
            }
            return list;
        }
    
        /**
         * 方法名：removeDuplicate1
         * 功能：通过HashSet踢除重复元素
         * 描述：
         * 创建人：typ
         * 创建时间：2019/4/15 21:50
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static List removeDuplicate1(List list) {
            HashSet hashSet = new HashSet(list);
            list.clear();
            list.addAll(hashSet);
            return list;
        }
    
        /**
         * 方法名：removeDuplicate2
         * 功能：把list里的对象遍历一遍，用list.contain()，如果不存在就放入到另外一个list集合中
         * 描述：
         * 创建人：typ
         * 创建时间：2019/4/15 21:52
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static List removeDuplicate2(List list) {
            List listTemp = new ArrayList();
            for (int i = 0; i < list.size(); i++) {
                if (!listTemp.contains(list.get(i))) {
                    listTemp.add(list.get(i));
                }
            }
            return listTemp;
        }
    
        /**
         * 方法名：removeDuplicateWithOrder
         * 功能：删除ArrayList中重复元素，保持顺序
         * 描述：
         * 创建人：typ
         * 创建时间：2019/4/15 21:51
         * 修改人：
         * 修改描述：
         * 修改时间：
         */
        public static List removeDuplicateWithOrder(List list) {
            Set set = new HashSet();
            List newList = new ArrayList();
            for (Iterator iter = list.iterator(); iter.hasNext(); ) {
                Object element = iter.next();
                if (set.add(element))
                    newList.add(element);
            }
            list.clear();
            list.addAll(newList);
            return list;
        }
    
    
        // 数据
        public static List<List<Integer>> list() {
            List<Integer> list = new ArrayList<>();
            list.add(0);
            list.add(0);
            list.add(0);
            List<Integer> list1 = new ArrayList<>();
            list1.add(0);
            list1.add(1);
            list1.add(1235);
            List<Integer> list2 = new ArrayList<>();
            list2.add(0);
            list2.add(2);
            list2.add(455);
            List<Integer> list3 = new ArrayList<>();
            list3.add(0);
            list3.add(3);
            list3.add(453);
    
            List<Integer> l = new ArrayList<>();
            l.add(1);
            l.add(0);
            l.add(0);
            List<Integer> l1 = new ArrayList<>();
            l1.add(1);
            l1.add(1);
            l1.add(1235);
            List<Integer> l2 = new ArrayList<>();
            l2.add(1);
            l2.add(2);
            l2.add(455);
            List<Integer> l3 = new ArrayList<>();
            l3.add(1);
            l3.add(3);
            l3.add(453);
    
            List<Integer> ll = new ArrayList<>();
            ll.add(2);
            ll.add(0);
            ll.add(0);
            List<Integer> ll1 = new ArrayList<>();
            ll1.add(2);
            ll1.add(1);
            ll1.add(1235);
            List<Integer> ll2 = new ArrayList<>();
            ll2.add(2);
            ll2.add(2);
            ll2.add(455);
            List<Integer> ll3 = new ArrayList<>();
            ll3.add(2);
            ll3.add(3);
            ll3.add(453);
    
            List<Integer> lll = new ArrayList<>();
            lll.add(0);
            lll.add(0);
            lll.add(0);
            List<Integer> lll1 = new ArrayList<>();
            lll1.add(0);
            lll1.add(1);
            lll1.add(1235);
            List<Integer> lll2 = new ArrayList<>();
            lll2.add(0);
            lll2.add(2);
            lll2.add(455);
            List<Integer> lll3 = new ArrayList<>();
            lll3.add(0);
            lll3.add(3);
            lll3.add(453);
    
            List<List<Integer>> listList = new ArrayList<>();
            listList.add(list);
            listList.add(list1);
            listList.add(list2);
            listList.add(list3);
    
            listList.add(l);
            listList.add(l1);
            listList.add(l2);
            listList.add(l3);
    
            listList.add(ll);
            listList.add(ll1);
            listList.add(ll2);
            listList.add(ll3);
    
            listList.add(lll);
            listList.add(lll1);
            listList.add(lll2);
            listList.add(lll3);
    
            return listList;
        }
        
    }

### 四、使用AES加解密 ###

package com.demo.util;
    
    import javax.crypto.*;
    import javax.crypto.spec.SecretKeySpec;
    import java.io.UnsupportedEncodingException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    
    /**
     * 类名：AesUtil.java
     * 路径：com.demo.util.AesUtil.java
     * 创建人：tanyp
     * 创建时间：2019/5/5 16:25
     * 功能：使用AES实现加解密
     * 修改人：
     * 修改时间：
     * 修改备注：
     */
    public class AesUtil {
    
        public static void main(String[] args) {
            String content = "g25"; // 加密的字符串
            String addPwd = "123456"; // 加解密密钥
    
            // 加密
            System.out.println("加密前content：" + content);
            String encryptResultStr = encrypt(content, addPwd);
            System.out.println("加密后content：" + encryptResultStr);
            // 解密
            String userAccount = AesUtil.decrypt(encryptResultStr, addPwd);
            System.out.println("解密后content：" + userAccount);
        }
    
    
        /**
         * 方法名：encrypt
         * 功能：加密方法
         * 创建人：tanyp
         * 创建时间：2019/5/5 16:29
         * 入参：
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static String encrypt(String data, String key) {
            byte[] enAccount = encryptIn(data, key);
            String encryptResultStr = parseByte2HexStr(enAccount);
            return encryptResultStr;
        }
    
        /**
         * 方法名：decrypt
         * 功能：解密方法
         * 创建人：tanyp
         * 创建时间：2019/5/5 16:29
         * 入参：
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static String decrypt(String data, String key) {
            byte[] accountFrom = AesUtil.parseHexStr2Byte(data);
            byte[] deAccount = AesUtil.decryptOut(accountFrom, key);
            String userAccount = new String(deAccount);
            return userAccount;
        }
    
        /**
         * 方法名：encryptIn
         * 功能：解密算法
         * 创建人：tanyp
         * 创建时间：2019/5/5 16:30
         * 入参：content：要加密的内容，password：加密使用的密钥
         * 出参：加密后的字节数组
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static byte[] encryptIn(String content, String password) {
            SecureRandom random = null;
            try {
                random = SecureRandom.getInstance("SHA1PRNG");
                random.setSeed(password.getBytes());
            } catch (NoSuchAlgorithmException e1) {
                e1.printStackTrace();
            }
    
            try {
                KeyGenerator kgen = KeyGenerator.getInstance("AES");
                kgen.init(128, random);
                SecretKey secretKey = kgen.generateKey();
                byte[] enCodeFormat = secretKey.getEncoded();
                SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
                Cipher cipher = Cipher.getInstance("AES");// 创建密码器
                byte[] byteContent = content.getBytes("utf-8");
                cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化
                byte[] result = cipher.doFinal(byteContent);
                return result; // 加密
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 方法名：parseByte2HexStr
         * 功能：将二进制转换成16进制 加密
         * 创建人：tanyp
         * 创建时间：2019/5/5 16:31
         * 入参：
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static String parseByte2HexStr(byte buf[]) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < buf.length; i++) {
                String hex = Integer.toHexString(buf[i] & 0xFF);
                if (hex.length() == 1) {
                    hex = '0' + hex;
                }
                sb.append(hex.toUpperCase());
            }
            return sb.toString();
        }
    
        /**
         * 方法名：decryptOut
         * 功能：解密算法
         * 创建人：tanyp
         * 创建时间：2019/5/5 16:32
         * 入参：content：待解密内容，password：解密密钥
         * 出参：解密后的字节数组
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static byte[] decryptOut(byte[] content, String password) {
            SecureRandom random = null;
            try {
                random = SecureRandom.getInstance("SHA1PRNG");
                random.setSeed(password.getBytes());
            } catch (NoSuchAlgorithmException e1) {
                e1.printStackTrace();
            }
            try {
                KeyGenerator kgen = KeyGenerator.getInstance("AES");
                kgen.init(128, random);
                SecretKey secretKey = kgen.generateKey();
                byte[] enCodeFormat = secretKey.getEncoded();
                SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
                Cipher cipher = Cipher.getInstance("AES");// 创建密码器
                cipher.init(Cipher.DECRYPT_MODE, key);// 初始化
                byte[] result = cipher.doFinal(content);
                return result; // 加密
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 方法名：parseHexStr2Byte
         * 功能：将16进制转换为二进制
         * 创建人：tanyp
         * 创建时间：2019/5/5 16:33
         * 入参：
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static byte[] parseHexStr2Byte(String hexStr) {
            if (hexStr.length() < 1){
                return null;
            }
            byte[] result = new byte[hexStr.length() / 2];
            for (int i = 0; i < hexStr.length() / 2; i++) {
                int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
                int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
                result[i] = (byte) (high * 16 + low);
            }
            return result;
        }
    }

### 五、数字的加、减、乘、除操作 ###

/**
     * 类名：NumberUtils.java
     * 路径：com.demo.util.NumberUtils.java
     * 创建人：tanyp
     * 创建时间：2019/5/5 17:02
     * 功能：对数字的操作工具类（加、减、乘、除）
     * 修改人：
     * 修改时间：
     * 修改备注：
     */
    public class NumberUtils {
    
    
        /**
         * 方法名：sub
         * 功能：减法运算
         * 创建人：tanyp
         * 创建时间：2019/5/5 17:05
         * 入参：v1:被减数 ,v2:减数
         * 出参：两个参数的差
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static double sub(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.subtract(b2).doubleValue();
        }
    
        /**
         * 方法名：add
         * 功能：加法运算
         * 创建人：tanyp
         * 创建时间：2019/5/5 17:05
         * 入参：v1:被加数 ,v2:加数
         * 出参：两个参数的和
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static double add(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.add(b2).doubleValue();
        }
    
        /**
         * 方法名：mul
         * 功能：乘法运算
         * 创建人：tanyp
         * 创建时间：2019/5/5 17:06
         * 入参：v1：被乘数，v2：乘数
         * 出参：两个参数的积
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static double mul(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.multiply(b2).doubleValue();
        }
    
        /**
         * 方法名：div
         * 功能：除法运算，当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
         * 创建人：tanyp
         * 创建时间：2019/5/5 17:07
         * 入参：v1：被除数，v2：除数，scale：表示表示需要精确到小数点以后几位
         * 出参：两个参数的商
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static double div(double v1, double v2, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException("The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /**
         * 方法名：isNumeric
         * 功能：是否为整数
         * 创建人：tanyp
         * 创建时间：2019/5/5 17:13
         * 入参：
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static boolean isNumeric(String str) {
            Pattern pattern = Pattern.compile("[0-9]*");
            return pattern.matcher(str).matches();
        }
    
    }

### 六、Map转实体类 ###

/**
     * 类名：MapToObjectUtils.java
     * 路径：com.demo.util.MapToObjectUtils.java
     * 创建人：tanyp
     * 创建时间：2019/5/5 17:02
     * 功能：对数字的操作工具类（加、减、乘、除）
     * 修改人：
     * 修改时间：
     * 修改备注：
     */
    public class MapToObjectUtils {
    
        /**
         * 方法名：flushObject
         * 功能：将Map形式的键值对中的值转换为泛型形参给出的类中的属性值 t一般代表pojo类
         * 创建人：tanyp
         * 创建时间：2019/5/5 17:14
         * 入参：params：键值对Map数据，t：映射实体
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static <T extends Object> T flushObject(T t, Map<String, Object> params) {
            if (params == null || t == null) {
                return t;
            }
    
            Class<?> clazz = t.getClass();
            for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
                try {
                    Field[] fields = clazz.getDeclaredFields();
                    for (int i = 0; i < fields.length; i++) {
                        // 获取属性的名字
                        String name = fields[i].getName();
                        Object value = params.get(name);
                        if (value != null && !"".equals(value)) {
                            // 注意下面这句，不设置true的话，不能修改private类型变量的值
                            fields[i].setAccessible(true);
                            fields[i].set(t, value);
                        }
                    }
                } catch (Exception e) {
                }
            }
            return t;
        }
    }

### 七、获取周或月的开始&结束日期 ###

/**
         * 方法名：getStartDayOfWeekNo
         * 功能：某周的开始日期
         * 创建人：tanyp
         * 创建时间：2019/8/14 13:38
         * 入参：
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static String getStartDayOfWeekNo(int year, int weekNo) {
            Calendar cal = getCalendarFormYear(year);
            cal.set(Calendar.WEEK_OF_YEAR, weekNo);
            String month = (cal.get(Calendar.MONTH) + 1) < 10 ? "0" + (cal.get(Calendar.MONTH) + 1) : String.valueOf(cal.get(Calendar.MONTH) + 1);
            String day = cal.get(Calendar.DAY_OF_MONTH) < 10 ? "0" + cal.get(Calendar.DAY_OF_MONTH) : String.valueOf(cal.get(Calendar.DAY_OF_MONTH));
            return cal.get(Calendar.YEAR) + month + day;
        }
    
        /**
         * 方法名：getEndDayOfWeekNo
         * 功能：某周的结束日期
         * 创建人：tanyp
         * 创建时间：2019/8/14 13:38
         * 入参：
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static String getEndDayOfWeekNo(int year, int weekNo) {
            Calendar cal = getCalendarFormYear(year);
            cal.set(Calendar.WEEK_OF_YEAR, weekNo);
            cal.add(Calendar.DAY_OF_WEEK, 6);
            String month = (cal.get(Calendar.MONTH) + 1) < 10 ? "0" + (cal.get(Calendar.MONTH) + 1) : String.valueOf(cal.get(Calendar.MONTH) + 1);
            String day = cal.get(Calendar.DAY_OF_MONTH) < 10 ? "0" + cal.get(Calendar.DAY_OF_MONTH) : String.valueOf(cal.get(Calendar.DAY_OF_MONTH));
            return cal.get(Calendar.YEAR) + month + day;
        }
    
        private static Calendar getCalendarFormYear(int year) {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
            cal.set(Calendar.YEAR, year);
            return cal;
        }
    
        /**
         * 方法名：getFirstDayOfMonth
         * 功能：获取某月的第一天
         * 创建人：tanyp
         * 创建时间：2019/8/14 13:38
         * 入参：
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static String getFirstDayOfMonth(int year, int month) {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.YEAR, year);
            cal.set(Calendar.MONTH, month - 1);
            int firstDay = cal.getMinimum(Calendar.DATE);
            cal.set(Calendar.DAY_OF_MONTH, firstDay);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            return sdf.format(cal.getTime());
        }
    
        /**
         * 方法名：getLastDayOfMonth
         * 功能：获取某月的最后一天
         * 创建人：tanyp
         * 创建时间：2019/8/14 13:39
         * 入参：
         * 出参：
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static String getLastDayOfMonth(int year, int month) {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.YEAR, year);
            cal.set(Calendar.MONTH, month - 1);
            int lastDay = cal.getActualMaximum(Calendar.DATE);
            cal.set(Calendar.DAY_OF_MONTH, lastDay);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            return sdf.format(cal.getTime());
        }

### 八、Java8日期时间类（LocalDate） ###

package com.demo.utils;
    
    import java.time.LocalDate;
    import java.time.LocalDateTime;
    import java.time.LocalTime;
    import java.time.format.DateTimeFormatter;
    
    /**
     * 类名：LocalDateUtil.java
     * 路径：com.demo.utils.LocalDateUtil.java
     * 创建人：tanyp
     * 创建时间：2019/8/20 11:36
     * 功能：java8 日期格式化及时间计算
     * 修改人：
     * 修改时间：
     * 修改备注：
     */
    public class LocalDateUtil {
    
        public static void main(String[] args) {
            // 获取当前日期(yyyy-MM-dd)
            LocalDate newDate = LocalDate.now();
            System.out.println("当前日期(yyyy-MM-dd)：" + newDate);
    
            // 获取当前时间（HH:mm:sss）
            LocalTime newTime = LocalTime.now();
            System.out.println("当前时间(HH:mm:ss)：" + newTime);
    
            // 获取当前日期时间（yyyy-MM-dd HH:mm:ss）
            LocalDateTime newDateTime = LocalDateTime.now();
            System.out.println("当前日期(yyyy-MM-dd HH:mm:ss)：" + newDateTime);
    
            // 计算时间或日期(plus()、minus())
            // 获取过去n天或未来n天的日期
            LocalDate date7_1 = newDate.minusDays(7);
            LocalDate date7_2 = newDate.plusDays(7);
            System.out.println("获取7天前的日期：" + date7_1 + "，获取7天后的日期：" + date7_2);
    
            // 获取过去n月或未来n月的日期
            LocalDate month7_1 = newDate.minusMonths(7);
            LocalDate month7_2 = newDate.plusMonths(7);
            System.out.println("获取7个月前的日期：" + month7_1 + "，获取7个月后的日期：" + month7_2);
    
            // 备注：在java.time.LocalTime和java.time.LocalDateTime中也有对应的plus()和minus()方法。
    
            // 日期比较（isBefore()、isAfter()），返回true或false
            LocalDate newD = LocalDate.now();
            LocalDate lsatD = newD.plusDays(1);
            if (lsatD.isAfter(newD)) {
                System.out.println("newD小于lsatD");
            } else {
                System.out.println("newD大于lsatD");
            }
    
            if (lsatD.isBefore(newD)) {
                System.out.println("newD大于lsatD");
            } else {
                System.out.println("newD小于lsatD");
            }
    
            // 日期时间格式化（java.time.format.DateTimeFormatter）
            String date1 = newDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
            System.out.println("日期格式化为（yyyy-MM-dd）：" + date1);
    
            String date2 = newDate.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
            System.out.println("日期格式化为（yyyyMMdd）：" + date2);
    
            String date3 = newDate.format(DateTimeFormatter.ofPattern("yyyy-MM"));
            System.out.println("日期格式化为（yyyy-MM）：" + date3);
    
            String date4 = newDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            System.out.println("日期格式化为（yyyy-MM-dd HH:mm:ss）：" + date4);
    
            // 获取基本属性
            int year = newDate.getYear();
            int month = newDate.getMonthValue();
            int week = newDate.getDayOfWeek().getValue();
            System.out.println("获取年份：" + year + ",月份：" + month + "，星期：" + week);
    
            // 计算两个日期之间相差多少天
            LocalDate localDate1 = LocalDate.of(2019, 8, 1);
            LocalDate localDate2 = LocalDate.of(2019, 8, 20);
            int num = (int) (localDate2.toEpochDay() - localDate1.toEpochDay());
            System.out.println("相差天数为：" + num);
    
            // 字符串转日期
            LocalDate date = LocalDate.parse("2019-08-01");
            System.out.println(date);
            // 获取某个时间在这个月的开始时间和结束时间
            LocalDate fistDate = LocalDate.parse("2019-08-28").with(TemporalAdjusters.firstDayOfMonth());
            System.out.println(fistDate);
            LocalDate lastDate = LocalDate.parse("2019-08-28").with(TemporalAdjusters.lastDayOfMonth());
            System.out.println(lastDate);
    
            System.out.println("获取星期："+LocalDate.parse("2019-08-28").getDayOfWeek());
    
            System.out.println("判断是否是闰年："+LocalDate.now().isLeapYear());
    
            System.out.println("每天的开始时间："+ LocalTime.MIN);
            System.out.println("每天的结束时间："+ LocalTime.MAX);
    
            System.out.println("获取毫秒值："+ Instant.now().toEpochMilli());
    
            System.out.println("两个日期的相差天数："+ ChronoUnit.DAYS.between(fistDate,lastDate));
    
            System.out.println("字符串转LocalDateTime："+ LocalDateTime.parse("2019-05-14 21:15:30.555", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
    
            System.out.println("LocalDateTime转字符串："+ DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS").format(LocalDateTime.now()));
    
        }
    }

### 九、判断是否是数字字符串 ###

package com.test;
    
    /**
     * 类名：Test.java
     * 路径：com.test.Numeric.java
     * 创建人：tanyp
     * 创建时间：2019/10/10 9:31
     * 功能：判断是否是数字字符串
     * 修改人：
     * 修改时间：
     * 修改备注：
     */
    public class Numeric{
    
        public static void main(String[] args) {
            String str = null;
            System.out.println(isNumeric(str));
        }
    
        /**
         * 方法名：isNumeric
         * 功能：判断字符串是否是数字
         * 创建人：tanyp
         * 创建时间：2019/10/10 9:44
         * 入参：str：字符串
         * 出参：return：true或false
         * 修改人：
         * 修改时间：
         * 修改备注：
         */
        public static boolean isNumeric(String str) {
            if (str == null || str.length() == 0) {
                return false;
            }
    
            try {
                Integer.parseInt(str);
                return true;
            } catch (NumberFormatException e) {
                try {
                    Double.parseDouble(str);
                    return true;
                } catch (NumberFormatException e1) {
                    try {
                        Float.parseFloat(str);
                        return true;
                    } catch (NumberFormatException e2) {
                        return false;
                    }
                }
            }
        }
    }