StringUtil String工具类常用方法集合

记录日常常用String操作方法，记录一下，方便以后自己和大家参考使用

/**

* 数组是否包含指定的元素

*

* @param fields

* ,名称

* @param name

* ，元素

* @return boolean, yes or no

*/

/**
* 数组是否包含指定的元素
*
* @param fields
*            ,名称
* @param name
*            ，元素
* @return boolean, yes or no
*/
public static boolean contains(String[] fields, String name) {
if (getIndex(fields, name) == -1) { return false; }
return true;
}

/**

* 在数组中查找指定的串，如果找到，则返回索引，否则返回-1

*

* @param name

* ，索引名称

* @return int, 索引号 不成功返回 -1

*/

/**
* 在数组中查找指定的串，如果找到，则返回索引，否则返回-1
*
* @param name
*            ，索引名称
* @return int, 索引号 不成功返回 -1
*/
public static int getIndex(String[] fields, String name) {
if ((fields == null) || (name == null)) { return -1; }
for (int i = 0; i < fields.length; i++) {
if (name.equalsIgnoreCase(fields[i])) { return i; }
}
return -1;
}

/**

* 将普通文本字符串过滤成含 < br>

* 的超文本字串

*

* @param src

* , 输入源串

* @return String, 返回过滤结果

*/

/**
* 将普通文本字符串过滤成含 < br>
* 的超文本字串
*
* @param src
*            , 输入源串
* @return String, 返回过滤结果
*/
public static String strFilter(String src) {
String ret = src.replaceAll("<", "<");
ret = ret.replaceAll(">", ">");
ret = ret.replaceAll("<", "<");
ret = ret.replaceAll("\r\n", "<br>");
return ret;
}

/**

* 将DATE转换为String类型 format “yyyy-MM-dd”

*

* @param date

* @return

*/

/**
* 将DATE转换为String类型 format "yyyy-MM-dd"
*
* @param date
* @return
*/
public static String dateToString(java.sql.Date date) {
java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("yyyy-MM-dd");
String s = "";
if (date != null) {
s = format.format(date);
}
return s;
}

/**

* 将DATE转换为String类型 format 自定义 如 “yyyy-MM-dd hh:mm:ss”

*

* @param date

* @return

*/

/**
* 将DATE转换为String类型 format 自定义 如 "yyyy-MM-dd hh:mm:ss"
*
* @param date
* @return
*/
public static String dateToString(java.sql.Date date, String formatType) {
java.text.SimpleDateFormat format = new java.text.SimpleDateFormat(formatType);
String s = "";
if (date != null) {
s = format.format(date);
}
return s;
}

/**

* 替换空字符串

*

* @param sStr

* @return

*/

/**
* 替换空字符串
*
* @param sStr
* @return
*/
public static String nullToSpace(String sStr) {
return sStr == null ? "" : sStr;
}

public static String nullToSpace(Object sStr) {
return sStr == null ? "" : String.valueOf(sStr);
}

/**

* 判断对象是否为空

* 1,字符串(null或者”“)都返回true

* 2,数字类型(null或者0)都返回true

* 3,集合类型(null或者不包含元素都返回true)

* 4,数组类型不包含元素返回true(包含null元素返回false)

* 5,其他对象仅null返回true

*

* @param obj

* @return

*/

/**
* 判断对象是否为空<br>
* 1,字符串(null或者"")都返回true<br>
* 2,数字类型(null或者0)都返回true<br>
* 3,集合类型(null或者不包含元素都返回true)<br>
* 4,数组类型不包含元素返回true(包含null元素返回false)<br>
* 5,其他对象仅null返回true
*
* @param obj
* @return
*/
public static boolean isEmpty(Object obj) {
if (obj == null) { return true; }
if (obj instanceof Number) {
Number num = (Number) obj;
if (num.intValue() == 0) {
return true;
} else {
return false;
}
} else if (obj instanceof String) {
String str = (String) obj;
if ((str == null) || str.equals("")) {
return true;
} else {
return false;
}
} else if (obj instanceof Collection<?>) {
Collection<?> c = (Collection<?>) obj;
return c.isEmpty();
} else if (obj instanceof Map<?, ?>) {
Map<?, ?> m = (Map<?, ?>) obj;
return m.isEmpty();
} else if (obj.getClass().isArray()) {
int length = Array.getLength(obj);
return length == 0 ? true : false;
} else {
return false;
}
}

