日期格式字符串比较
/**
- 比较两个日期时间的先后
-
- @param strDate1
- @param strDate2
- @return 0-两个时间相等；大于0-strDate1在strDate2之后；小于0-strDate1在strDate2之前
*/
public static int compareDateTime(String strDate1, String strDate2) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date1;
Date date2;
try {
date1 = sdf.parse(strDate1);
date2 = sdf.parse(strDate2);
return date1.compareTo(date2);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return 0;
}
}
数字格式字符串转汉字
/**
- 数字字符串转汉字
- 1234 转换为一二三四
- @param str
- @return
*/
public static String getChinese(String str){
StringBuilder sb= new StringBuilder();
for(int i = 0; i < str.length(); i++){
char c = str.charAt(i);
sb.append(formatDigit(c));
}
return sb.toString();
}
/**
- 数字0-9 转换为 汉字零-九
-
- @param sign
- @return
*/
private static char formatDigit(char sign) {
if (sign == '0')
sign = '零';
if (sign == '1')
sign = '一';
if (sign == '2')
sign = '二';
if (sign == '3')
sign = '三';
if (sign == '4')
sign = '四';
if (sign == '5')
sign = '五';
if (sign == '6')
sign = '六';
if (sign == '7')
sign = '七';
if (sign == '8')
sign = '八';
if (sign == '9')
sign = '九';
return sign;
}
yyyyMMdd转yyyy-MM-dd
/**
- yyyyMMdd字符串格式转换为yyyy-MM-dd
- @param str
- @return
*/
public static String dateConvertion(String str) {
Date parse = null;
String dateString = "";
try {
parse = new SimpleDateFormat("yyyyMMdd").parse(str);
dateString = new SimpleDateFormat("yyyy-MM-dd").format(parse);
} catch (ParseException e) {
dateString = null;
}
return dateString;
}
yyyy-MM-dd HH:mm:ss转换为汉字描述
/**
- 将时间格式的字符串yyyy-MM-dd HH:mm:ss转换为汉字描述
-
- @param date
- yyyy-MM-dd HH:mm:ss
- @return 例：二零二零年八月十三日二十一点零五分
*/
public static String transferDateTimeToChineseCharacter(String date) {
String chineseDate = "";
String d = date;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date da;
String datestr = "";
try {
da = sdf.parse(d);
datestr = sdf.format(da);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String[] cstr = datestr.split(" ");
// 1.处理年月日
String[] strs = cstr[0].split("-");
// 年
for (int i = 0; i < strs[0].length(); i++) {
chineseDate += formatDigit(strs[0].charAt(i));
}
// 月
char c1 = strs[1].charAt(0);
char c2 = strs[1].charAt(1);
String newmonth = "";
if (c1 == '0') {
newmonth = String.valueOf(formatDigit(c2));
} else if (c1 == '1' && c2 == '0') {
newmonth = "十";
} else if (c1 == '1' && c2 != '0') {
newmonth = "十" + formatDigit(c2);
}
chineseDate = chineseDate + "年" + newmonth + "月";
// 日
char d1 = strs[2].charAt(0);
char d2 = strs[2].charAt(1);
String newday = "";
if (d1 == '0') {// 单位数天
newday = String.valueOf(formatDigit(d2));
} else if (d1 != '1' && d2 == '0') {// 几十
newday = String.valueOf(formatDigit(d1)) + "十";
} else if (d1 != '1' && d2 != '0') {// 几十几
newday = formatDigit(d1) + "十" + formatDigit(d2);
} else if (d1 == '1' && d2 != '0') {// 十几
newday = "十" + formatDigit(d2);
} else {// 10
newday = "十";
}
chineseDate = chineseDate + newday + "日";
// 2.处理时分秒
String[] tsStrs = cstr[1].split(":");
// 时
char h1 = tsStrs[0].charAt(0);
char h2 = tsStrs[0].charAt(1);
String newhours = "";
if (h1 == '0') {
newhours = String.valueOf(formatDigit(h2));
} else if (h1 >= '1' && h2 == '0') {
if (h1 == '1') {
newhours = "十";
} else {
newhours = String.valueOf(formatDigit(h1)) + "十";
}
} else if (h1 >= '1' && h2 != '0') {
if (h1 == '1') {
newhours = "十" + String.valueOf(formatDigit(h2));
} else {
newhours = String.valueOf(formatDigit(h1)) + "十" + String.valueOf(formatDigit(h2));
}
}
chineseDate = chineseDate + newhours + "点";
// 分
char m1 = tsStrs[1].charAt(0);
char m2 = tsStrs[1].charAt(1);
String newminutes = "";
if (m1 != '0' || m2 != '0') {
if (m1 == '0') {
newminutes = "零" + String.valueOf(formatDigit(m2));
} else if (m1 >= '1' && m2 == '0') {
if (m1 == '1') {
newminutes = "十";
} else {
newminutes = String.valueOf(formatDigit(m1)) + "十";
}
} else if (m1 >= '1' && m2 != '0') {
if (m1 == '1') {
newminutes = "十" + String.valueOf(formatDigit(m2));
} else {
newminutes = String.valueOf(formatDigit(m1)) + "十" + String.valueOf(formatDigit(m2));
}
}
chineseDate = chineseDate + newminutes + "分";
}
// 秒
// char s1 = tsStrs[2].charAt(0);
// char s2 = tsStrs[2].charAt(1);
// String newseconds = "";
// if (s1 == '0') {//单位数天
// newseconds = String.valueOf(formatDigit(s2));
// } else if (s1 != '1' && s2 == '0') {//几十
// newseconds = String.valueOf(formatDigit(d1)) + "十";
// } else if (s1 != '1' && s2 != '0') {//几十几
// newseconds = formatDigit(s1) + "十" + formatDigit(s2);
// } else if (s1 == '1' && s2 != '0') {//十几
// newseconds = "十" + formatDigit(s2);
// } else {//10
// newseconds = "十";
// }
// chineseDate = chineseDate + newday + "秒";
return chineseDate;
}
文字转汉语拼音
所需依赖：
<dependency>
<groupId>com.belerweb</groupId>
<artifactId>pinyin4j</artifactId>
<version>2.5.1</version>
</dependency>
测试源代码：
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
/**
- 文字转拼音工具类
- 注：暂不支持多音字，多音字取该字的第一个音
*/
public class HanyupinyinUtil {
/**
- 将文字转为汉语拼音,全拼(复兴路=>fuxinglu)
*
- @param ChineseLanguage 要转换的文字
- @return String
*/
public static String getPinyinString(String ChineseLanguage) {
if(ChineseLanguage == null || "".equals(ChineseLanguage))
return "";
char[] cl_chars = ChineseLanguage.trim().toCharArray();
String hanyupinyin = "";
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);// 输出拼音全部小写
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);// 不带声调
defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_V);
try {
for (int i = 0; i < cl_chars.length; i++) {
if (String.valueOf(cl_chars[i]).matches("[\u4e00-\u9fa5]+")) {// 如果字符是中文,则将中文转为汉语拼音
hanyupinyin += PinyinHelper.toHanyuPinyinStringArray(cl_chars[i], defaultFormat)[0];
} else {// 如果字符不是中文,则不转换
hanyupinyin += cl_chars[i];
}
}
} catch (BadHanyuPinyinOutputFormatCombination e) {
System.out.println("字符不能转成汉语拼音");
}
return hanyupinyin;
}
/**
- 取每个汉字的第一个字符,大写(复兴路=>FXL)
*
- @param ChineseLanguage 要转换的文字
- @return String
*/
public static String getFirstLettersUp(String ChineseLanguage) {
return getFirstLetters(ChineseLanguage, HanyuPinyinCaseType.UPPERCASE);
}
/**
- 取每个汉字的第一个字符,小写(复兴路=>fxl)
*
- @param ChineseLanguage 要转换的文字
- @return String
*/
public static String getFirstLettersLo(String ChineseLanguage) {
return getFirstLetters(ChineseLanguage, HanyuPinyinCaseType.LOWERCASE);
}
/**
- 将文字转为汉语拼音首字母,大写或小写需要自己指定(用上面的就行了,这个就别用了)
*
- @param ChineseLanguage 要转换的文字
- @param caseType UPPERCASE->大写,LOWERCASE->小写
- @return String
*/
public static String getFirstLetters(String ChineseLanguage, HanyuPinyinCaseType caseType) {
char[] cl_chars = ChineseLanguage.trim().toCharArray();
String hanyupinyin = "";
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
defaultFormat.setCaseType(caseType);// 输出拼音全部大写
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);// 不带声调
hanyupinyin = getHanYuPinYinString(cl_chars, hanyupinyin, defaultFormat);
return hanyupinyin;
}
/**
- 取第一个汉字的第一个字符(复兴路=>F)
*
- @param ChineseLanguage 要转换的文字
- @return String
*/
public static String getFirstLetter(String ChineseLanguage) {
char[] cl_chars = ChineseLanguage.trim().toCharArray();
String hanyupinyin = "";
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
defaultFormat.setCaseType(HanyuPinyinCaseType.UPPERCASE);// 输出拼音全部大写
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);// 不带声调
try {
String str = String.valueOf(cl_chars[0]);
if (str.matches("[\u4e00-\u9fa5]+")) {// 如果字符是中文,则将中文转为汉语拼音,并取第一个字母
hanyupinyin = PinyinHelper.toHanyuPinyinStringArray(
cl_chars[0], defaultFormat)[0].substring(0, 1);
;
} else if (str.matches("[0-9]+")) {// 如果字符是数字,取数字
hanyupinyin += cl_chars[0];
} else if (str.matches("[a-zA-Z]+")) {// 如果字符是字母,取字母
hanyupinyin += cl_chars[0];
} else {// 否则不转换
}
} catch (BadHanyuPinyinOutputFormatCombination e) {
System.out.println("字符不能转成汉语拼音");
}
return hanyupinyin;
}
//获取汉语拼音
private static String getHanYuPinYinString(char[] cl_chars, String hanyupinyin, HanyuPinyinOutputFormat defaultFormat) {
try {
for (int i = 0; i < cl_chars.length; i++) {
String str = String.valueOf(cl_chars[i]);
if (str.matches("[\u4e00-\u9fa5]+")) {// 如果字符是中文,则将中文转为汉语拼音,并取第一个字母
hanyupinyin += PinyinHelper.toHanyuPinyinStringArray(cl_chars[i], defaultFormat)[0].substring(0, 1);
} else if (str.matches("[0-9]+")) {// 如果字符是数字,取数字
hanyupinyin += cl_chars[i];
} else if (str.matches("[a-zA-Z]+")) {// 如果字符是字母,取字母
hanyupinyin += cl_chars[i];
} else {// 否则不转换
hanyupinyin += cl_chars[i];//如果是标点符号的话，带着
}
}
} catch (BadHanyuPinyinOutputFormatCombination e) {
System.out.println("字符不能转成汉语拼音");
}
return hanyupinyin;
}
public static void main(String[] args) {
System.out.println("getPinyinString===============" + getPinyinString("航班变更"));
System.out.println("getPinyinString===============" + getPinyinString("航班查询"));
// System.out.println("getFirstLettersUp===============" + getFirstLettersUp("返回"));
// System.out.println("getFirstLettersLo===============" + getFirstLettersLo("返回"));
// System.out.println("getFirstLetter===============" + getFirstLetter("返回"));
}
}
十六进制与字符串的转换
字符串转十六进制
/**
* 字符串转换成为16进制(无需Unicode编码)
* @param str
* @return
*/
public static String str2HexStr(String str) {
char[] chars = "0123456789ABCDEF".toCharArray();
StringBuilder sb = new StringBuilder("");
byte[] bs = str.getBytes();
int bit;
for (int i = 0; i < bs.length; i++) {
bit = (bs[i] & 0x0f0) >> 4;
sb.append(chars[bit]);
bit = bs[i] & 0x0f;
sb.append(chars[bit]);
// sb.append(' ');
}
return sb.toString().trim();
}
十六进制转字符串
/**
* 16进制直接转换成为字符串(无需Unicode解码)
* @param hexStr
* @return
*/
public static String hexStr2Str(String hexStr) {
String str = "0123456789ABCDEF";
char[] hexs = hexStr.toCharArray();
byte[] bytes = new byte[hexStr.length() / 2];
int n;
for (int i = 0; i < bytes.length; i++) {
n = str.indexOf(hexs[2 * i]) * 16;
n += str.indexOf(hexs[2 * i + 1]);
bytes[i] = (byte) (n & 0xff);
}
return new String(bytes);
}
字符串转日期
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2019-01-03 10:59:27")
判断字符串是否为数字
使用StringUtils工具类
org.apache.commons.lang3.StringUtils字符串解析工具包，其中isNumeric(String Str)解析是否为数字类型的方法，该方式只能校验不含负号“-”的数字，即输入一个负数-199，输出结果将是false
import org.apache.commons.lang3.StringUtils;
public class NumberDemo {
private static boolean isNumber(String str) {
return StringUtils.isNumeric(str);
}
}
isNumeric方法通过循环判断每一个字符，如果有一个字符不是数字，那么直接返回false。方法源码如下：
public static boolean isNumeric(final CharSequence cs) {
// 判断是否为空，如果为空则返回false
if (isEmpty(cs)) {
return false;
}
// 通过 length() 方法计算cs传入进来的字符串的长度，并将字符串长度存放到sz中
final int sz = cs.length();
// 通过字符串长度循环
for (int i = 0; i < sz; i++) {
// 判断每一个字符是否为数字，如果其中有一个字符不满足，则返回false
if (!Character.isDigit(cs.charAt(i))) {
return false;
}
}
// 验证全部通过则返回true
return true;
}
使用ACSII码
public static boolean isNumeric(String str){
for(int i=str.length();--i>=0;){
int chr=str.charAt(i);
if(chr<48 || chr>57)
return false;
}
return true;
}
使用Java自带函数
方式原理和StringUtils.isNumeric()一样，该方式只能叫严不含负号的数字
public static boolean isNumeric(String str){
for (int i = str.length();--i>=0;){
if (!Character.isDigit(str.charAt(i))){
return false;
}
}
return true;
}
使用正则表达式（推荐）
通过正则表达式判断字符串是否为数字，如下：
-
str.matches("\\d+ ");
-
通过 -?[0-9]+(\\\\.[0-9]+)? 进行匹配是否为数字；
-
Pattern pattern = Pattern.compile(" [0-9] ");
-
“-?[0-9]+.?[0-9]+”， 即可匹配所有数字。
-
Pattern.compile("^[-\\+]?[\\d]*$");
-
str.matches("-?[0-9]+.?[0-9]*"); （比较全面，推荐）
*\\d+ 使用正则表达式判断该字符串是否为纯数字。第一个\是转义符；\d+表示匹配1个或多个连续数字。+和*类似，表示0个或多个，?表示0或1个
方式一：
public class NumberDemo {
// 根据阿里巴巴代码规范，将Pattern设置为全局常量
// 通过 -?[0-9]+(\\\\.[0-9]+)? 进行匹配是否为数字
private static Pattern pattern = Pattern.compile("-?[0-9]+(\\\\.[0-9]+)?");
/**
* 通过正则表达式判断字符串是否为数字
* @param str
* @return
*/
private static boolean isNumber(String str) {
// 通过Matcher进行字符串匹配
Matcher m = pattern.matcher(str);
// 如果正则匹配通过 m.matches() 方法返回 true ，反之 false
return m.matches();
}
}
方式二（推荐）：
public static boolean isInteger(String str) {
Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
return pattern.matcher(str).matches();
}
