1、Java数据类型
/** * 1、基本数据类型的变量： * * 1）、整数类型：byte（1字节=8bit），short（2字节），int（4字节），long（8字节） * * 2）、浮点数类型：float（4字节），double（8字节） * * 3）、字符类型：char（2字节）----Unicode码 * * 4）、布尔类型：boolean（未指定字节数）----true和false * * 2、引用数据类型的变量： * * 除了基本类型（primitive type）和枚举类型（enumeration type），剩下的都是引用类型，比如String。 * */
/** * 包装类： * 1、基本包装类 * Boolean * Byte * Short * Character * Long * Integer * Float * Double * * 2、高精度数字 * BigDecimal * BigInteger * */
/** * 1、自动类型转换 * byte 、char 、short --> int --> long --> float --> double * * 2、强制类型转换 * 使用强转符：()，可能导致精度损失 * */
1、MAIN方法
import com.iven.data.utils.DataConversionUtil; import com.iven.data.utils.DateUtil; import java.util.Date; /** * JVM的基本了解: * 1、方法区内存：存储字节码代码片段、静态变量 * 2、堆内存：new实例变量、数组 * 3、栈内存：局部变量 * */ public class DataTypeDemo { /** * Demo01: 基本数据类型的注意 * */ public static void basicDataDemo(){ /** * 1、声明long型变量，必须以l或L结尾,其整数默认是int类型（易超出其取值范围而报错） * 2、需注意数据的取值范围 * （1）、byte的取值范围：-128~127(-2^7~2^7-1) * （2）、short的取值范围：-32768 ~ 32767（-2^15~2^15-1） * （3）、int取值范围：-2147483648 ~ 2147483647（-2^31~2^31-1） * （4）、。。。。。。 * 3、浮点型默认是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型会造成精度损失，因此需要强制类型转换 * 4、整数默认是int类型 */ //错误： //long l = 2147483648; long l = 2147483648L; //byte b=128; byte b=28; //丢失精度,两种解决方案 //float f=1.2; float f1=1.2f; float f2=(float) 1.2; //丢失精度 //short s1 = 1; //s1 = s1 + 1; short s1 = 1; short s2 = 1; s1 = (short)(s1 + 1); //有隐含的强制类型转换,推荐使用 s2 +=1; System.out.println(l); System.out.println(b); System.out.println(f1); System.out.println(f2); System.out.println(s1); System.out.println(s2); } /** * Demo02: String引用数据类型的注意 * */ public static void stringDataDemo(){ /** * 1、String s1 = 123; * 在静态区的“123”（字符串常量池）创建了一个对象 * 2、String s2 = new String(123); * 创建了二个对象：一个在静态区的“123”（字符串常量池）对象，一个是用new创建在堆上的对象 * */ String s1 = 123; String s2 = new String(123); System.out.println(s1 == s2); //false String s3 = 123456; String s4 = 123 + 456; System.out.println(s3 == s4); //true String s5 = s1 + 456; System.out.println(s5 == s4); //false /** * String类型是只读字符串，字符串内容不允许改变 * Stringbuffer/ Stringbulider表示字符串对象可以修改 * 1、 Stringbuffer：有synchronized关键字修饰，表示线程安全的，效率低 * 2、 Stringbulider：无synchronized关键字修饰，表示非线程安全的，效率高 * 开发建议使用：Stringbuffer》Stringbulider》String * */ String a = new String(123); StringBuffer b = new StringBuffer(123); b.append(456); //字符串a不允许修改 System.out.println(a:+ a); System.out.println(b:+ b); } /** * Demo03: 数据间转换的注意 * */ public static void dataConversionDemo(){ /** * 数据转换工具类:DataConversionUtil * 1、自动装箱：自动将基本数据类型转换为包装器类型 * 2、自动拆箱：自动将包装器类型转换为基本数据类型 * 3、声明包装类可以避免空指针异常 * */ String a =123; int b; int c; //利用包装类实现自动装箱与自动拆箱，即数据类型转换 b = Integer.parseInt(a); //调用工具类的静态方法 c = DataConversionUtil.toInt(a); System.out.println(b); System.out.println(c); int d =123; String e ; String f ; e = DataConversionUtil.toStr(d); f = String.valueOf(d); System.out.println(e); System.out.println(f); Integer i = null; System.out.println(i); //报错 //int j = null; //System.out.println(j); } /** * Demo04: 日期类型使用的注意 * */ public static void dateUsingDemo(){ /** * 日期相关工具类:DateUtil * */ //输出：Fri May 13 21:43:49 CST 2022 Date date = new Date(); System.out.println(date); //转换格式： //取得当前日期的字符串表现形式 String d = DateUtil.getDate(); System.out.println(d); } public static void main(String[] args) { //静态方法不需要实例化 basicDataDemo(); stringDataDemo(); dataConversionDemo(); dateUsingDemo(); System.out.println(结束); } }
2、数据转换工具类
import java.math.BigDecimal; import java.math.BigInteger; import java.nio.ByteBuffer; import java.nio.charset.Charset; import java.text.NumberFormat; import java.util.Set; import org.apache.commons.lang3.ArrayUtils; import org.apache.commons.lang3.StringUtils; /** * 数据转换工具类 */ public class DataConversionUtil { /** * 转换为字符串<br> * 如果给定的值为null，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static String toStr(Object value, String defaultValue) { if (null == value) { return defaultValue; } if (value instanceof String) { return (String) value; } return value.toString(); } /** * 转换为字符串<br> * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static String toStr(Object value) { return toStr(value, null); } /** * 转换为字符<br> * 如果给定的值为null，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static Character toChar(Object value, Character defaultValue) { if (null == value) { return defaultValue; } if (value instanceof Character) { return (Character) value; } final String valueStr = toStr(value, null); return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0); } /** * 转换为字符<br> * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static Character toChar(Object value) { return toChar(value, null); } /** * 转换为byte<br> * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static Byte toByte(Object value, Byte defaultValue) { if (value == null) { return defaultValue; } if (value instanceof Byte) { return (Byte) value; } if (value instanceof Number) { return ((Number) value).byteValue(); } final String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } try { return Byte.parseByte(valueStr); } catch (Exception e) { return defaultValue; } } /** * 转换为byte<br> * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static Byte toByte(Object value) { return toByte(value, null); } /** * 转换为Short<br> * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static Short toShort(Object value, Short defaultValue) { if (value == null) { return defaultValue; } if (value instanceof Short) { return (Short) value; } if (value instanceof Number) { return ((Number) value).shortValue(); } final String valueStr = toStr(value, null); if (StringUtils.isBlank(valueStr)) { return defaultValue; } try { return Short.parseShort(valueStr.trim()); } catch (Exception e) { return defaultValue; } } /** * 转换为Short<br> * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static Short toShort(Object value) { return toShort(value, null); } /** * 转换为Number<br> * 如果给定的值为空，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static Number toNumber(Object value, Number defaultValue) { if (value == null) { return defaultValue; } if (value instanceof Number) { return (Number) value; } final String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } try { return NumberFormat.getInstance().parse(valueStr); } catch (Exception e) { return defaultValue; } } /** * 转换为Number<br> * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static Number toNumber(Object value) { return toNumber(value, null); } /** * 转换为int<br> * 如果给定的值为空，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static Integer toInt(Object value, Integer defaultValue) { if (value == null) { return defaultValue; } if (value instanceof Integer) { return (Integer) value; } if (value instanceof Number) { return ((Number) value).intValue(); } final String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } try { return Integer.parseInt(valueStr.trim()); } catch (Exception e) { return defaultValue; } } /** * 转换为int<br> * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static Integer toInt(Object value) { return toInt(value, null); } /** * 转换为Integer数组<br> * * @param str 被转换的值 * @return 结果 */ public static Integer[] toIntArray(String str) { return toIntArray(,, str); } /** * 转换为Long数组<br> * * @param str 被转换的值 * @return 结果 */ public static Long[] toLongArray(String str) { return toLongArray(,, str); } /** * 转换为Integer数组<br> * * @param split 分隔符 * @param split 被转换的值 * @return 结果 */ public static Integer[] toIntArray(String split, String str) { if (StringUtils.isEmpty(str)) { return new Integer[]{}; } String[] arr = str.split(split); final Integer[] ints = new Integer[arr.length]; for (int i = 0; i < arr.length; i++) { final Integer v = toInt(arr[i], 0); ints[i] = v; } return ints; } /** * 转换为Long数组<br> * * @param split 分隔符 * @param str 被转换的值 * @return 结果 */ public static Long[] toLongArray(String split, String str) { if (StringUtils.isEmpty(str)) { return new Long[]{}; } String[] arr = str.split(split); final Long[] longs = new Long[arr.length]; for (int i = 0; i < arr.length; i++) { final Long v = toLong(arr[i], null); longs[i] = v; } return longs; } /** * 转换为String数组<br> * * @param str 被转换的值 * @return 结果 */ public static String[] toStrArray(String str) { return toStrArray(,, str); } /** * 转换为String数组<br> * * @param split 分隔符 * @param split 被转换的值 * @return 结果 */ public static String[] toStrArray(String split, String str) { return str.split(split); } /** * 转换为long<br> * 如果给定的值为空，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static Long toLong(Object value, Long defaultValue) { if (value == null) { return defaultValue; } if (value instanceof Long) { return (Long) value; } if (value instanceof Number) { return ((Number) value).longValue(); } final String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } try { // 支持科学计数法 return new BigDecimal(valueStr.trim()).longValue(); } catch (Exception e) { return defaultValue; } } /** * 转换为long<br> * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static Long toLong(Object value) { return toLong(value, null); } /** * 转换为double<br> * 如果给定的值为空，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static Double toDouble(Object value, Double defaultValue) { if (value == null) { return defaultValue; } if (value instanceof Double) { return (Double) value; } if (value instanceof Number) { return ((Number) value).doubleValue(); } final String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } try { // 支持科学计数法 return new BigDecimal(valueStr.trim()).doubleValue(); } catch (Exception e) { return defaultValue; } } /** * 转换为double<br> * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static Double toDouble(Object value) { return toDouble(value, null); } /** * 转换为Float<br> * 如果给定的值为空，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static Float toFloat(Object value, Float defaultValue) { if (value == null) { return defaultValue; } if (value instanceof Float) { return (Float) value; } if (value instanceof Number) { return ((Number) value).floatValue(); } final String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } try { return Float.parseFloat(valueStr.trim()); } catch (Exception e) { return defaultValue; } } /** * 转换为Float<br> * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static Float toFloat(Object value) { return toFloat(value, null); } /** * 转换为boolean<br> * String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static Boolean toBool(Object value, Boolean defaultValue) { if (value == null) { return defaultValue; } if (value instanceof Boolean) { return (Boolean) value; } String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } valueStr = valueStr.trim().toLowerCase(); switch (valueStr) { case true: return true; case false: return false; case yes: return true; case ok: return true; case no: return false; case 1: return true; case 0: return false; default: return defaultValue; } } /** * 转换为boolean<br> * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static Boolean toBool(Object value) { return toBool(value, null); } /** * 转换为Enum对象<br> * 如果给定的值为空，或者转换失败，返回默认值<br> * * @param clazz Enum的Class * @param value 值 * @param defaultValue 默认值 * @return Enum */ public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue) { if (value == null) { return defaultValue; } if (clazz.isAssignableFrom(value.getClass())) { @SuppressWarnings(unchecked) E myE = (E) value; return myE; } final String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } try { return Enum.valueOf(clazz, valueStr); } catch (Exception e) { return defaultValue; } } /** * 转换为Enum对象<br> * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br> * * @param clazz Enum的Class * @param value 值 * @return Enum */ public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value) { return toEnum(clazz, value, null); } /** * 转换为BigInteger<br> * 如果给定的值为空，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static BigInteger toBigInteger(Object value, BigInteger defaultValue) { if (value == null) { return defaultValue; } if (value instanceof BigInteger) { return (BigInteger) value; } if (value instanceof Long) { return BigInteger.valueOf((Long) value); } final String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } try { return new BigInteger(valueStr); } catch (Exception e) { return defaultValue; } } /** * 转换为BigInteger<br> * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static BigInteger toBigInteger(Object value) { return toBigInteger(value, null); } /** * 转换为BigDecimal<br> * 如果给定的值为空，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @param defaultValue 转换错误时的默认值 * @return 结果 */ public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue) { if (value == null) { return defaultValue; } if (value instanceof BigDecimal) { return (BigDecimal) value; } if (value instanceof Long) { return new BigDecimal((Long) value); } if (value instanceof Double) { return new BigDecimal((Double) value); } if (value instanceof Integer) { return new BigDecimal((Integer) value); } final String valueStr = toStr(value, null); if (StringUtils.isEmpty(valueStr)) { return defaultValue; } try { return new BigDecimal(valueStr); } catch (Exception e) { return defaultValue; } } /** * 转换为BigDecimal<br> * 如果给定的值为空，或者转换失败，返回默认值<br> * 转换失败不会报错 * * @param value 被转换的值 * @return 结果 */ public static BigDecimal toBigDecimal(Object value) { return toBigDecimal(value, null); } /** * 将对象转为字符串<br> * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法 * * @param obj 对象 * @return 字符串 */ public static String utf8Str(Object obj) { return str(obj, UTF-8); } /** * 将对象转为字符串<br> * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法 * * @param obj 对象 * @param charsetName 字符集 * @return 字符串 */ public static String str(Object obj, String charsetName) { return str(obj, Charset.forName(charsetName)); } /** * 将对象转为字符串<br> * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法 * * @param obj 对象 * @param charset 字符集 * @return 字符串 */ public static String str(Object obj, Charset charset) { if (null == obj) { return null; } if (obj instanceof String) { return (String) obj; } else if (obj instanceof byte[]) { return str((byte[]) obj, charset); } else if (obj instanceof Byte[]) { byte[] bytes = ArrayUtils.toPrimitive((Byte[]) obj); return str(bytes, charset); } else if (obj instanceof ByteBuffer) { return str((ByteBuffer) obj, charset); } return obj.toString(); } /** * 将byte数组转为字符串 * * @param bytes byte数组 * @param charset 字符集 * @return 字符串 */ public static String str(byte[] bytes, String charset) { return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset)); } /** * 解码字节码 * * @param data 字符串 * @param charset 字符集，如果此字段为空，则解码的结果取决于平台 * @return 解码后的字符串 */ public static String str(byte[] data, Charset charset) { if (data == null) { return null; } if (null == charset) { return new String(data); } return new String(data, charset); } /** * 将编码的byteBuffer数据转换为字符串 * * @param data 数据 * @param charset 字符集，如果为空使用当前系统字符集 * @return 字符串 */ public static String str(ByteBuffer data, String charset) { if (data == null) { return null; } return str(data, Charset.forName(charset)); } /** * 将编码的byteBuffer数据转换为字符串 * * @param data 数据 * @param charset 字符集，如果为空使用当前系统字符集 * @return 字符串 */ public static String str(ByteBuffer data, Charset charset) { if (null == charset) { charset = Charset.defaultCharset(); } return charset.decode(data).toString(); } // ----------------------------------------------------------------------- 全角半角转换 /** * 半角转全角 * * @param input String. * @return 全角字符串. */ public static String toSBC(String input) { return toSBC(input, null); } /** * 半角转全角 * * @param input String * @param notConvertSet 不替换的字符集合 * @return 全角字符串. */ public static String toSBC(String input, Set<Character> notConvertSet) { char c[] = input.toCharArray(); for (int i = 0; i < c.length; i++) { if (null != notConvertSet && notConvertSet.contains(c[i])) { // 跳过不替换的字符 continue; } if (c[i] == ' ') { c[i] = '\u3000'; } else if (c[i] < '\177') { c[i] = (char) (c[i] + 65248); } } return new String(c); } /** * 全角转半角 * * @param input String. * @return 半角字符串 */ public static String toDBC(String input) { return toDBC(input, null); } /** * 替换全角为半角 * * @param text 文本 * @param notConvertSet 不替换的字符集合 * @return 替换后的字符 */ public static String toDBC(String text, Set<Character> notConvertSet) { char c[] = text.toCharArray(); for (int i = 0; i < c.length; i++) { if (null != notConvertSet && notConvertSet.contains(c[i])) { // 跳过不替换的字符 continue; } if (c[i] == '\u3000') { c[i] = ' '; } else if (c[i] > '\uFF00' && c[i] < '\uFF5F') { c[i] = (char) (c[i] - 65248); } } String returnString = new String(c); return returnString; } /** * 数字金额大写转换 先写个完整的然后将如零拾替换成零 * * @param n 数字 * @return 中文大写数字 */ public static String digitUppercase(double n) { String[] fraction = {角, 分}; String[] digit = {零, 壹, 贰, 叁, 肆, 伍, 陆, 柒, 捌, 玖}; String[][] unit = {{元, 万, 亿}, {, 拾, 佰, 仟}}; String head = n < 0 ? 负 : ; n = Math.abs(n); String s = ; for (int i = 0; i < fraction.length; i++) { s += (digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll((零.)+, ); } if (s.length() < 1) { s = 整; } int integerPart = (int) Math.floor(n); for (int i = 0; i < unit[0].length && integerPart > 0; i++) { String p = ; for (int j = 0; j < unit[1].length && n > 0; j++) { p = digit[integerPart % 10] + unit[1][j] + p; integerPart = integerPart / 10; } s = p.replaceAll((零.)*零$, ).replaceAll(^$, 零) + unit[0][i] + s; } return head + s.replaceAll((零.)*零元, 元).replaceFirst((零.)+, ).replaceAll((零.)+, 零).replaceAll(^整$, 零元整); } }
3、日期转换工具类
import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; /** * 日期转换工具类 */ public class DateUtil { /** * 日期格式 */ public static final String FORMAT_DATE = yyyy-MM-dd; /** * 日期时间格式 */ public static final String FORMAT_DATETIME = yyyy-MM-dd HH:mm:ss; /** * 时间格式 */ public static final String FORMAT_TIME = HH:mm:ss; /** * 整点时间格式 */ public static final String FORMAT_DATETIMEZD = yyyy-MM-dd HH:00:00; /** * 日期格式(年, 月) */ public static final String FORMAT_YEARMONTH = yyyy-MM; /** * 全时间格式 */ public static final String FORMAT_FULLTIME = yyyyMMddHHmmssSSS; /** * 根据规定格式的字符串得到Calendar * * @param dateString 日期串 * @return 对应Calendar */ public static Calendar getCalendar(String dateString) { Calendar calendar = Calendar.getInstance(); String[] items = dateString.split(-); calendar.set(Integer.parseInt(items[0]), Integer.parseInt(items[1]) - 1, Integer.parseInt(items[2])); return calendar; } /** * 根据指定的日期格式将时间日期字符串转化为Date对象 * * @param dateString 时间或日期字符串 * @param format 格式 * @return Date */ public static Date getDateFromString(String dateString, String format) { SimpleDateFormat sdf = new SimpleDateFormat(format); try { return sdf.parse(dateString); } catch (ParseException e) { return null; } } /** * 将Date对象根据指定的时间格式转换为String字符串 * * @param date Date * @param format 格式 * @return String */ public static String getStringFromDate(Date date, String format) { SimpleDateFormat sdf = new SimpleDateFormat(format); return sdf.format(date); } /** * 转换时间字符串的格式 * * @param dateString 时间字符串 * @param fromFormat 当前格式 * @param toFormat 转换格式 * @return String */ public static String changeFormat(String dateString, String fromFormat, String toFormat) { Date date = getDateFromString(dateString, fromFormat); if (date == null) return dateString; return getStringFromDate(date, toFormat); } /** * 取得当前日期时间的字符串表示形式 * * @return String */ public static String getDateTime() { Calendar calendar = Calendar.getInstance(); return getStringFromDate(calendar.getTime(), FORMAT_DATETIME); } /** * 取得当前日期的字符串表现形式 * * @return String */ public static String getDate() { Calendar calendar = Calendar.getInstance(); return getStringFromDate(calendar.getTime(), FORMAT_DATE); } /** * 取得当前时间的字符串表示形式 * * @return String */ public static String getTime() { Calendar calendar = Calendar.getInstance(); return getStringFromDate(calendar.getTime(), FORMAT_TIME); } /** * 取得当前年的年份 * * @return int */ public static int getYear() { Calendar calendar = Calendar.getInstance(); return calendar.get(Calendar.YEAR); } /** * 取得当前月的月份 * * @return int */ public static int getMonth() { Calendar calendar = Calendar.getInstance(); return calendar.get(Calendar.MONTH); } /** * 取得当前日的日期 * * @return int */ public static int getDay() { Calendar calendar = Calendar.getInstance(); return calendar.get(Calendar.DATE); } /** * 取得指定的日期字符串的星期数 * * @param date 日期字符串 * @return String */ public static String getChineseDayOfWeek(String date) { Calendar calendar = getCalendar(date); int w = calendar.get(Calendar.DAY_OF_WEEK); String week = ; switch (w) { case Calendar.SUNDAY: week = 星期日; break; case Calendar.MONDAY: week = 星期一; break; case Calendar.TUESDAY: week = 星期二; break; case Calendar.WEDNESDAY: week = 星期三; break; case Calendar.THURSDAY: week = 星期四; break; case Calendar.FRIDAY: week = 星期五; break; case Calendar.SATURDAY: week = 星期六; break; default: week = 星期一; break; } return week; } /** * 取得当前日期是星期几 * * @return String */ public static String getDayOfWeek() { return getChineseDayOfWeek(getDate()); } /** * 取得中文的数据字符串 * * @param number 数字 * @return String */ public static String getChineseNumber(int number) { String n = ; switch (number) { case 0: n = O; break; case 1: n = 一; break; case 2: n = 二; break; case 3: n = 三; break; case 4: n = 四; break; case 5: n = 五; break; case 6: n = 六; break; case 7: n = 七; break; case 8: n = 八; break; case 9: n = 九; break; default: n = ; break; } return n; } /** * 根据日期值得到中文日期字符串 * * @param date 日期值 * @return 中文日期字符串 */ public static String getChineseDate(String date) { if (date.length() < 10) { return ; } else { String year = date.substring(0, 4); String month = date.substring(5, 7); String day = date.substring(8, 10); String y1 = year.substring(0, 1); String y2 = year.substring(1, 2); String y3 = year.substring(2, 3); String y4 = year.substring(3, 4); String m2 = month.substring(1, 2); String d1 = day.substring(0, 1); String d2 = day.substring(1, 2); String cy1 = getChineseNumber(Integer.parseInt(y1)); String cy2 = getChineseNumber(Integer.parseInt(y2)); String cy3 = getChineseNumber(Integer.parseInt(y3)); String cy4 = getChineseNumber(Integer.parseInt(y4)); String cm2 = getChineseNumber(Integer.parseInt(m2)); String cd1 = getChineseNumber(Integer.parseInt(d1)); String cd2 = getChineseNumber(Integer.parseInt(d2)); String cYear = cy1 + cy2 + cy3 + cy4 + 年; String cMonth = 月; if (Integer.parseInt(month) > 9) { cMonth = 十 + cm2 + cMonth; } else { cMonth = cm2 + cMonth; } String cDay = 日; if (Integer.parseInt(day) > 9) { cDay = cd1 + 十 + cd2 + cDay; } else { cDay = cd2 + cDay; } String chineseday = cYear + cMonth + cDay; return chineseday; } } /** * 根据日期值得到中文日期字符串 * 返回2005年09月23日格式的日期 * * @param date 给定日期 * @return String */ public static String getChineseTwoDate(String date) { if (date.length() < 10) { return ; } else { String year = date.substring(0, 4); String month = date.substring(5, 7); String day = date.substring(8, 10); return year + 年 + month + 月 + day + 日; } } /** * 根据当天的日期值得到中文日期字符串 * 返回2005年09月23日格式的日期 * * @return String */ public static String getChineseTwoDate() { return getChineseTwoDate(getDate()); } /** * 得到与指定日期相差指定天数的日期字符串 * * @param date 指定的日期 * @param period 前后的天数，正值为后， 负值为前 * @param periodType 周期类别 可以是天、月、年 * @return 日期字符串 */ public static String getCertainDate(String date, int period, int periodType) { Calendar calendar = getCalendar(date); switch (periodType) { case Calendar.DATE: calendar.add(Calendar.DATE, period); break; case Calendar.MONTH: calendar.add(Calendar.MONTH, period); break; case Calendar.YEAR: calendar.add(Calendar.YEAR, period); break; default: break; } return getStringFromDate(calendar.getTime(), FORMAT_DATE); } /** * 得到与指定日期相差指定天数的日期字符串 * * @param dateString 指定的日期 * @param days 前后的天数，正值为后， 负值为前 * @return 日期字符串 */ public static String getCertainDate(String dateString, int days) { Calendar calendar = getCalendar(dateString); calendar.add(Calendar.DATE, days); return getStringFromDate(calendar.getTime(), FORMAT_DATE); } /** * 得到指定日期的星期一的日期 * * @param dateString 日期字符串 * @return 本周星期一的日期 */ public static String getFirstDateOfWeek(String dateString) { Calendar calendar = getCalendar(dateString); int iCount; if (calendar.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) { iCount = -6; } else { iCount = Calendar.MONDAY - calendar.get(Calendar.DAY_OF_WEEK); } return getCertainDate(dateString, iCount); } /** * 返回两个时间相差的小时数 * * @param beginTime 开始时间 * @param endTime 结束时间 * @return 返回值 */ public static double getDiffHoure(String beginTime, String endTime) { double dif = 0; try { Date eDatetime = getDateFromString(endTime, FORMAT_DATE); Date bDatetime = getDateFromString(beginTime, FORMAT_DATE); dif = (eDatetime.getTime() - bDatetime.getTime()) / 1000 / 3600; } catch (Exception e) { dif = 0; } return dif; } /** * 得到当前日期的所在月的第一天的日期 * * @param date 当前日期 * @return String 返回的日期 */ public static String getMonthFirstDay(String date) { Calendar cal = getCalendar(date); String month = String.valueOf(cal.get(Calendar.MONTH) + 1); String year = String.valueOf(cal.get(Calendar.YEAR)); if (Integer.parseInt(month) < 10) { month = 0 + month; } return year + - + month + -01; } /** * 得到当前日期的所在月的最后一天的日期 * * @param date 当前日期 * @return String 返回的日期 */ public static String getMonthLastDay(String date) { Calendar cal = getCalendar(date); int month = cal.get(Calendar.MONTH) + 1; int year = cal.get(Calendar.YEAR); int nextMonth = month + 1; int nextYear = year; if (nextMonth == 13) { nextMonth = 1; nextYear = nextYear + 1; } String nextMonthFirstDay = nextYear + - + nextMonth + -01; return getCertainDate(nextMonthFirstDay, -1); } /** * 取得两日期间的月份差数 * * @param startDate 起始日期 * @param endDate 结束日期 * @return 月份差数 */ public static int getMonthDiff(String startDate, String endDate) { String[] startArray = startDate.split(-); String[] endArray = endDate.split(-); int startYear = Integer.parseInt(startArray[0]); int startMonth = Integer.parseInt(startArray[1]); int endYear = Integer.parseInt(endArray[0]); int endMonth = Integer.parseInt(endArray[1]); return Math.abs((endYear - startYear) * 12 + endMonth - startMonth); } /** * @param date 传入的日期 * @param days 要增加的天数 * @return Date 获取的目标日期 * * 获得特定日期之后的固定天数的某一天 */ public static Date addDays(Date date, int days) { Date date1 = null; try { if (null == date) { return date1; } Calendar calendar = Calendar.getInstance(); calendar.setTime(date); calendar.add(Calendar.DATE, days); date1 = calendar.getTime(); } catch (Exception e) { e.printStackTrace(); } finally { return date1; } } /** * @param minuendDate 被减数日期 * @param subDate 减数日期 * @return long 相差的天数 * * 获得日期相减后的天数 */ public static int subDate(Date minuendDate, Date subDate) { if (minuendDate != null && subDate != null) { long timeMillions = (minuendDate.getTime() - subDate.getTime()) % (24 * 60 * 60 * 1000); int days = new Long((minuendDate.getTime() - subDate.getTime()) / (24 * 60 * 60 * 1000)).intValue(); if (timeMillions == 0) { return days; } else { return days + 1; } } else { return 0; } } /** * 获取昨天的日期 */ public static String getYesterDayDate() { Calendar cd = Calendar.getInstance(); cd.add(Calendar.DATE, -1); return new SimpleDateFormat(yyyy-MM-dd).format(cd.getTime()); } /** * 获取昨天的日期 */ public static String getYesterDayDate(String dateformat) { if (dateformat.isEmpty()) { dateformat = yyyy-MM-dd; } Calendar cd = Calendar.getInstance(); cd.add(Calendar.DATE, -1); return new SimpleDateFormat(dateformat).format(cd.getTime()); } /** * * 获取指定日期前一天的日期 */ public static String getYesterDayDate(String strTime, String dateformat) { Calendar cd = Calendar.getInstance(); if (strTime == null) { cd.setTime(new Date()); } if (dateformat == null) { dateformat = yyyy-MM-dd HH:mm:ss; } DateFormat sdf = new SimpleDateFormat(dateformat); Date date = null; try { date = sdf.parse(strTime); } catch (Exception e) { e.printStackTrace(); } cd.setTime(date); cd.add(Calendar.DATE, -1); return new SimpleDateFormat(dateformat).format(cd.getTime()); } /** * 两时间相隔月份 * @param startDate * @param endDate * @return */ public static Integer getDiffMonth(Date startDate, Date endDate){ Calendar start = Calendar.getInstance(); Calendar end = Calendar.getInstance(); start.setTime(startDate); end.setTime(endDate); int result = end.get(Calendar.MONTH) - start.get(Calendar.MONTH); int month = (end.get(Calendar.YEAR) - start.get(Calendar.YEAR)) * 12; return Math.abs(month + result); } /** * 格式化时间，时间转字符串 * * @param date null则为当前系统时间 * @param format 格式，null则默认为：'yyyy-MM-dd HH:mm:ss' * @return 字符串格式的日期 */ public static String getDateTimeByStr(Date date, String format) { if (date == null) { date = new Date(); } if (format == null) { format = yyyy-MM-dd HH:mm:ss; } return new SimpleDateFormat(format).format(date); } }
4、项目包
链接 提取码：o7dq
搜索
复制
<iframe height=240 width=320></iframe>