/**

* 将list转换成string 替换掉里面的所有空格和 [] 可用于 sql语句中的 in 里面

*

* @param list

* @return

*/

/**
* 将list转换成string 替换掉里面的所有空格和 [] 可用于 sql语句中的 in 里面
*
* @param list
* @return
*/
public static String listToString(List list) {
String rtn = list.toString();
rtn = rtn.replaceAll("\\[", "");
rtn = rtn.replaceAll("\\]", "");
rtn = rtn.replaceAll(" ", "");
return rtn;
}

/**

* 得到当前日期 yyyy-MM-dd

*

* @return

*/

/**
* 得到当前日期 yyyy-MM-dd
*
* @return
*/
public static String getNowDate() {
java.util.Date date = new java.util.Date();
String s = dateToString(date);
return s;
}

/**

* 判断日期类型

*

* @param strDate

* 成功返回date类型，失败返回null

* @return

*/

/**
* 判断日期类型
*
* @param strDate
*            成功返回date类型，失败返回null
* @return
*/
public static java.util.Date isDate(String strDate) {
java.util.Date returnDate = null;
try {
DateFormat df = DateFormat.getDateInstance();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String cDate = sdf.format(df.parse(strDate)).toString();
returnDate = df.parse(cDate);
} catch (Exception e) {
return null;
}
return returnDate;
}

/**

* 字符编码自定义转换类型

*

* @param str

* @param fEncode

* @param tEncode

* @return

*/

