标签：return String 数据类型 param value Java null public
/** * 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>标签：return,String,数据类型,param,value,Java,null,public 来源： https://www.cnblogs.com/Iven-L/p/16268764.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。