导入jar包
<!-- 中文转拼音jar包 -->
<!-- https://mvnrepository.com/artifact/com.belerweb/pinyin4j -->
<dependency>
<groupId>com.belerweb</groupId>
<artifactId>pinyin4j</artifactId>
<version>2.5.1</version>
</dependency>
<!-- json转化jar包 -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
工具类
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.springframework.util.AntPathMatcher;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
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.exception.BadHanyuPinyinOutputFormatCombination;
/**
* 字符串工具类
*
* @author ruoyi
*/
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
/** 空字符串 */
private static final String NULLSTR = "";
/** 下划线 */
private static final char SEPARATOR = '_';
/**
* http请求
*/
public static final String HTTP = "http://";
/**
* https请求
*/
public static final String HTTPS = "https://";
/**
* 获取参数不为空值
*
* @param value defaultValue 要判断的value
* @return value 返回值
*/
public static <T> T nvl(T value, T defaultValue)
{
return value != null ? value : defaultValue;
}
/**
* * 判断一个Collection是否为空， 包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：为空 false：非空
*/
public static boolean isEmpty(Collection<?> coll)
{
return isNull(coll) || coll.isEmpty();
}
/**
* * 判断一个Collection是否非空，包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Collection<?> coll)
{
return !isEmpty(coll);
}
/**
* * 判断一个对象数组是否为空
*
* @param objects 要判断的对象数组
** @return true：为空 false：非空
*/
public static boolean isEmpty(Object[] objects)
{
return isNull(objects) || (objects.length == 0);
}
/**
* * 判断一个对象数组是否非空
*
* @param objects 要判断的对象数组
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Object[] objects)
{
return !isEmpty(objects);
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：为空 false：非空
*/
public static boolean isEmpty(Map<?, ?> map)
{
return isNull(map) || map.isEmpty();
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Map<?, ?> map)
{
return !isEmpty(map);
}
/**
* * 判断一个字符串是否为空串
*
* @param str String
* @return true：为空 false：非空
*/
public static boolean isEmpty(String str)
{
return isNull(str) || NULLSTR.equals(str.trim());
}
/**
* * 判断一个字符串是否为非空串
*
* @param str String
* @return true：非空串 false：空串
*/
public static boolean isNotEmpty(String str)
{
return !isEmpty(str);
}
/**
* * 判断一个对象是否为空
*
* @param object Object
* @return true：为空 false：非空
*/
public static boolean isNull(Object object)
{
return object == null;
}
/**
* * 判断一个对象是否非空
*
* @param object Object
* @return true：非空 false：空
*/
public static boolean isNotNull(Object object)
{
return !isNull(object);
}
/**
* * 判断一个对象是否是数组类型（Java基本型别的数组）
*
* @param object 对象
* @return true：是数组 false：不是数组
*/
public static boolean isArray(Object object)
{
return isNotNull(object) && object.getClass().isArray();
}
/**
* 去空格
*/
public static String trim(String str)
{
return (str == null ? "" : str.trim());
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @return 结果
*/
public static String substring(final String str, int start)
{
if (str == null)
{
return NULLSTR;
}
if (start < 0)
{
start = str.length() + start;
}
if (start < 0)
{
start = 0;
}
if (start > str.length())
{
return NULLSTR;
}
return str.substring(start);
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @param end 结束
* @return 结果
*/
public static String substring(final String str, int start, int end)
{
if (str == null)
{
return NULLSTR;
}
if (end < 0)
{
end = str.length() + end;
}
if (start < 0)
{
start = str.length() + start;
}
if (end > str.length())
{
end = str.length();
}
if (start > end)
{
return NULLSTR;
}
if (start < 0)
{
start = 0;
}
if (end < 0)
{
end = 0;
}
return str.substring(start, end);
}
/**
* 是否为http(s)://开头
*
* @param link 链接
* @return 结果
*/
public static boolean ishttp(String link)
{
return StringUtils.startsWithAny(link, HTTP, HTTPS);
}
/**
* 字符串转set
*
* @param str 字符串
* @param sep 分隔符
* @return set集合
*/
public static final Set<String> str2Set(String str, String sep)
{
return new HashSet<String>(str2List(str, sep, true, false));
}
/**
* 字符串转list
*
* @param str 字符串
* @param sep 分隔符
* @param filterBlank 过滤纯空白
* @param trim 去掉首尾空白
* @return list集合
*/
public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim)
{
List<String> list = new ArrayList<String>();
if (StringUtils.isEmpty(str))
{
return list;
}
// 过滤空白字符串
if (filterBlank && StringUtils.isBlank(str))
{
return list;
}
String[] split = str.split(sep);
for (String string : split)
{
if (filterBlank && StringUtils.isBlank(string))
{
continue;
}
if (trim)
{
string = string.trim();
}
list.add(string);
}
return list;
}
/**
* 判断给定的set列表中是否包含数组array 判断给定的数组array中是否包含给定的元素value
*
* @param set 给定的集合
* @param array 给定的数组
* @return boolean 结果
*/
public static boolean containsAny(Collection<String> collection, String... array)
{
if (isEmpty(collection) || isEmpty(array))
{
return false;
}
else
{
for (String str : array)
{
if (collection.contains(str))
{
return true;
}
}
return false;
}
}
/**
* 查找指定字符串是否包含指定字符串列表中的任意一个字符串同时串忽略大小写
*
* @param cs 指定字符串
* @param searchCharSequences 需要检查的字符串数组
* @return 是否包含任意一个字符串
*/
public static boolean containsAnyIgnoreCase(CharSequence cs, CharSequence... searchCharSequences)
{
if (isEmpty(cs) || isEmpty(searchCharSequences))
{
return false;
}
for (CharSequence testStr : searchCharSequences)
{
if (containsIgnoreCase(cs, testStr))
{
return true;
}
}
return false;
}
/**
* 驼峰转下划线命名
*/
public static String toUnderScoreCase(String str)
{
if (str == null)
{
return null;
}
StringBuilder sb = new StringBuilder();
// 前置字符是否大写
boolean preCharIsUpperCase = true;
// 当前字符是否大写
boolean curreCharIsUpperCase = true;
// 下一字符是否大写
boolean nexteCharIsUpperCase = true;
for (int i = 0; i < str.length(); i++)
{
char c = str.charAt(i);
if (i > 0)
{
preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
}
else
{
preCharIsUpperCase = false;
}
curreCharIsUpperCase = Character.isUpperCase(c);
if (i < (str.length() - 1))
{
nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
}
if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
{
sb.append(SEPARATOR);
}
else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
{
sb.append(SEPARATOR);
}
sb.append(Character.toLowerCase(c));
}
return sb.toString();
}
/**
* 是否包含字符串
*
* @param str 验证字符串
* @param strs 字符串组
* @return 包含返回true
*/
public static boolean inStringIgnoreCase(String str, String... strs)
{
if (str != null && strs != null)
{
for (String s : strs)
{
if (str.equalsIgnoreCase(trim(s)))
{
return true;
}
}
}
return false;
}
/**
* 删除最后一个字符串
*
* @param str 输入字符串
* @param spit 以什么类型结尾的
* @return 截取后的字符串
*/
public static String lastStringDel(String str, String spit)
{
if (!StringUtils.isEmpty(str) && str.endsWith(spit))
{
return str.subSequence(0, str.length() - 1).toString();
}
return str;
}
/**
* 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
*
* @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串
*/
public static String convertToCamelCase(String name)
{
StringBuilder result = new StringBuilder();
// 快速检查
if (name == null || name.isEmpty())
{
// 没必要转换
return "";
}
else if (!name.contains("_"))
{
// 不含下划线，仅将首字母大写
return name.substring(0, 1).toUpperCase() + name.substring(1);
}
// 用下划线将原始字符串分割
String[] camels = name.split("_");
for (String camel : camels)
{
// 跳过原始字符串中开头、结尾的下换线或双重下划线
if (camel.isEmpty())
{
continue;
}
// 首字母大写
result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase());
}
return result.toString();
}
/**
* 驼峰式命名法
* 例如：user_name->userName
*/
public static String toCamelCase(String s)
{
if (s == null)
{
return null;
}
if (s.indexOf(SEPARATOR) == -1)
{
return s;
}
s = s.toLowerCase();
StringBuilder sb = new StringBuilder(s.length());
boolean upperCase = false;
for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if (c == SEPARATOR)
{
upperCase = true;
}
else if (upperCase)
{
sb.append(Character.toUpperCase(c));
upperCase = false;
}
else
{
sb.append(c);
}
}
return sb.toString();
}
/**
* 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
*
* @param str 指定字符串
* @param strs 需要检查的字符串数组
* @return 是否匹配
*/
public static boolean matches(String str, List<String> strs)
{
if (isEmpty(str) || isEmpty(strs))
{
return false;
}
for (String pattern : strs)
{
if (isMatch(pattern, str))
{
return true;
}
}
return false;
}
/**
* 判断url是否与规则配置: ? 表示单个字符; * 表示一层路径内的任意字符串，不可跨层级; ** 表示任意层路径;
*
* @param pattern 匹配规则
* @param url 需要匹配的url
* @return
*/
public static boolean isMatch(String pattern, String url) {
AntPathMatcher matcher = new AntPathMatcher();
return matcher.match(pattern, url);
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj)
{
return (T) obj;
}
/**
* 数字左边补齐0，使之达到指定长度。注意，如果数字转换为字符串后，长度大于size，则只保留 最后size个字符。
*
* @param num 数字对象
* @param size 字符串指定长度
* @return 返回数字的字符串格式，该字符串为指定长度。
*/
public static final String padl(final Number num, final int size)
{
return padl(num.toString(), size, '0');
}
/**
* 字符串左补齐。如果原始字符串s长度大于size，则只保留最后size个字符。
*
* @param s 原始字符串
* @param size 字符串指定长度
* @param c 用于补齐的字符
* @return 返回指定长度的字符串，由原字符串左补齐或截取得到。
*/
public static final String padl(final String s, final int size, final char c)
{
final StringBuilder sb = new StringBuilder(size);
if (s != null)
{
final int len = s.length();
if (s.length() <= size)
{
for (int i = size - len; i > 0; i--)
{
sb.append(c);
}
sb.append(s);
}
else
{
return s.substring(len - size, len);
}
}
else
{
for (int i = size; i > 0; i--)
{
sb.append(c);
}
}
return sb.toString();
}
/**
* 生成随机数
*
* @param length 随机数长度
* @return
*/
public static String getRandom(int length) {
Random random = new Random();
String result = "";
for (int i = 0; i < length; i++) {
result += random.nextInt(10);
}
return result;
}
/**
* 生成随机数字和字母组合
* @param length
* @return
*/
public static String getCharAndNumr(int length) {
Random random = new Random();
StringBuffer valSb = new StringBuffer();
String charStr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int charLength = charStr.length();
for (int i = 0; i < length; i++) {
int index = random.nextInt(charLength);
valSb.append(charStr.charAt(index));
}
return valSb.toString();
}
/**
* 生成订单编号
*
* @return
*/
public static String getOrderIdByTime() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String newDate = sdf.format(DateUtils.getNowDate());
String result = "";
Random random = new Random();
for (int i = 0; i < 6; i++) {
result += random.nextInt(10);
}
return newDate + result;
}
/**
* 手机号格式验证
*
* @param phoneNumber
* @return 0格式正确，1格式错误
*/
public static int formatPhone(String phoneNumber) {
int status = 0;
if (phoneNumber.length() != 11) {
status = 1;
System.out.println("手机号码长度错误！");
} else {
String regex = "^((13[0-9])|(14[5,7,9])|(15([0-3]|[5-9]))|(166)|(17([0-3]|[5-6]))|(18[0-9])|(19[8,9]))\\d{8}$";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(phoneNumber);
if (m.matches()) {
System.out.println("您的手机号格式正确!");
String s = phoneNumber.substring(0, 3) + "****"
+ phoneNumber.substring(phoneNumber.length() - 4, phoneNumber.length());
System.out.println(s);
} else {
status = 1;
System.out.println("您的手机号格式不正确！");
}
}
return status;
}
/**
* 身份证号格式验证
*
* @param idNumber
* @return 0格式正确，1格式错误
*/
public static int formatIdNumber(String idNumber) {
int status = 0;
if (idNumber.length() != 18) {
status = 1;
System.out.println("身份证号长度错误！");
} else {
String substring = idNumber.substring(0, 17);
String regex = "[0-9]*";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(substring);
if (m.matches()) {
System.out.println("您的身份证号格式正确!");
} else {
status = 1;
System.out.println("您的身份证号格式不正确！");
}
}
return status;
}
/**
* 金额格式验证
*
* @param money
* @return 0格式正确，1格式错误
*/
public static int formatMoney(String money) {
int status = 0;
String regex = "^(([1-9]{1}\\d*)|([0]{1}))(\\.(\\d){0,2})?$";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(money);
if (m.matches()) {
System.out.println("金额格式正确!");
} else {
status = 1;
System.out.println("金额格式不正确！");
}
return status;
}
/**
* 银行卡号格式验证
*
* @param cardNo
* @return 0格式正确，1格式错误
*/
public static int formatCardNo(String cardNo) {
int status = 0;
String regex = "[0-9]*";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(cardNo);
if (m.matches()) {
System.out.println("银行卡号格式正确!");
} else {
status = 1;
System.out.println("银行卡号格式不正确！");
}
return status;
}
/**
* 汉字验证
*
* @param hanzi
* @return 0格式正确，1格式错误
*/
public static int formatHanzi(String hanzi) {
int status = 0;
String regex = "[\u4e00-\u9fa5]";
Pattern p = Pattern.compile(regex);
char c[] = hanzi.toCharArray();
for (int i = 0; i < c.length; i++) {
Matcher m = p.matcher(String.valueOf(c[i]));
if (!m.matches()) {
status = 1;
}
}
if (status == 0) {
System.out.println("汉字格式正确!");
} else {
System.out.println("汉字格式不正确!");
}
return status;
}
/**
* 整数验证
*
* @param number
* @return 0格式正确，1格式错误
*/
public static int formatNumeric(String number) {
int status = 0;
String regex = "^(0?|[1-9]\\d*)$";// 正整数，不能以0开头
// String regex = "^(0?|-?[1-9]\\d*)$";// 整数，可以为负数，不能以0开头
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(number);
if (m.matches()) {
System.out.println("数字格式正确!");
} else {
status = 1;
System.out.println("数字格式不正确!");
}
return status;
}
/**
* 金额转中文大写
*
* @param money
* @return
*/
public static String upperCaseMoney(double money) {
String[] upNum = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
String[] danwei = { "圆", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟" };
// 取消科学记数法
NumberFormat numFormat = NumberFormat.getInstance();
numFormat.setMaximumFractionDigits(2);// 设置小数位个数
numFormat.setGroupingUsed(false);// 取消科学技术发
String formatNum = numFormat.format(money);
String strmoney = formatNum + "";// 浮点型转为字符型
String lastUpNum = "null"; // 用于存放上个参数的值
String result = "";// 返回的结果
String[] split = strmoney.split("\\.");
String strMoney = split[0];
String point = "";
// 小数部分取值处理。
if (split.length > 1) {
point = split[1];
if (point.length() == 1) {
point = point.concat("0");
}
} else {
point = "0";
}
// 大于12位就直接返回。
int moneyLen = strMoney.length();
if (money == 0) {
return "零圆整";
}
if (moneyLen > 12) {
return "金额：" + money + "元，超出大写转换范围。最大金额：999999999999.99元";
}
// 整数(integer)部分处理。
if (!"0".equals(strMoney)) {
for (int i = 0; i < moneyLen; i++) {
String strNum = strMoney.charAt(i) + "";
int singleNum = Integer.parseInt(strNum);
String upSingleNum = upNum[singleNum];
// 上一为不等于0的情况
if (!"零".equals(lastUpNum)) {
if (!"零".equals(upSingleNum)) {
result = result.concat(upSingleNum).concat(danwei[moneyLen - i - 1]);
} else
// 为零但是在万、亿位上要加单位 (moneyLen-i)==9 指的是单位：亿。 (moneyLen-i)==5指的是单位：万
if ((moneyLen - i) == 5 || (moneyLen - i) == 9) {
lastUpNum = "";
} else {
result = result.concat(upSingleNum);
}
}
// 上一位为0的情况
if ("零".equals(lastUpNum) && !"零".equals(upSingleNum)) {
result = result.concat(upSingleNum).concat(danwei[moneyLen - i - 1]);
}
// 捕捉上一位数（lastUpNum）为零的情况做优化。
if ((moneyLen - i) == 5 || (moneyLen - i) == 9) {
// 排除加单位时前面为"零"的情况。如：两百零万
if ("零".equals(lastUpNum) || "null".equals(lastUpNum)) {
result = result.substring(0, result.length() - 1);
}
if (!result.endsWith("亿")) {
result = result.concat(danwei[moneyLen - i - 1]);
}
lastUpNum = "";
} else {
// 把当前大写数字复制给 lastUpNum 用于下次判断
lastUpNum = upSingleNum;
}
}
// 对几万元整和几亿元整(result:五万零或者五亿零零)做优化。
result = result.replaceAll("零零", "零");
if (result.endsWith("零")) {
String substring = result.substring(0, result.length() - 1);
result = substring;
}
result = result.concat("圆");
result = result.replaceAll("圆圆", "圆");
result = result.replaceAll("万万", "万");
}
// 小数(point)部分处理
if ("0".equals(point)) {
result = result + "整";
} else {
// 去 整
// if(result.endsWith("整")){
// result = result.substring(0,result.length()-1);
// }
if ((point.charAt(0) + "").equals("0")) {
result = result.concat(upNum[Integer.parseInt(point.charAt(1) + "")] + "分");
} else if ((point.charAt(1) + "").equals("0")) {
result = result.concat(upNum[Integer.parseInt(point.charAt(0) + "")] + "角");
} else {
result = result.concat(upNum[Integer.parseInt(point.charAt(0) + "")] + "角")
.concat(upNum[Integer.parseInt(point.charAt(1) + "")] + "分");
}
}
return result;
}
public static void main(String[] args) {
formatPhone("16534978510");
}
/*
* json对象转格式化后的json字符串
* @attention: 入参格式不同，返回结果不同
* @date: 2020年11月12日 0012 15:32
* @param: json
* 如果参数是json对象，返回的将是：格式化后的json字符串（小于号>会被转码成\u003c,大于号>会被转码成\u003e，且替换无效）;
* 如果参数是json字符串，返回的将是：带转义符\且两边带双引号的json字符串；
* 当参数是json字符串时，实现的效果与toJsonString()方法一样
* @return: java.lang.String
* jar包
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
*/
public static String formatJson(Object json) {
// 非空校验
if (null == json) return "";
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setPrettyPrinting();
Gson gson = gsonBuilder.create();
String jsonStr = gson.toJson(json);
// 替换无效
// jsonStr = jsonStr.replaceAll("\\u003c","<").replaceAll("\\u003e", ">");
// log.debug("json字符串格式化前：\n" + json.toString());
// log.debug("json字符串格式化后：\n" + jsonStr);
return jsonStr;
}
/**
* 汉字转为拼音
*
* @param chinese
* @return
*/
public static String toPinyin(String chinese) {
String pinyinStr = "";
char[] newChar = chinese.toCharArray();
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
for (int i = 0; i < newChar.length; i++) {
if (newChar[i] > 128) {
try {
pinyinStr += PinyinHelper.toHanyuPinyinStringArray(newChar[i], defaultFormat)[0];
} catch (BadHanyuPinyinOutputFormatCombination e) {
e.printStackTrace();
}
} else {
pinyinStr += newChar[i];
}
}
return pinyinStr;
}
/**
* 获取字符串拼音的第一个字母
*
* @param chinese
* @return
*/
public static String toChar(String chinese) {
String pinyinStr = "";
char[] newChar = chinese.toCharArray(); // 转为单个字符
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
for (int i = 0; i < newChar.length; i++) {
if (newChar[i] > 128) {
try {
pinyinStr += PinyinHelper.toHanyuPinyinStringArray(newChar[i], defaultFormat)[0].charAt(0);
} catch (BadHanyuPinyinOutputFormatCombination e) {
e.printStackTrace();
}
} else {
pinyinStr += newChar[i];
}
}
return pinyinStr;
}
/**
* 有多个汉字，只取第一个汉字进行翻译
*
* @param chinese
* @return
*/
public static String toFirstChar(String chinese) {
String pinyinStr = "";
char[] newChar = chinese.toCharArray(); // 转为单个字符
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
if (newChar[0] > 128) {
try {
pinyinStr += PinyinHelper.toHanyuPinyinStringArray(newChar[0], defaultFormat)[0].charAt(0);
} catch (BadHanyuPinyinOutputFormatCombination e) {
e.printStackTrace();
}
} else {
pinyinStr += newChar[0];
}
return pinyinStr;
}
private final static int[] dayArr = new int[] { 20, 19, 21, 20, 21, 22, 23, 23, 23, 24, 23, 22 };
private final static String[] constellationArr = new String[] { "摩羯座", "水瓶座", "双鱼座", "白羊座", "金牛座", "双子座", "巨蟹座",
"狮子座", "处女座", "天秤座", "天蝎座", "射手座", "摩羯座" };
/**
* Java通过生日计算星座
*
* @param month
* @param day
* @return
*/
public static String getConstellation(int month, int day) {
return day < dayArr[month - 1] ? constellationArr[month - 1] : constellationArr[month];
}
/**
* 计算年龄
*
* @param birthday
* @return
*/
public static Integer getAge(Date birthday) {
int year1 = birthday.getYear();
Date date = new Date();
int year2 = date.getYear();
return year2 - year1;
}
}
902
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