/**
* 字符编码自定义转换类型
*
* @param str
* @param fEncode
* @param tEncode
* @return
*/
public static String convertEncode(String str, String fEncode, String tEncode) {
if (str == null) {
return str;
} else {
try {
return new String(str.getBytes(fEncode), tEncode);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}

/**

* 转换GBK 到 utf-8

*

* @param str

* @return

*/

/**
* 转换GBK 到 utf-8
*
* @param str
* @return
*/
public static String cGBK2UTF8(String str) {
if (str == null) {
return str;
} else {
try {
/*
* 如果 页面为UTF-8的页面 但是用GBK进行编码了 将已经遍成为GBK的按照GBK取出成BYTE 转换为原始页面的编码
*/
return new String(str.getBytes("GBK"), "UTF-8");
} catch (Exception e) {
// System.out.println("PubUnit.ConverttoGBK:" + e.toString());
e.printStackTrace();
return null;
}
}

}

/**

* 转换ISO8859-1 到 GB2312

*

* @param str

* @return

*/

/**
* 转换ISO8859-1 到 GB2312
*
* @param str
* @return
*/
public static String cISO2GB2312(String str) {
if (str == null) {
return str;
} else {
try {
return new String(str.getBytes("ISO-8859-1"), "gb2312");
} catch (Exception e) {
System.out.println("PubUnit.ConverttoGBK:" + e.toString());
return null;
}
}

}

/**

* 求a1 a2数组的交集

*

* @param a1

* @param a2

* @return 返回交集数组

*/

/**
* 求a1 a2数组的交集
*
* @param a1
* @param a2
* @return 返回交集数组
*/
public static String[] arrayIntersection(String[] a1, String[] a2) {

List<String> list = Arrays.asList(a1);
list.retainAll(Arrays.asList(a2)); // list 中的就是交集了.

return list.toArray(new String[0]);
}

/**

* union all 将两个StringArray 组合成一个StringArray

*

* @param a1

* @param a2

* @return

*/

/**
* union all 将两个StringArray 组合成一个StringArray
*
* @param a1
* @param a2
* @return
*/
public static String[] arrayUnionAll(String[] a1, String[] a2) {
String[] a3 = new String[a1.length + a2.length];
System.arraycopy(a1, 0, a3, 0, a1.length);
System.arraycopy(a2, 0, a3, a1.length, a2.length);
return a3;
}

/**

* 将两个StringArray求 并集

*

* @param a

* @return

*/

/**
* 将两个StringArray求 并集
*
* @param a
* @return
*/
public static String[] arrayUnion(String[] a1, String[] a2) {
String[] a3 = arrayUnionAll(a1, a2);
HashSet set = new HashSet();
set.addAll(Arrays.asList(a3));
String[] strs2 = (String[]) set.toArray(new String[0]);
return strs2;
}

/**

* 从 字符串数组1 中移除包含在指定 字符串数组2 中的所有元素

*

* @param a1

* @param a2

* @return

*/

/**
* 从 a1 中移除包含在指定 a2 中的所有元素
*
* @param a1
* @param a2
* @return
*/
public static String[] removeAll(String[] a1, String[] a2) {
List<String> list = Arrays.asList(a1);
list.removeAll(Arrays.asList(a2)); // list 中的就是交集了.
return list.toArray(new String[0]);
}

/**

* 限制字符串长度 截取前charCount个汉字 英文占两个字符

*

* @param bt

* @param bytesCount

* @return

*/

/**
* 限制字符长度 截取前charCount个汉字 英文占两个字符
*
* @param bt
* @param bytesCount
* @return
*/
public static String limitChar(String str, int charCount) {
int bytesCount = charCount * 2;
byte[] bytes = str.getBytes();
if (bytesCount >= bytes.length) { return str; }
char[] chars = new String(bytes, 0, bytesCount).toCharArray();
char[] charsPlus = new String(bytes, 0, bytesCount + 1).toCharArray();

if (chars.length == charsPlus.length) {
return new String(  bytes,0,bytesCount - 1);
}

return new String(bytes, 0, bytesCount);

}

/**

* 将字符串转换为整数 如果转换失败返回0

*

* @param str

* @return

*/

/**
* 将字符串转换为整数 如果转换失败返回0
*
* @param str
* @return
*/
public static final int getInt(String str) {
return getInt(str, 0);
}

/**

* 将中文字符转换为简拼

*

* @param c

* @return

*/

/**
* 将中文字符转换为简拼
*
* @param c
* @return
*/
public static String toJP(String c) {

char[] chars = c.toCharArray();

StringBuffer sb = new StringBuffer("");

for (int i = 0; i < chars.length; i++) {
sb.append(getJP(chars[i]));
}

// return sb.toString().toUpperCase();
return sb.toString();
}

public static String getJP(char c) {
byte[] array = new byte[2];
array = String.valueOf(c).getBytes();
if (array.length < 2) { return String.valueOf(c); }
int i = (short) (array[0] - '\0' + 256) * 256
+ (short) (array[1] - '\0' + 256);
if (i < 0xB0A1) { return String.valueOf(c); }
if (i < 0xB0C5) { return "a"; }
if (i < 0xB2C1) { return "b"; }
if (i < 0xB4EE) { return "c"; }
if (i < 0xB6EA) { return "d"; }
if (i < 0xB7A2) { return "e"; }
if (i < 0xB8C1) { return "f"; }
if (i < 0xB9FE) { return "g"; }
if (i < 0xBBF7) { return "h"; }
if (i < 0xBFA6) { return "j"; }
if (i < 0xC0AC) { return "k"; }
if (i < 0xC2E8) { return "l"; }
if (i < 0xC4C3) { return "m"; }
if (i < 0xC5B6) { return "n"; }
if (i < 0xC5BE) { return "o"; }
if (i < 0xC6DA) { return "p"; }
if (i < 0xC8BB) { return "q"; }
if (i < 0xC8F6) { return "r"; }
if (i < 0xCBFA) { return "s"; }
if (i < 0xCDDA) { return "t"; }
if (i < 0xCEF4) { return "w"; }
if (i < 0xD1B9) { return "x"; }
if (i < 0xD4D1) { return "y"; }
if (i < 0xD7FA) { return "z"; }
return String.valueOf(c);
}

/**

* 将字符串数组转换成字符串，以”,”分隔

*

* @param str

* ， 输入串

* @return 串数组

*/

public final static String arrayToString(String[] arrays) {

return arrayToString(arrays, false);

}

/**
* 将字符串数组转换成字符串，以","分隔
*
* @param str
*            ， 输入串
* @return 串数组
*/
public final static String arrayToString(String[] arrays) {
return arrayToString(arrays, false);
}

/**

* 转换字符串首字母为大写

*

* @param str

* @return

*/

/**
* 转换字符串首字母为大写
*
* @param str
* @return
*/
public final static String firstCharToUpper(String str) {
char c = str.charAt(0);
if (!Character.isLetter(c)) {
return str;
} else if (Character.isUpperCase(c)) {
return str;
} else if (Character.isLowerCase(c)) {
return (char) (c - 32) + str.substring(1);
} else {
return str;
}
}

/**

* 将小写金额转换为大写

*

* @param amount

* 110.00

* @return 壹佰壹拾圆整

*/

/**
* 将小写金额转换为大写
*
* @param amount
*            110.00
* @return 壹佰壹拾圆整
*/
public static String amountToUpper(String amount) throws Exception {
// String[] lowerAmount = { "0", "1", "2", "3", "4", "5", "6", "7", "8",
// "9" };
String[] upperAmount = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌",
"玖" };
String[] unit = { "分", "角", "圆", "拾", "佰", "仟", "萬", "亿" };
String wholeUnit = "整";
StringBuffer result = new StringBuffer();

if (StringUtil.isEmpty(amount)) { return ""; }
// 为0
if (Double.valueOf(amount) == 0) { return upperAmount[0]; }
// 去掉开头和结尾的0
amount = amount.replaceAll("^0*", "");
if (amount.startsWith(".")) {
amount = "0" + amount;
}
if (amount.indexOf(".") > -1) {
amount = amount.replaceAll("0*$|\\.0{1,2}$", "");
}
// 判断格式
Pattern p = Pattern.compile("\\d{1,12}(\\.\\d{1,2})?");
Matcher m = p.matcher(amount);
if (!m.matches()) { throw new Exception("金额格式不正确! "); }
// 分成整数和小数分别读
String whole = "";
String integral = "";
if (amount.indexOf(".") > -1) {
whole = amount.split("\\.")[0];
integral = amount.split("\\.")[1];
} else {
whole = amount;
}
// 整数读法
StringBuffer sceAmount = new StringBuffer(whole);
if (sceAmount.length() > 4) { // 每4位用逗号分隔
int count = sceAmount.length() / 4;
for (int i = 0; i <= count; i++) {
if (i == 1) {
sceAmount.insert(sceAmount.length() - 4 * i, ",");
} else if (i > 1) {
sceAmount.insert(sceAmount.length() - 4 * i - 1, ",");
}
}
}
String[] sce = sceAmount.toString().split(",");
for (int i = sce.length - 1; i >= 0; i--) { // 每4位循环读
StringBuffer oneComma = new StringBuffer();
if (Pattern.compile("\\d{1,4}").matcher(sce[i]).matches()) {
if (Pattern.compile("[1-9]{4}").matcher(sce[i]).matches()) { // 不含有0
int t = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 千位
int h = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 百位
int d = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 十位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(3))); // 个位
oneComma.append(upperAmount[t])
.append(unit[5])
.append(upperAmount[h])
.append(unit[4])
.append(upperAmount[d])
.append(unit[3])
.append(upperAmount[e]);
} else if (Pattern  .compile("0{1}[1-9]{1}0{1}[1-9]{1}")
.matcher(sce[i])
.matches()) {
int h = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 百位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(3))); // 个位
oneComma.append(upperAmount[0])
.append(upperAmount[h])
.append(unit[4])
.append(upperAmount[0])
.append(upperAmount[e]);
} else if (Pattern  .compile("0{1,3}[1-9]{1}")
.matcher(sce[i])
.matches()) {
int e = Integer.valueOf(String.valueOf(sce[i].charAt(3))); // 个位
oneComma.append(upperAmount[0]).append(upperAmount[e]);
} else if (Pattern  .compile("0{1,2}[1-9]{1}0{1}")
.matcher(sce[i])
.matches()) {
int d = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 十位
oneComma.append(upperAmount[0])
.append(upperAmount[d])
.append(unit[3]);
} else if (Pattern  .compile("0{1}[1-9]{1}0{2}")
.matcher(sce[i])
.matches()) {
int h = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 百位
oneComma.append(upperAmount[0])
.append(upperAmount[h])
.append(unit[4]);
} else if (Pattern  .compile("[1-9]{1}0{3}")
.matcher(sce[i])
.matches()) {
int t = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 千位
oneComma.append(upperAmount[t]).append(unit[5]);
} else if (Pattern  .compile("[1-9]{2}0{2}")
.matcher(sce[i])
.matches()) {
int t = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 千位
int h = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 百位
oneComma.append(upperAmount[t])
.append(unit[5])
.append(upperAmount[h])
.append(unit[4]);
} else if (Pattern  .compile("[1-9]{1}0{1}[1-9]{1}0{1}")
.matcher(sce[i])
.matches()) {
int t = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 千位
int d = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 十位
oneComma.append(upperAmount[t])
.append(unit[5])
.append(upperAmount[0])
.append(upperAmount[d])
.append(unit[3]);
} else if (Pattern  .compile("[1-9]{1}0{2}[1-9]{1}")
.matcher(sce[i])
.matches()) {
int t = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 千位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(3))); // 个位
oneComma.append(upperAmount[t])
.append(unit[5])
.append(upperAmount[0])
.append(upperAmount[e]);
} else if (Pattern  .compile("0{1}[1-9]{2}0{1}")
.matcher(sce[i])
.matches()) {
int h = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 百位
int d = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 十位
oneComma.append(upperAmount[0])
.append(upperAmount[h])
.append(unit[4])
.append(upperAmount[d])
.append(unit[3]);
} else if (Pattern  .compile("0{1,2}[1-9]{2}")
.matcher(sce[i])
.matches()) {
int d = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 十位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(3))); // 个位
oneComma.append(upperAmount[0])
.append(upperAmount[d])
.append(unit[3])
.append(upperAmount[e]);
} else if (Pattern  .compile("[1-9]{3}0{1}")
.matcher(sce[i])
.matches()) {
int t = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 千位
int h = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 百位
int d = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 十位
oneComma.append(upperAmount[t])
.append(unit[5])
.append(upperAmount[h])
.append(unit[4])
.append(upperAmount[d])
.append(unit[3]);
} else if (Pattern  .compile("[1-9]{2}0{1}[1-9]{1}")
.matcher(sce[i])
.matches()) {
int t = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 千位
int h = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 百位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(3))); // 个位
oneComma.append(upperAmount[t])
.append(unit[5])
.append(upperAmount[h])
.append(unit[4])
.append(upperAmount[0])
.append(upperAmount[e]);
} else if (Pattern  .compile("0{1}[1-9]{3}")
.matcher(sce[i])
.matches()) { // 四位
int h = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 百位
int d = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 十位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(3))); // 个位
oneComma.append(upperAmount[0])
.append(upperAmount[h])
.append(unit[4])
.append(upperAmount[d])
.append(unit[3])
.append(upperAmount[e]);
} else if (Pattern  .compile("[1-9]{1}0{1}[1-9]{2}")
.matcher(sce[i])
.matches()) {
int t = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 千位
int d = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 十位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(3))); // 个位
oneComma.append(upperAmount[t])
.append(unit[5])
.append(upperAmount[0])
.append(upperAmount[d])
.append(unit[3])
.append(upperAmount[e]);
} else if (Pattern  .compile("[1-9]{3}")
.matcher(sce[i])
.matches()) { // 三位
int h = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 百位
int d = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 十位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 个位
oneComma.append(upperAmount[h])
.append(unit[4])
.append(upperAmount[d])
.append(unit[3])
.append(upperAmount[e]);
} else if (Pattern  .compile("[1-9]{1}0{2}")
.matcher(sce[i])
.matches()) { // 三位
int h = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 百位
oneComma.append(upperAmount[h]).append(unit[4]);
} else if (Pattern  .compile("[1-9]{1}0{1}[1-9]{1}")
.matcher(sce[i])
.matches()) {
int h = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 百位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(2))); // 个位
oneComma.append(upperAmount[h])
.append(unit[4])
.append(upperAmount[0])
.append(upperAmount[e]);
} else if (Pattern  .compile("[1-9]{2}0{1}")
.matcher(sce[i])
.matches()) {
int h = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 百位
int d = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 十位
oneComma.append(upperAmount[h])
.append(unit[4])
.append(upperAmount[d])
.append(unit[3]);
} else if (Pattern  .compile("[1-9]{1}")
.matcher(sce[i])
.matches()) {
int e = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 个位
oneComma.append(upperAmount[e]);
} else if (Pattern  .compile("[1-9]{2}")
.matcher(sce[i])
.matches()) { // 两位
int d = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 十位
int e = Integer.valueOf(String.valueOf(sce[i].charAt(1))); // 个位
oneComma.append(upperAmount[d])
.append(unit[3])
.append(upperAmount[e]);
} else if (Pattern  .compile("[1-9]{1}0{1}")
.matcher(sce[i])
.matches()) {
int d = Integer.valueOf(String.valueOf(sce[i].charAt(0))); // 十位
oneComma.append(upperAmount[d]).append(unit[3]);
}
}
if (sce.length == 3) {
if (i == 2) {
result.insert(0, oneComma.toString()).append(unit[2]);
} else if (i == 1) {// 有一个逗号(包含万位单位)
oneComma.append(unit[6]);
result.insert(0, oneComma.toString());
} else if (i == 0) { // 有两个逗号(包含亿位单位)
oneComma.append(unit[7]);
result.insert(0, oneComma.toString());
}
} else if (sce.length == 2) {
if (i == 1) {
result.insert(0, oneComma.toString()).append(unit[2]);
} else if (i == 0) {// 有一个逗号(包含万位单位)
oneComma.append(unit[6]);
result.insert(0, oneComma.toString());
}
} else if (sce.length == 1) {// 没有逗号,最大单位为千
result.insert(0, oneComma.toString()).append(unit[2]);
}
}
// 小数读法
if (integral.length() == 1) { // 只带角
result  .append(upperAmount[0])
.append(upperAmount[Integer.valueOf(integral)])
.append(unit[1]);
} else if (integral.length() == 2) {
if (!integral.startsWith("0")) {// 有角有分
result  .append(upperAmount[0])
.append(upperAmount[Integer.valueOf(String.valueOf(integral.charAt(0)))])
.append(unit[1])
.append(upperAmount[Integer.valueOf(String.valueOf(integral.charAt(1)))])
.append(unit[0]);
} else {// 只有分
result  .append(upperAmount[0])
.append(upperAmount[Integer.valueOf(String.valueOf(integral.charAt(1)))])
.append(unit[0]);
}
} else if (integral.equals("")) {
result.append(wholeUnit);
}
return result.toString();
}