Java常用工具方法及工具类
在平时开发中遇到的各种格式化工具类，整理还在继续中......
目录
二、数值类型保留小数点
三、List去重方式
四、使用AES加解密
五、数字的加、减、乘、除操作
六、Map转实体类
七、获取周或月的开始&结束日期
八、Java8日期时间类（LocalDate）
九、判断是否是数字字符串
一、时间工具类
- 字符串时间格式后返回字符串
- 返回某个时间段内的时分整点时间段
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 formatHour(String startStr, String endStr) {
List 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 = 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() {
List list = new ArrayList<>();
list.add(0);
list.add(0);
list.add(0);
List list1 = new ArrayList<>();
list1.add(0);
list1.add(1);
list1.add(1235);
List list2 = new ArrayList<>();
list2.add(0);
list2.add(2);
list2.add(455);
List list3 = new ArrayList<>();
list3.add(0);
list3.add(3);
list3.add(453);
List l = new ArrayList<>();
l.add(1);
l.add(0);
l.add(0);
List l1 = new ArrayList<>();
l1.add(1);
l1.add(1);
l1.add(1235);
List l2 = new ArrayList<>();
l2.add(1);
l2.add(2);
l2.add(455);
List l3 = new ArrayList<>();
l3.add(1);
l3.add(3);
l3.add(453);
List ll = new ArrayList<>();
ll.add(2);
ll.add(0);
ll.add(0);
List ll1 = new ArrayList<>();
ll1.add(2);
ll1.add(1);
ll1.add(1235);
List ll2 = new ArrayList<>();
ll2.add(2);
ll2.add(2);
ll2.add(455);
List ll3 = new ArrayList<>();
ll3.add(2);
ll3.add(3);
ll3.add(453);
List lll = new ArrayList<>();
lll.add(0);
lll.add(0);
lll.add(0);
List lll1 = new ArrayList<>();
lll1.add(0);
lll1.add(1);
lll1.add(1235);
List lll2 = new ArrayList<>();
lll2.add(0);
lll2.add(2);
lll2.add(455);
List lll3 = new ArrayList<>();
lll3.add(0);
lll3.add(3);
lll3.add(453);
List> 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 flushObject(T t, Map 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;
}
}
}
}
}