目录
字符串工具类
package com.github.wxiaoqi.demo;
import java.io.UnsupportedEncodingException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
*
*
* @Title: StringHelper.java
* @Package com.jarvis.base.utils
* @Description:
* @date 2017年9月2日 下午2:23:51
* @version V1.0 字符串处理工具类。
*/
public final class StringHelper {
/**
* 描述： 构造方法
*/
private StringHelper() {
}
/**
* 空字符串
*/
public static final String EMPTY_STRING = "";
/**
* 点
*/
public static final char DOT = '.';
/**
* 下划线
*/
public static final char UNDERSCORE = '_';
/**
* 逗点及空格
*/
public static final String COMMA_SPACE = ", ";
/**
* 逗点
*/
public static final String COMMA = ",";
/**
* 开始括号
*/
public static final String OPEN_PAREN = "(";
/**
* 结束括号
*/
public static final String CLOSE_PAREN = ")";
/**
* 单引号
*/
public static final char SINGLE_QUOTE = '\'';
/**
* 回车
*/
public static final String CRLF = "\r\n";
/**
* 常量 12
*/
public static final int FIANL_TWELVE = 12;
/**
* 十六进制常量 0x80
*/
public static final int HEX_80 = 0x80;
/**
* 十六进制常量 0xff
*/
public static final int HEX_FF = 0xff;
/**
* 把字符数组，转化为一个字符
*
* @param seperator
* 字符分隔符
* @param strings
* 数组对象
* @return 字符串
*/
public static String join(String seperator, String[] strings) {
int length = strings.length;
if (length == 0) {
return EMPTY_STRING;
}
StringBuffer buf = new StringBuffer(length * strings[0].length()).append(strings[0]);
for (int i = 1; i < length; i++) {
buf.append(seperator).append(strings[i]);
}
return buf.toString();
}
/**
* 把迭代对象转化为一个字符串
*
* @param seperator
* 分隔符
* @param objects
* 迭代器对象
* @return 字符串
*/
public static String join(String seperator, Iterator<?> objects) {
StringBuffer buf = new StringBuffer();
if (objects.hasNext()) {
buf.append(objects.next());
}
while (objects.hasNext()) {
buf.append(seperator).append(objects.next());
}
return buf.toString();
}
/**
* 把两个字符串数组的元素用分隔符连接，生成新的数组，生成的数组以第一个字符串数组为参照，与其长度相同。
*
* @param x
* 字符串数组
* @param seperator
* 分隔符
* @param y
* 字符串数组
* @return 组合后的字符串数组
*/
public static String[] add(String[] x, String seperator, String[] y) {
String[] result = new String[x.length];
for (int i = 0; i < x.length; i++) {
result[i] = x[i] + seperator + y[i];
}
return result;
}
/**
* 生成一个重复的字符串，如需要重复*10次，则生成：**********。
*
* @param string
* 重复元素
* @param times
* 重复次数
* @return 生成后的字符串
*/
public static String repeat(String string, int times) {
StringBuffer buf = new StringBuffer(string.length() * times);
for (int i = 0; i < times; i++) {
buf.append(string);
}
return buf.toString();
}
/**
* 字符串替换处理，把旧的字符串替换为新的字符串，主要是通过字符串查找进行处理
*
* @param source
* 需要进行替换的字符串
* @param old
* 需要进行替换的字符串
* @param replace
* 替换成的字符串
* @return 替换处理后的字符串
*/
public static String replace(String source, String old, String replace) {
StringBuffer output = new StringBuffer();
int sourceLen = source.length();
int oldLen = old.length();
int posStart = 0;
int pos;
// 通过截取字符串的方式，替换字符串
while ((pos = source.indexOf(old, posStart)) >= 0) {
output.append(source.substring(posStart, pos));
output.append(replace);
posStart = pos + oldLen;
}
// 如果还有没有处理的字符串，则都添加到新字符串后面
if (posStart < sourceLen) {
output.append(source.substring(posStart));
}
return output.toString();
}
/**
* 替换字符，如果指定进行全替换，必须设wholeWords=true，否则只替换最后出现的字符。
*
* @param template
* 字符模板
* @param placeholder
* 需要替换的字符
* @param replacement
* 新的字符
* @param wholeWords
* 是否需要全替换，true为需要，false为不需要。如果不需要，则只替换最后出现的字符。
* @return 替换后的新字符
*/
public static String replace(String template, String placeholder, String replacement, boolean wholeWords) {
int loc = template.indexOf(placeholder);
if (loc < 0) {
return template;
} else {
final boolean actuallyReplace = wholeWords || loc + placeholder.length() == template.length()
|| !Character.isJavaIdentifierPart(template.charAt(loc + placeholder.length()));
String actualReplacement = actuallyReplace ? replacement : placeholder;
return new StringBuffer(template.substring(0, loc)).append(actualReplacement).append(
replace(template.substring(loc + placeholder.length()), placeholder, replacement, wholeWords))
.toString();
}
}
/**
* 替换字符，只替换第一次出现的字符串。
*
* @param template
* 字符模板
* @param placeholder
* 需要替换的字符串
* @param replacement
* 新字符串
* @return 替换后的字符串
*/
public static String replaceOnce(String template, String placeholder, String replacement) {
int loc = template.indexOf(placeholder);
if (loc < 0) {
return template;
} else {
return new StringBuffer(template.substring(0, loc)).append(replacement)
.append(template.substring(loc + placeholder.length())).toString();
}
}
/**
* 把字符串，按指字的分隔符分隔为字符串数组
*
* @param seperators
* 分隔符
* @param list
* 字符串
* @return 字符串数组
*/
public static String[] split(String list, String seperators) {
return split(list, seperators, false);
}
/**
* 把字符串，按指字的分隔符分隔为字符串数组
*
* @param seperators
* 分隔符
* @param list
* 字符串
* @param include
* 是否需要把分隔符也返回
* @return 字符串数组
*/
public static String[] split(String list, String seperators, boolean include) {
StringTokenizer tokens = new StringTokenizer(list, seperators, include);
String[] result = new String[tokens.countTokens()];
int i = 0;
while (tokens.hasMoreTokens()) {
result[i++] = tokens.nextToken();
}
return result;
}
/**
* 提取字符串中，以.为分隔符后的所有字符，如string.exe，将返回exe。
*
* @param qualifiedName
* 字符串
* @return 提取后的字符串
*/
public static String unqualify(String qualifiedName) {
return unqualify(qualifiedName, ".");
}
/**
* 提取字符串中，以指定分隔符后的所有字符，如string.exe，将返回exe。
*
* @param qualifiedName
* 字符串
* @param seperator
* 分隔符
* @return 提取后的字符串
*/
public static String unqualify(String qualifiedName, String seperator) {
return qualifiedName.substring(qualifiedName.lastIndexOf(seperator) + 1);
}
/**
* 提取字符串中，以.为分隔符以前的字符，如string.exe，则返回string
*
* @param qualifiedName
* 字符串
* @return 提取后的字符串
*/
public static String qualifier(String qualifiedName) {
int loc = qualifiedName.lastIndexOf(".");
if (loc < 0) {
return EMPTY_STRING;
} else {
return qualifiedName.substring(0, loc);
}
}
/**
* 向字符串数组中的所有元素添加上后缀
*
* @param columns
* 字符串数组
* @param suffix
* 后缀
* @return 添加后缀后的数组
*/
public static String[] suffix(String[] columns, String suffix) {
if (suffix == null) {
return columns;
}
String[] qualified = new String[columns.length];
for (int i = 0; i < columns.length; i++) {
qualified[i] = suffix(columns[i], suffix);
}
return qualified;
}
/**
* 向字符串加上后缀
*
* @param name
* 需要添加后缀的字符串
* @param suffix
* 后缀
* @return 添加后缀的字符串
*/
public static String suffix(String name, String suffix) {
return (suffix == null) ? name : name + suffix;
}
/**
* 向字符串数组中的所有元素，添加上前缀
*
* @param columns
* 需要添加前缀的字符串数组
* @param prefix
* prefix
* @return
*/
public static String[] prefix(String[] columns, String prefix) {
if (prefix == null) {
return columns;
}
String[] qualified = new String[columns.length];
for (int i = 0; i < columns.length; i++) {
qualified[i] = prefix + columns[i];
}
return qualified;
}
/**
* 向字符串添加上前缀
*
* @param name
* 需要添加前缀的字符串
* @param prefix
* 前缀
* @return 添加前缀后的字符串
*/
public static String prefix(String name, String prefix) {
return (prefix == null) ? name : prefix + name;
}
/**
* 判断字符串是否为"true"、"t"，如果是，返回true，否则返回false
*
* @param tfString
* 需要进行判断真/假的字符串
* @return true/false
*/
public static boolean booleanValue(String tfString) {
String trimmed = tfString.trim().toLowerCase();
return trimmed.equals("true") || trimmed.equals("t");
}
/**
* 把对象数组转化为字符串
*
* @param array
* 对象数组
* @return 字符串
*/
public static String toString(Object[] array) {
int len = array.length;
if (len == 0) {
return StringHelper.EMPTY_STRING;
}
StringBuffer buf = new StringBuffer(len * FIANL_TWELVE);
for (int i = 0; i < len - 1; i++) {
buf.append(array[i]).append(StringHelper.COMMA_SPACE);
}
return buf.append(array[len - 1]).toString();
}
/**
* 描述：把数组中的所有元素出现的字符串进行替换，把旧字符串替换为新字符数组的所有元素，只替换第一次出现的字符。
*
* @param string
* 需要替换的数组
* @param placeholders
* 需要替换的字符串
* @param replacements
* 新字符串数组
* @return 替换后的字符串数组
*/
public static String[] multiply(String string, Iterator<?> placeholders, Iterator<?> replacements) {
String[] result = new String[] { string };
while (placeholders.hasNext()) {
result = multiply(result, (String) placeholders.next(), (String[]) replacements.next());
}
return result;
}
/**
* 把数组中的所有元素出现的字符串进行替换，把旧字符串替换为新字符数组的所有元素，只替换第一次出现的字符。
*
* @param strings
* 需要替换的数组
* @param placeholder
* 需要替换的字符串
* @param replacements
* 新字符串数组
* @return 替换后的字符串数组
*/
private static String[] multiply(String[] strings, String placeholder, String[] replacements) {
String[] results = new String[replacements.length * strings.length];
int n = 0;
for (int i = 0; i < replacements.length; i++) {
for (int j = 0; j < strings.length; j++) {
results[n++] = replaceOnce(strings[j], placeholder, replacements[i]);
}
}
return results;
}
/**
* 统计Char在字符串中出现在次数，如"s"在字符串"string"中出现的次数
*
* @param string
* 字符串
* @param character
* 需要进行统计的char
* @return 数量
*/
public static int count(String string, char character) {
int n = 0;
for (int i = 0; i < string.length(); i++) {
if (string.charAt(i) == character) {
n++;
}
}
return n;
}
/**
* 描述：计算字符串中未引用的字符
*
* @param string
* 字符串
* @param character
* 字符
* @return 未引用的字符数
*/
public static int countUnquoted(String string, char character) {
if (SINGLE_QUOTE == character) {
throw new IllegalArgumentException("Unquoted count of quotes is invalid");
}
int count = 0;
int stringLength = string == null ? 0 : string.length();
boolean inQuote = false;
for (int indx = 0; indx < stringLength; indx++) {
if (inQuote) {
if (SINGLE_QUOTE == string.charAt(indx)) {
inQuote = false;
}
} else if (SINGLE_QUOTE == string.charAt(indx)) {
inQuote = true;
} else if (string.charAt(indx) == character) {
count++;
}
}
return count;
}
/**
*
* 描述：描述：判断字符串是否为空，如果为true则为空。与isEmpty不同，如果字符为" "也视为空字符
*
* @param str
* 字符串
* @return
*/
public static boolean isBlank(String str) {
boolean b = true;// 20140507 modify by liwei 修复对" "为false的bug
if (str == null) {
b = true;
} else {
int strLen = str.length();
if (strLen == 0) {
b = true;
}
for (int i = 0; i < strLen; i++) {
if (!Character.isWhitespace(str.charAt(i))) {
b = false;
break;
}
}
}
return b;
}
/**
*
* 描述：描述：判断字符串是否为空，如果为true则不为空。与isNotEmpty不同，如果字符为" "也视为空字符
*
* @param str
* 字符串
* @return
*/
public static boolean isNotBlank(String str) {
int strLen = 0;
if (str != null) {
strLen = str.length();
}
if (str == null || strLen == 0) {
return false;
}
for (int i = 0; i < strLen; i++) {
if (!Character.isWhitespace(str.charAt(i))) {
return true;
}
}
return false;
}
/**
* 判断字符串是否非空，如果为true则不为空
*
* @param string
* 字符串
* @return true/false
*/
public static boolean isNotEmpty(String string) {
return string != null && string.length() > 0;
}
/**
* 判断字符串是否空，如果为true则为空
*
* @param str
* 字符串
* @return true/false
*/
public static boolean isEmpty(String str) {
if (str == null || str.trim().length() == 0) {
return true;
}
return false;
}
/**
* 向字符串添加上前缀，并以.作为分隔符
*
* @param name
* 需要添加前缀的字符串
* @param prefix
* 前缀
* @return 添加前缀后的字符串
*/
public static String qualify(String name, String prefix) {
if (name.startsWith("'")) {
return name;
}
return new StringBuffer(prefix.length() + name.length() + 1).append(prefix).append(DOT).append(name).toString();
}
/**
* 向字符串数组中的所有字符添加上前缀，前以点作为分隔符
*
* @param names
* 字符串数组
* @param prefix
* 前缀
* @return 添加前缀后的字符串数组
*/
public static String[] qualify(String[] names, String prefix) {
if (prefix == null) {
return names;
}
int len = names.length;
String[] qualified = new String[len];
for (int i = 0; i < len; i++) {
qualified[i] = qualify(prefix, names[i]);
}
return qualified;
}
/**
* 在字符串中，查找字符第一次出现的位置
*
* @param sqlString
* 原字符串
* @param string
* 需要查找到字符串
* @param startindex
* 开始位置
* @return 第一个出现的位置
*/
public static int firstIndexOfChar(String sqlString, String string, int startindex) {
int matchAt = -1;
for (int i = 0; i < string.length(); i++) {
int curMatch = sqlString.indexOf(string.charAt(i), startindex);
if (curMatch >= 0) {
if (matchAt == -1) {
matchAt = curMatch;
} else {
matchAt = Math.min(matchAt, curMatch);
}
}
}
return matchAt;
}
/**
* 从字符串中提取指字长度的字符。区分中英文。<br>
* 如果需要加省略号，则将在指定长度上少取3个字符宽度，末尾加上"......"。
*
* @param string
* 字符串
* @param length
* 要取的字符长度，此为中文长度，英文仅当作半个字符。
* @param appendSuspensionPoints
* 是否需要加省略号
* @return 提取后的字符串
*/
public static String truncate(String string, int length, boolean appendSuspensionPoints) {
if (isEmpty(string) || length < 0) {
return string;
}
if (length == 0) {
return "";
}
int strLength = string.length(); // 字符串字符个数
int byteLength = byteLength(string); // 字符串字节长度
length *= 2; // 换成字节长度
// 判断是否需要加省略号
boolean needSus = false;
if (appendSuspensionPoints && byteLength >= length) {
needSus = true;
// 如果需要加省略号，则要少取2个字节用来加省略号
length -= 2;
}
StringBuffer result = new StringBuffer();
int count = 0;
for (int i = 0; i < strLength; i++) {
if (count >= length) { // 取完了
break;
}
char c = string.charAt(i);
if (isLetter(c)) { // Ascill字符
result.append(c);
count += 1;
} else { // 非Ascill字符
if (count == length - 1) { // 如果只要取1个字节了，而后面1个是汉字，就放空格
result.append(" ");
count += 1;
} else {
result.append(c);
count += 2;
}
}
}
if (needSus) {
result.append("...");
}
return result.toString();
}
/**
* 描述：判断一个字符是Ascill字符还是其它字符（如汉，日，韩文字符）
*
* @param c
* 需要判断的字符
* @return
*/
public static boolean isLetter(char c) {
int k = HEX_80;
return c / k == 0 ? true : false;
}
/**
* 得到一个字符串的长度,显示的长度,一个汉字或日韩文长度为2,英文字符长度为1
*
* @param s
* ,需要得到长度的字符串
* @return int, 得到的字符串长度
*/
public static int byteLength(String s) {
char[] c = s.toCharArray();
int len = 0;
for (int i = 0; i < c.length; i++) {
if (isLetter(c[i])) {
len++;
} else {
len += 2;
}
}
return len;
}
/**
* 从字符串中提取指字长度的字符
*
* @param string
* 字符串
* @param length
* 字符长度
* @return 提取后的字符串
*/
public static String truncate(String string, int length) {
if (isEmpty(string)) {
return string;
}
if (string.length() <= length) {
return string;
} else {
return string.substring(0, length);
}
}
/**
* 去丢字符的左侧空格
*
* @param value
* 字符串
* @return 去丢左侧空格后的字符串
*/
public static String leftTrim(String value) {
String result = value;
if (result == null) {
return result;
}
char ch[] = result.toCharArray();
int index = -1;
for (int i = 0; i < ch.length; i++) {
if (!Character.isWhitespace(ch[i])) {
break;
}
index = i;
}
if (index != -1) {
result = result.substring(index + 1);
}
return result;
}
/**
* 去丢字符的右侧空格
*
* @param value
* 字符串
* @return 去右侧空格后的字符串
*/
public static String rightTrim(String value) {
String result = value;
if (result == null) {
return result;
}
char ch[] = result.toCharArray();
int endIndex = -1;
for (int i = ch.length - 1; i > -1; i--) {
if (!Character.isWhitespace(ch[i])) {
break;
}
endIndex = i;
}
if (endIndex != -1) {
result = result.substring(0, endIndex);
}
return result;
}
/**
* 把null字符串转化为""
*
* @param source
* 空字符串
* @return 转化后的字符串
*/
public static String n2s(String source) {
return source != null ? source : "";
}
/**
* 如果字符串为空，则返回默认字符串
*
* @param source
* 源字符串
* @param defaultStr
* 默认字符串
* @return 转换后的字符串
*/
public static String n2s(String source, String defaultStr) {
return source != null ? source : defaultStr;
}
/**
* 将字符串格式化成 HTML 以SCRIPT变量 主要是替换单,双引号，以将内容格式化输出，适合于 HTML 中的显示输出
*
* @param str
* 要格式化的字符串
* @return 格式化后的字符串
*/
public static String toScript(String str) {
if (str == null) {
return null;
}
String html = new String(str);
html = replace(html, "\"", "\\\"");
html = replace(html, "\r\n", "\n");
html = replace(html, "\n", "\\n");
html = replace(html, "\t", " ");
html = replace(html, "\'", "\\\'");
html = replace(html, " ", " ");
html = replace(html, "</script>", "<\\/script>");
html = replace(html, "</SCRIPT>", "<\\/SCRIPT>");
return html;
}
/**
* 同于String#trim()，但是检测null，如果原字符串为null，则仍然返回null
*
* @param s
* s
* @return
*/
public static String trim(String s) {
return s == null ? s : s.trim();
}
/**
* 对字符串进行空格处理，如果字符串为null呀是空字符串， 则返回默认的数字。
*
* @param source
* 需要进行处理的字符串
* @param defaultValue
* 缺省值
* @return 字符串的数字值
*/
public static int strTrim(String source, int defaultValue) {
if (isEmpty(source)) {
return defaultValue;
}
try {
source = source.trim();
int value = (new Integer(source)).intValue();
return value;
} catch (Exception ex) {
ex.printStackTrace();
System.err.println("数字转换出错，请检查数据来源。返回默认值");
return defaultValue;
}
}
/**
* 对字符串进行过滤处理，如果字符串是null或为空字符串， 返回默认值。
*
* @param source
* 需要进行处理的字符串
* @param defaultValue
* 缺省值
* @return 过滤后的字符串
*/
public static String strTrim(String source, String defaultValue) {
if (StringHelper.isEmpty(source)) {
return defaultValue;
}
try {
source = source.trim();
return source;
} catch (Exception ex) {
ex.printStackTrace();
System.err.println("字符串去空格失败，返回默认值");
return defaultValue;
}
}
/**
* 描述：为了防止跨站脚本攻击，转换<>这种尖括号。
*
* @param source
* @return
*/
public static String encodeURL(String source) {
if (source == null) {
return null;
}
String html = new String(source);
html = replace(html, "<", "<");
html = replace(html, ">", ">");
html = replace(html, "\"", """);
html = replace(html, " ", " ");
html = replace(html, "\'", "´");
html = replace(html, "\\", "\");
html = replace(html, "&", "&");
html = replace(html, "\r", "");
html = replace(html, "\n", "");
html = replace(html, "(", "(");
html = replace(html, ")", ")");
html = replace(html, "[", "[");
html = replace(html, "]", "]");
html = replace(html, ";", ";");
html = replace(html, "/", "/");
return html;
}
/**
* 把字符串中一些特定的字符转换成html字符，如&、<、>、"号等
*
* @param source
* 需要进行处理的字符串
* @return 处理后的字符串
*/
public static String encodeHtml(String source) {
if (source == null) {
return null;
}
String html = new String(source);
html = replace(html, "&", "&");
html = replace(html, "<", "<");
html = replace(html, ">", ">");
html = replace(html, "\"", """);
html = replace(html, " ", " ");
html = replace(html, "\'", "´");
return html;
}
/**
* 把一些html的字符串还原
*
* @param source
* 需要进行处理的字符串
* @return 处理后的字符串
*/
public static String decodeHtml(String source) {
if (source == null) {
return null;
}
String html = new String(source);
html = replace(html, "&", "&");
html = replace(html, "<", "<");
html = replace(html, ">", ">");
html = replace(html, """, "\"");
html = replace(html, " ", " ");
html = replace(html, "\r\n", "\n");
html = replace(html, "\n", "<br>\n");
html = replace(html, "\t", " ");
html = replace(html, " ", " ");
return html;
}
/**
* 判断字符串是否为布尔值，如true/false等
*
* @param source
* 需要进行判断的字符串
* @return 返回字符串的布尔值
*/
public static boolean isBoolean(String source) {
if (source.equalsIgnoreCase("true") || source.equalsIgnoreCase("false")) {
return true;
}
return false;
}
/**
* 去除字符串中的最后字符
*
* @param str
* 原字符串
* @param strMove
* 要去除字符 比如","
* @return 去除后的字符串
*/
public static String lastCharTrim(String str, String strMove) {
if (isEmpty(str)) {
return "";
}
String newStr = "";
if (str.lastIndexOf(strMove) != -1 && str.lastIndexOf(strMove) == str.length() - 1) {
newStr = str.substring(0, str.lastIndexOf(strMove));
}
return newStr;
}
/**
* 清除字符串里的html代码
*
* @param html
* 需要进行处理的字符串
* @return 清除html后的代码
*/
public static String clearHtml(String html) {
if (isEmpty(html)) {
return "";
}
String patternStr = "(<[^>]*>)";
Pattern pattern = Pattern.compile(patternStr, Pattern.CASE_INSENSITIVE);
Matcher matcher = null;
StringBuffer bf = new StringBuffer();
try {
matcher = pattern.matcher(html);
boolean first = true;
int start = 0;
int end = 0;
while (matcher.find()) {
start = matcher.start(1);
if (first) {
bf.append(html.substring(0, start));
first = false;
} else {
bf.append(html.substring(end, start));
}
end = matcher.end(1);
}
if (end < html.length()) {
bf.append(html.substring(end));
}
html = bf.toString();
return html;
} catch (Exception ex) {
ex.printStackTrace();
System.err.println("清除html标签失败");
} finally {
pattern = null;
matcher = null;
}
return html;
}
/**
* 把文杯格式转换为html格式
*
* @param content
* 转换的内容
* @return
*/
public static String textFmtToHtmlFmt(String content) {
content = StringHelper.replace(content, " ", " ");
content = StringHelper.replace(content, "\r\n", "<br>");
content = StringHelper.replace(content, "\n", "<br>");
return content;
}
/**
*
* 描述：大写英文字母转换成小写
*
* @param strIn
* 字符串参数
* @return
*/
public static String toLowerStr(String strIn) {
String strOut = new String(); // 输出的字串
int len = strIn.length(); // 参数的长度
int i = 0; // 计数器
char ch; // 存放参数的字符
while (i < len) {
ch = strIn.charAt(i);
if (ch >= 'A' && ch <= 'Z') {
ch = (char) (ch - 'A' + 'a');
}
strOut += ch;
i++;
}
return strOut;
}
/**
*
* 描述：小写英文字母转换成大写
*
* @param strIn
* 字符串参数
* @return
*/
public static String toUpperStr(String strIn) {
String strOut = new String(); // 输出的字串
int len = strIn.length(); // 参数的长度
int i = 0; // 计数器
char ch; // 存放参数的字符
while (i < len) {
ch = strIn.charAt(i);
if (ch >= 'a' && ch <= 'z') {
ch = (char) (ch - 'a' + 'A');
}
strOut += ch;
i++;
}
return strOut;
}
/**
* 货币缩写,提供亿和万两个单位，并精确到小数点2位 切换到新的算法:对数算法
*
* @param original
* @return
*/
public static String currencyShortFor(String original) {
if (StringHelper.isBlank(original)) {
return "";
} else {
String shortFor = "";
double shortForValue = 0;
DecimalFormat df = new DecimalFormat("#.00");
try {
double account = Double.parseDouble(original);
if (account / 100000000 > 1) {
shortForValue = account / 100000000;
shortFor = df.format(shortForValue) + "亿";
} else if (account / 10000 > 1) {
shortForValue = account / 10000;
shortFor = df.format(shortForValue) + "万";
} else {
shortFor = original;
}
} catch (NumberFormatException e) {
e.printStackTrace();
System.err.println("字符串[" + original + "]转换成数字出错");
}
return shortFor;
}
}
/**
* 将日期格式由yyyyMMdd装换为yyyy-MM-dd
*
* @param date
* Date string whose format is yyyyMMdd.
* @return
*/
public static String formatDate(String date) {
if (isBlank(date) || date.length() < 8) {
return "";
}
StringBuffer dateBuf = new StringBuffer();
dateBuf.append(date.substring(0, 4));
dateBuf.append("-");
dateBuf.append(date.substring(4, 6));
dateBuf.append("-");
dateBuf.append(date.substring(6, 8));
return dateBuf.toString();
}
static Pattern pattern = Pattern.compile("^\\d+(\\.0)?$", Pattern.CASE_INSENSITIVE);
/**
* 判断是否为整数
*
* @param str
* 传入的字符串
* @return 是整数返回true,否则返回false
*/
public static boolean isInteger(String str) {
return pattern.matcher(str).matches();
}
/**
* 用于=中英文混排标题中限定字符串长度。保证显示长度最多只相差一个全角字符。
*
* @param string
* 需要截取的字符串
* @param byteCount
* 字节数（度量标准为中文为两个字节，ASCII字符为一个字节,这样子，刚好匹配ASCII为半角字符，而中文为全角字符，
* 保证在网页上中英文混合的句子长度一致）
* @return
* @throws UnsupportedEncodingException
*/
public static String substring(String string, int byteCount) throws UnsupportedEncodingException {
if (isBlank(string)) {
return string;
}
byte[] bytes = string.getBytes("Unicode");// 使用UCS-2编码.
int viewBytes = 0; // 表示当前的字节数(英文为单字节，中文为双字节的表示方法)
int ucs2Bytes = 2; // 要截取的字节数，从第3个字节开始,前两位为位序。（UCS-2的表示方法）
// UCS-2每个字符使用两个字节来编码。
// ASCII n+=1,i+=2
// 中文 n+=2,i+=2
for (; ucs2Bytes < bytes.length && viewBytes < byteCount; ucs2Bytes++) {
// 奇数位置，如3、5、7等，为UCS2编码中两个字节的第二个字节
if (ucs2Bytes % 2 == 1) {
viewBytes++; // 低字节，无论中英文，都算一个字节。
} else {
// 当UCS2编码的第一个字节不等于0时，该UCS2字符为汉字，一个汉字算两个字节
// 高位时，仅中文的高位算一字节。
if (bytes[ucs2Bytes] != 0) {
viewBytes++;
}
}
}
// 截一半的汉字要保留
if (ucs2Bytes % 2 == 1) {
ucs2Bytes = ucs2Bytes + 1;
}
String result = new String(bytes, 0, ucs2Bytes, "Unicode");// 将字节流转换为java默认编码UTF-8的字符串
if (bytes.length > ucs2Bytes) {
result += "...";
}
return result;
}
/**
* 描述：根据长度截断字串
*
* @param str
* 字串
* @param length
* 截取长度
* @return
*/
public static String[] splite(String str, int length) {
if (StringHelper.isEmpty(str)) {
return null;
}
String[] strArr = new String[(str.length() + length - 1) / length];
for (int i = 0; i < strArr.length; i++) {
if (str.length() > i * length + length - 1) {
strArr[i] = str.substring(i * length, i * length + length - 1);
} else {
strArr[i] = str.substring(i * length);
}
}
return strArr;
}
/**
* 描述：把某一个字符变成大写
*
* @param str
* str 字串
* @param index
* 第几个字符
* @return
*/
public static String toUpOneChar(String str, int index) {
return toUpOrLowOneChar(str, index, 1);
}
/**
* 描述：把某一个字符变成小写 作者：李建 时间：Dec 17, 2010 9:42:32 PM
*
* @param str
* str 字串
* @param index
* 第几个字符
* @return
*/
public static String toLowOneChar(String str, int index) {
return toUpOrLowOneChar(str, index, 0);
}
/**
* 描述：把某一个字符变成大写或小写 作者：李建 时间：Dec 17, 2010 9:39:32 PM
*
* @param str
* 字串
* @param index
* 第几个字符
* @param upOrLow
* 大小写 1：大写；0小写
* @return
*/
public static String toUpOrLowOneChar(String str, int index, int upOrLow) {
if (StringHelper.isNotEmpty(str) && index > -1 && index < str.length()) {
char[] chars = str.toCharArray();
if (upOrLow == 1) {
chars[index] = Character.toUpperCase(chars[index]);
} else {
chars[index] = Character.toLowerCase(chars[index]);
}
return new String(chars);
}
return str;
}
/**
* 将字符串用分隔符断裂成字符串列表
*
* @param value
* 原字符串
* @param separator
* 分隔字符
* @return 结果列表
*/
public static List<String> split2List(String value, String separator) {
List<String> ls = new ArrayList<String>();
int i = 0, j = 0;
while ((i = value.indexOf(separator, i)) != -1) {
ls.add(value.substring(j, i));
++i;
j = i;
}
ls.add(value.substring(j));
return ls;
}
/**
* 将数组用分隔符连接成新字符串(split的逆方法)
*
* @param strs
* 字符串数组
* @param sep
* 分隔符
* @return 结果字符串
*/
public static String join(String[] strs, String sep) {
StringBuilder res = new StringBuilder();
for (int i = 0; i < strs.length; i++) {
res.append(strs[i] + sep);
}
return res.substring(0, res.length() - sep.length());
}
/**
* 获得一个UUID
*
* @return String UUID
*/
public static String getUUID() {
String str = UUID.randomUUID().toString();// 标准的UUID格式为：xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx(8-4-4-4-12)
// 去掉"-"符号，不用replaceAll的原因与split一样，replaceAll支持正则表达式，频繁使用时效率不够高(当然偶尔用一下影响也不会特别严重)
return join(split(str, "-"), "");
}
/**
* <pre>
* 例： String strVal="This is a dog"; String
* strResult=CTools.replace(strVal,"dog","cat"); 结果： strResult equals
* "This is cat"
*
* @param strSrc
* 要进行替换操作的字符串
* @param strOld
* 要查找的字符串
* @param strNew
* 要替换的字符串
* @return 替换后的字符串
*
* <pre>
*/
public static final String replaceAllStr(String strSrc, String strOld, String strNew) {
if (strSrc == null || strOld == null || strNew == null) {
return "";
}
int i = 0;
// 避免新旧字符一样产生死循环
if (strOld.equals(strNew)) {
return strSrc;
}
if ((i = strSrc.indexOf(strOld, i)) >= 0) {
char[] arr_cSrc = strSrc.toCharArray();
char[] arr_cNew = strNew.toCharArray();
int intOldLen = strOld.length();
StringBuffer buf = new StringBuffer(arr_cSrc.length);
buf.append(arr_cSrc, 0, i).append(arr_cNew);
i += intOldLen;
int j = i;
while ((i = strSrc.indexOf(strOld, i)) > 0) {
buf.append(arr_cSrc, j, i - j).append(arr_cNew);
i += intOldLen;
j = i;
}
buf.append(arr_cSrc, j, arr_cSrc.length - j);
return buf.toString();
}
return strSrc;
}
/**
* 用于将字符串中的特殊字符转换成Web页中可以安全显示的字符串 可对表单数据据进行处理对一些页面特殊字符进行处理如'
* <','>','"',''','&'
*
* @param strSrc
* 要进行替换操作的字符串
* @return 替换特殊字符后的字符串
* @since 1.0
*/
public static String htmlEncode(String strSrc) {
if (strSrc == null) {
return "";
}
char[] arr_cSrc = strSrc.toCharArray();
StringBuffer buf = new StringBuffer(arr_cSrc.length);
char ch;
for (int i = 0; i < arr_cSrc.length; i++) {
ch = arr_cSrc[i];
if (ch == '<') {
buf.append("<");
} else if (ch == '>') {
buf.append(">");
} else if (ch == '"') {
buf.append(""");
} else if (ch == '\'') {
buf.append("'");
} else if (ch == '&') {
buf.append("&");
} else {
buf.append(ch);
}
}
return buf.toString();
}
/**
* 用于将字符串中的特殊字符转换成Web页中可以安全显示的字符串 可对表单数据据进行处理对一些页面特殊字符进行处理如'
* <','>','"',''','&'
*
* @param strSrc
* 要进行替换操作的字符串
* @param quotes
* 为0时单引号和双引号都替换，为1时不替换单引号，为2时不替换双引号，为3时单引号和双引号都不替换
* @return 替换特殊字符后的字符串
* @since 1.0
*/
public static String htmlEncode(String strSrc, int quotes) {
if (strSrc == null) {
return "";
}
if (quotes == 0) {
return htmlEncode(strSrc);
}
char[] arr_cSrc = strSrc.toCharArray();
StringBuffer buf = new StringBuffer(arr_cSrc.length);
char ch;
for (int i = 0; i < arr_cSrc.length; i++) {
ch = arr_cSrc[i];
if (ch == '<') {
buf.append("<");
} else if (ch == '>') {
buf.append(">");
} else if (ch == '"' && quotes == 1) {
buf.append(""");
} else if (ch == '\'' && quotes == 2) {
buf.append("'");
} else if (ch == '&') {
buf.append("&");
} else {
buf.append(ch);
}
}
return buf.toString();
}
/**
* 和htmlEncode正好相反
*
* @param strSrc
* 要进行转换的字符串
* @return 转换后的字符串
* @since 1.0
*/
public static String htmlDecode(String strSrc) {
if (strSrc == null) {
return "";
}
strSrc = strSrc.replaceAll("<", "<");
strSrc = strSrc.replaceAll(">", ">");
strSrc = strSrc.replaceAll(""", "\"");
strSrc = strSrc.replaceAll("'", "'");
strSrc = strSrc.replaceAll("&", "&");
return strSrc;
}
/**
* 实际处理 return toChineseNoReplace(null2Blank(str));
*
* @param str
* 要进行处理的字符串
* @return 转换后的字符串
*/
public static String toChineseAndHtmlEncode(String str, int quotes) {
try {
if (str == null) {
return "";
} else {
str = str.trim();
str = new String(str.getBytes("ISO8859_1"), "GBK");
String htmlEncode = htmlEncode(str, quotes);
return htmlEncode;
}
} catch (Exception exp) {
return "";
}
}
/**
* 把null值和""值转换成 主要应用于页面表格格的显示
*
* @param str
* 要进行处理的字符串
* @return 转换后的字符串
*/
public static String str4Table(String str) {
if (str == null) {
return " ";
}
else if (str.equals("")) {
return " ";
} else {
return str;
}
}
}加密工具类
-
AES加解密
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
/**
* AES加解密
*
* @Author:Devil
*/
public class AESUtils {
/** 默认秘钥 */
protected static final String KEY = "BC3EKnzMD3dndw1Xs2KzESXCHgVlGOoYyFwLdS24Im2e7YyhB0wrUsyYf0";
/**
* AES解密
*/
protected static String decrypt(String encryptValue, String key) throws Exception {
return aesDecryptByBytes(base64Decode(encryptValue), key);
}
/**
* AES加密
*/
protected static String encrypt(String value, String key) throws Exception {
return base64Encode(aesEncryptToBytes(value, key));
}
private static String base64Encode(byte[] bytes){
return Base64Utils.encrypt(bytes);
}
@SuppressWarnings("static-access")
private static byte[] base64Decode(String base64Code) throws Exception{
return base64Code == null ? null : Base64Utils.decrypt(base64Code);
}
private static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(encryptKey.getBytes()));
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
return cipher.doFinal(content.getBytes("utf-8"));
}
private static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(decryptKey.getBytes()));
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
byte[] decryptBytes = cipher.doFinal(encryptBytes);
return new String(decryptBytes);
}
}
-
DES加解密
package com.demo;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.security.SecureRandom;
/**
* DES加解密工具类
*
* @Author:Devil
*
*/
class DESUtils {
/** 默认key */
protected final static String KEY = "ScAKC0XhadTHT3Al0QIDAQAB";
/**
* DES加密
*/
protected static String encrypt(String data, String key) {
String encryptedData = null;
try {
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
DESKeySpec deskey = new DESKeySpec(key.getBytes());
// 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey secretKey = keyFactory.generateSecret(deskey);
// 加密对象
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, secretKey, sr);
// 加密，并把字节数组编码成字符串
encryptedData = new sun.misc.BASE64Encoder().encode(cipher.doFinal(data.getBytes()));
} catch (Exception e) {
throw new RuntimeException("加密错误，错误信息：", e);
}
return encryptedData;
}
/**
* DES解密
*/
protected static String decrypt(String cryptData, String key) {
String decryptedData = null;
try {
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
DESKeySpec deskey = new DESKeySpec(key.getBytes());
// 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey secretKey = keyFactory.generateSecret(deskey);
// 解密对象
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.DECRYPT_MODE, secretKey, sr);
// 把字符串解码为字节数组，并解密
decryptedData = new String(cipher.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(cryptData)));
} catch (Exception e) {
throw new RuntimeException("解密错误，错误信息：", e);
}
return decryptedData;
}
//######################################################################################################################
static Key key;
/**
* 根据参数生成KEY
*/
public static void getKey(String strKey) {
try {
KeyGenerator _generator = KeyGenerator.getInstance("DES");
SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG" );
secureRandom.setSeed(strKey.getBytes());
//_generator.init(new SecureRandom(strKey.getBytes()));Linux下会报错
_generator.init(secureRandom);
key = _generator.generateKey();
_generator = null;
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 加密以byte[]明文输入,byte[]密文输出
*/
private static byte[] getEncCode(byte[] byteS) {
byte[] byteFina = null;
Cipher cipher;
try {
cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, key);
byteFina = cipher.doFinal(byteS);
} catch (Exception e) {
e.printStackTrace();
} finally {
cipher = null;
}
return byteFina;
}
/**
* 解密以byte[]密文输入,以byte[]明文输出
*/
private static byte[] getDesCode(byte[] byteD) {
Cipher cipher;
byte[] byteFina = null;
try {
cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");//DES/ECB/NoPadding;DES/ECB/ISO10126Padding
cipher.init(Cipher.DECRYPT_MODE, key);
byteFina = cipher.doFinal(byteD);
} catch (Exception e) {
e.printStackTrace();
} finally {
cipher = null;
}
return byteFina;
}
}
-
MD5
import java.nio.charset.Charset;
import java.security.DigestException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
//################################################################# MD5工具类 #####################################################
/**
* 获取字符串的MD5
* @param string 字符串
* @return String MD5字符串
* @throws NoSuchAlgorithmException
*/
public static String getStringMD5(String string,String salt) throws NoSuchAlgorithmException{
String target=null;
if(StringUtils.isBlank(salt)){
target=string;
}else{
target=getStringMD5(salt+string+salt, null);
}
byte[] byteString=target.getBytes(Charset.forName("utf-8"));
MessageDigest md=MessageDigest.getInstance("MD5");
byte[] array=md.digest(byteString);
StringBuffer sb = new StringBuffer();
for (int i = 0; i < array.length; ++i) {
sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1,3));
}
return sb.toString();
}
/**
* 获取文件MD5
* @param filePath 文件路径
* @return String
* @throws NoSuchAlgorithmException
* @throws IOException
* @throws DigestException
*/
public static String getFileMD5(String filePath) throws NoSuchAlgorithmException, IOException, DigestException{
MessageDigest md=MessageDigest.getInstance("MD5");
int length=0;
byte[] buffer=new byte[1024];
byte[] array=null;
InputStream is=new FileInputStream(new File(filePath));
while((length=is.read(buffer))!=-1){
md.update(buffer,0,length);
}
is.close();
array=md.digest();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < array.length; ++i) {
sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1,3));
}
return sb.toString();
}
- Base64编码
package com.demo;
/**
* BASE64加解密工具类
*
* @Author:Devil
*
*/
class Base64Utils {
private static char[] base64EncodeChars = new char[] { 'A', 'B', 'C', 'D',
'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/' };
private static byte[] base64DecodeChars = new byte[] { -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1,
-1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1,
-1, -1 };
/**
* BASE64加密
*/
protected static String encrypt(byte[] data) {
StringBuffer sb = new StringBuffer();
int len = data.length;
int i = 0;
int b1, b2, b3;
while (i < len) {
b1 = data[i++] & 0xff;
if (i == len) {
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[(b1 & 0x3) << 4]);
sb.append("==");
break;
}
b2 = data[i++] & 0xff;
if (i == len) {
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[((b1 & 0x03) << 4)
| ((b2 & 0xf0) >>> 4)]);
sb.append(base64EncodeChars[(b2 & 0x0f) << 2]);
sb.append("=");
break;
}
b3 = data[i++] & 0xff;
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[((b1 & 0x03) << 4)
| ((b2 & 0xf0) >>> 4)]);
sb.append(base64EncodeChars[((b2 & 0x0f) << 2)
| ((b3 & 0xc0) >>> 6)]);
sb.append(base64EncodeChars[b3 & 0x3f]);
}
return sb.toString();
}
/**
* Base64 解密
*/
protected static byte[] decrypt(String str) throws Exception{
StringBuffer sb = new StringBuffer();
byte[] data = str.getBytes("US-ASCII");
int len = data.length;
int i = 0;
int b1, b2, b3, b4;
while (i < len) {
do {
b1 = base64DecodeChars[data[i++]];
} while (i < len && b1 == -1);
if (b1 == -1) {
break;
}
do {
b2 = base64DecodeChars[data[i++]];
} while (i < len && b2 == -1);
if (b2 == -1) {
break;
}
sb.append((char) ((b1 << 2) | ((b2 & 0x30) >>> 4)));
do {
b3 = data[i++];
if (b3 == 61) {
return sb.toString().getBytes("iso8859-1");
}
b3 = base64DecodeChars[b3];
} while (i < len && b3 == -1);
if (b3 == -1) {
break;
}
sb.append((char) (((b2 & 0x0f) << 4) | ((b3 & 0x3c) >>> 2)));
do {
b4 = data[i++];
if (b4 == 61) {
return sb.toString().getBytes("iso8859-1");
}
b4 = base64DecodeChars[b4];
} while (i < len && b4 == -1);
if (b4 == -1) {
break;
}
sb.append((char) (((b3 & 0x03) << 6) | b4));
}
return sb.toString().getBytes("iso8859-1");
}
}
系统操作工具类
-
获取系统CPU,内存,硬盘使用率
package com.demo;
import com.sun.management.OperatingSystemMXBean;
import lombok.extern.slf4j.Slf4j;
import java.io.*;
import java.lang.management.ManagementFactory;
import java.math.BigDecimal;
import java.util.*;
@Slf4j
public class ComputerMonitorUtil {
private static String osName = System.getProperty("os.name");
private static final int CPUTIME = 500;
private static final int PERCENT = 100;
private static final int FAULTLENGTH = 10;
/**
* 功能：获取Linux和Window系统cpu使用率
*/
public static double getCpuUsage() {
// 如果是window系统
if (osName.toLowerCase().contains("windows")
|| osName.toLowerCase().contains("win")) {
try {
String procCmd = System.getenv("windir")
+ "//system32//wbem//wmic.exe process get Caption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";
// 取进程信息
long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));//第一次读取CPU信息
Thread.sleep(CPUTIME);//睡500ms
long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));//第二次读取CPU信息
if (c0 != null && c1 != null) {
long idletime = c1[0] - c0[0];//空闲时间
long busytime = c1[1] - c0[1];//使用时间
Double cpusage = Double.valueOf(PERCENT * (busytime) * 1.0 / (busytime + idletime));
BigDecimal b1 = new BigDecimal(cpusage);
double cpuUsage = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
return cpuUsage;
} else {
return 0.0;
}
} catch (Exception ex) {
log.debug(ex.toString());
return 0.0;
}
} else {
try {
Map<?, ?> map1 = ComputerMonitorUtil.cpuinfo();
Thread.sleep(CPUTIME);
Map<?, ?> map2 = ComputerMonitorUtil.cpuinfo();
long user1 = Long.parseLong(map1.get("user").toString());
long nice1 = Long.parseLong(map1.get("nice").toString());
long system1 = Long.parseLong(map1.get("system").toString());
long idle1 = Long.parseLong(map1.get("idle").toString());
long user2 = Long.parseLong(map2.get("user").toString());
long nice2 = Long.parseLong(map2.get("nice").toString());
long system2 = Long.parseLong(map2.get("system").toString());
long idle2 = Long.parseLong(map2.get("idle").toString());
long total1 = user1 + system1 + nice1;
long total2 = user2 + system2 + nice2;
float total = total2 - total1;
long totalIdle1 = user1 + nice1 + system1 + idle1;
long totalIdle2 = user2 + nice2 + system2 + idle2;
float totalidle = totalIdle2 - totalIdle1;
float cpusage = (total / totalidle) * 100;
BigDecimal b1 = new BigDecimal(cpusage);
double cpuUsage = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
return cpuUsage;
} catch (InterruptedException e) {
log.debug(e.toString());
}
}
return 0;
}
/**
* 功能：Linux CPU使用信息
*/
public static Map<?, ?> cpuinfo() {
InputStreamReader inputs = null;
BufferedReader buffer = null;
Map<String, Object> map = new HashMap<String, Object>();
try {
inputs = new InputStreamReader(new FileInputStream("/proc/stat"));
buffer = new BufferedReader(inputs);
String line = "";
while (true) {
line = buffer.readLine();
if (line == null) {
break;
}
if (line.startsWith("cpu")) {
StringTokenizer tokenizer = new StringTokenizer(line);
List<String> temp = new ArrayList<String>();
while (tokenizer.hasMoreElements()) {
String value = tokenizer.nextToken();
temp.add(value);
}
map.put("user", temp.get(1));
map.put("nice", temp.get(2));
map.put("system", temp.get(3));
map.put("idle", temp.get(4));
map.put("iowait", temp.get(5));
map.put("irq", temp.get(6));
map.put("softirq", temp.get(7));
map.put("stealstolen", temp.get(8));
break;
}
}
} catch (Exception e) {
log.debug(e.toString());
} finally {
try {
buffer.close();
inputs.close();
} catch (Exception e2) {
log.debug(e2.toString());
}
}
return map;
}
/**
* 功能：Linux 和 Window 内存使用率
*/
public static double getMemUsage() {
if (osName.toLowerCase().contains("windows")
|| osName.toLowerCase().contains("win")) {
try {
OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory
.getOperatingSystemMXBean();
// 总的物理内存+虚拟内存
long totalvirtualMemory = osmxb.getTotalSwapSpaceSize();
// 剩余的物理内存
long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize();
Double usage = (Double) (1 - freePhysicalMemorySize * 1.0 / totalvirtualMemory) * 100;
BigDecimal b1 = new BigDecimal(usage);
double memoryUsage = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
return memoryUsage;
} catch (Exception e) {
log.debug(e.toString());
}
} else {
Map<String, Object> map = new HashMap<String, Object>();
InputStreamReader inputs = null;
BufferedReader buffer = null;
try {
inputs = new InputStreamReader(new FileInputStream("/proc/meminfo"));
buffer = new BufferedReader(inputs);
String line = "";
while (true) {
line = buffer.readLine();
if (line == null) {
break;
}
int beginIndex = 0;
int endIndex = line.indexOf(":");
if (endIndex != -1) {
String key = line.substring(beginIndex, endIndex);
beginIndex = endIndex + 1;
endIndex = line.length();
String memory = line.substring(beginIndex, endIndex);
String value = memory.replace("kB", "").trim();
map.put(key, value);
}
}
long memTotal = Long.parseLong(map.get("MemTotal").toString());
long memFree = Long.parseLong(map.get("MemFree").toString());
long memused = memTotal - memFree;
long buffers = Long.parseLong(map.get("Buffers").toString());
long cached = Long.parseLong(map.get("Cached").toString());
double usage = (double) (memused - buffers - cached) / memTotal * 100;
BigDecimal b1 = new BigDecimal(usage);
double memoryUsage = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
return memoryUsage;
} catch (Exception e) {
log.debug(e.toString());
} finally {
try {
buffer.close();
inputs.close();
} catch (Exception e2) {
log.debug(e2.toString());
}
}
}
return 0.0;
}
/**
* Window 和Linux 得到磁盘的使用率
*
* @return
* @throws Exception
*/
public static double getDiskUsage() throws Exception {
double totalHD = 0;
double usedHD = 0;
if (osName.toLowerCase().contains("windows")
|| osName.toLowerCase().contains("win")) {
long allTotal = 0;
long allFree = 0;
for (char c = 'A'; c <= 'Z'; c++) {
String dirName = c + ":/";
File win = new File(dirName);
if (win.exists()) {
long total = (long) win.getTotalSpace();
long free = (long) win.getFreeSpace();
allTotal = allTotal + total;
allFree = allFree + free;
}
}
Double precent = (Double) (1 - allFree * 1.0 / allTotal) * 100;
BigDecimal b1 = new BigDecimal(precent);
precent = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
return precent;
} else {
Runtime rt = Runtime.getRuntime();
Process p = rt.exec("df -hl");// df -hl 查看硬盘空间
BufferedReader in = null;
try {
in = new BufferedReader(new InputStreamReader(p.getInputStream()));
String str = null;
String[] strArray = null;
while ((str = in.readLine()) != null) {
int m = 0;
strArray = str.split(" ");
for (String tmp : strArray) {
if (tmp.trim().length() == 0) {
continue;
}
++m;
if (tmp.indexOf("G") != -1) {
if (m == 2) {
if (!tmp.equals("") && !tmp.equals("0")) {
totalHD += Double.parseDouble(tmp.substring(0, tmp.length() - 1)) * 1024;
}
}
if (m == 3) {
if (!tmp.equals("none") && !tmp.equals("0")) {
usedHD += Double.parseDouble(tmp.substring(0, tmp.length() - 1)) * 1024;
}
}
}
if (tmp.indexOf("M") != -1) {
if (m == 2) {
if (!tmp.equals("") && !tmp.equals("0")) {
totalHD += Double.parseDouble(tmp.substring(0, tmp.length() - 1));
}
}
if (m == 3) {
if (!tmp.equals("none") && !tmp.equals("0")) {
usedHD += Double.parseDouble(tmp.substring(0, tmp.length() - 1));
}
}
}
}
}
} catch (Exception e) {
log.debug(e.toString());
} finally {
in.close();
}
// 保留2位小数
double precent = (usedHD / totalHD) * 100;
BigDecimal b1 = new BigDecimal(precent);
precent = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
return precent;
}
}
// window读取cpu相关信息
private static long[] readCpu(final Process proc) {
long[] retn = new long[2];
try {
proc.getOutputStream().close();
InputStreamReader ir = new InputStreamReader(proc.getInputStream());
LineNumberReader input = new LineNumberReader(ir);
String line = input.readLine();
if (line == null || line.length() < FAULTLENGTH) {
return null;
}
int capidx = line.indexOf("Caption");
int cmdidx = line.indexOf("CommandLine");
int rocidx = line.indexOf("ReadOperationCount");
int umtidx = line.indexOf("UserModeTime");
int kmtidx = line.indexOf("KernelModeTime");
int wocidx = line.indexOf("WriteOperationCount");
long idletime = 0;
long kneltime = 0;//读取物理设备时间
long usertime = 0;//执行代码占用时间
while ((line = input.readLine()) != null) {
if (line.length() < wocidx) {
continue;
}
// 字段出现顺序：Caption,CommandLine,KernelModeTime,ReadOperationCount
String caption = substring(line, capidx, cmdidx - 1).trim();
// System.out.println("caption:"+caption);
String cmd = substring(line, cmdidx, kmtidx - 1).trim();
// System.out.println("cmd:"+cmd);
if (cmd.indexOf("wmic.exe") >= 0) {
continue;
}
String s1 = substring(line, kmtidx, rocidx - 1).trim();
String s2 = substring(line, umtidx, wocidx - 1).trim();
List<String> digitS1 = getDigit(s1);
List<String> digitS2 = getDigit(s2);
if (caption.equals("System Idle Process") || caption.equals("System")) {
if (s1.length() > 0) {
if (!digitS1.get(0).equals("") && digitS1.get(0) != null) {
idletime += Long.valueOf(digitS1.get(0)).longValue();
}
}
if (s2.length() > 0) {
if (!digitS2.get(0).equals("") && digitS2.get(0) != null) {
idletime += Long.valueOf(digitS2.get(0)).longValue();
}
}
continue;
}
if (s1.length() > 0) {
if (!digitS1.get(0).equals("") && digitS1.get(0) != null) {
kneltime += Long.valueOf(digitS1.get(0)).longValue();
}
}
if (s2.length() > 0) {
if (!digitS2.get(0).equals("") && digitS2.get(0) != null) {
kneltime += Long.valueOf(digitS2.get(0)).longValue();
}
}
}
retn[0] = idletime;
retn[1] = kneltime + usertime;
return retn;
} catch (Exception ex) {
log.debug(ex.toString());
} finally {
try {
proc.getInputStream().close();
} catch (Exception e) {
log.debug(e.toString());
}
}
return null;
}
/**
* 从字符串文本中获得数字
*
* @param text
* @return
*/
private static List<String> getDigit(String text) {
List<String> digitList = new ArrayList<String>();
digitList.add(text.replaceAll("\\D", ""));
return digitList;
}
/**
* 由于String.subString对汉字处理存在问题（把一个汉字视为一个字节)，因此在 包含汉字的字符串时存在隐患，现调整如下：
*
* @param src 要截取的字符串
* @param start_idx 开始坐标（包括该坐标)
* @param end_idx 截止坐标（包括该坐标）
* @return
*/
private static String substring(String src, int start_idx, int end_idx) {
byte[] b = src.getBytes();
String tgt = "";
for (int i = start_idx; i <= end_idx; i++) {
tgt += (char) b[i];
}
return tgt;
}
public static void main(String[] args) throws Exception {
double cpuUsage = ComputerMonitorUtil.getCpuUsage();
//当前系统的内存使用率
double memUsage = ComputerMonitorUtil.getMemUsage();
//当前系统的硬盘使用率
double diskUsage = ComputerMonitorUtil.getDiskUsage();
System.out.println("cpuUsage:" + cpuUsage);
System.out.println("memUsage:" + memUsage);
System.out.println("diskUsage:" + diskUsage);
}
}
-
获取系统系统相关序列号
/**
* 获取主板序列号
*
* @return
*/
public static String getMotherboardSN() {
String result = "";
try {
File file = File.createTempFile("realhowto", ".vbs");
file.deleteOnExit();
FileWriter fw = new java.io.FileWriter(file);
String vbs = "Set objWMIService = GetObject(\"winmgmts:\\\\.\\root\\cimv2\")\n"
+ "Set colItems = objWMIService.ExecQuery _ \n"
+ " (\"Select * from Win32_BaseBoard\") \n"
+ "For Each objItem in colItems \n"
+ " Wscript.Echo objItem.SerialNumber \n"
+ " exit for ' do the first cpu only! \n" + "Next \n";
fw.write(vbs);
fw.close();
Process p = Runtime.getRuntime().exec(
"cscript //NoLogo " + file.getPath());
BufferedReader input = new BufferedReader(new InputStreamReader(
p.getInputStream()));
String line;
while ((line = input.readLine()) != null) {
result += line;
}
input.close();
} catch (Exception e) {
e.printStackTrace();
}
return result.trim();
}
/**
* 获取硬盘序列号
*
* @param drive
* 盘符
* @return
*/
public static String getHardDiskSN(String drive) {
String result = "";
try {
File file = File.createTempFile("realhowto", ".vbs");
file.deleteOnExit();
FileWriter fw = new java.io.FileWriter(file);
String vbs = "Set objFSO = CreateObject(\"Scripting.FileSystemObject\")\n"
+ "Set colDrives = objFSO.Drives\n"
+ "Set objDrive = colDrives.item(\""
+ drive
+ "\")\n"
+ "Wscript.Echo objDrive.SerialNumber"; // see note
fw.write(vbs);
fw.close();
Process p = Runtime.getRuntime().exec(
"cscript //NoLogo " + file.getPath());
BufferedReader input = new BufferedReader(new InputStreamReader(
p.getInputStream()));
String line;
while ((line = input.readLine()) != null) {
result += line;
}
input.close();
} catch (Exception e) {
e.printStackTrace();
}
return result.trim();
}
/**
* 获取CPU序列号
*
* @return
*/
public static String getCPUSerial() {
String result = "";
try {
File file = File.createTempFile("tmp", ".vbs");
file.deleteOnExit();
FileWriter fw = new java.io.FileWriter(file);
String vbs = "Set objWMIService = GetObject(\"winmgmts:\\\\.\\root\\cimv2\")\n"
+ "Set colItems = objWMIService.ExecQuery _ \n"
+ " (\"Select * from Win32_Processor\") \n"
+ "For Each objItem in colItems \n"
+ " Wscript.Echo objItem.ProcessorId \n"
+ " exit for ' do the first cpu only! \n" + "Next \n";
// + " exit for \r\n" + "Next";
fw.write(vbs);
fw.close();
Process p = Runtime.getRuntime().exec(
"cscript //NoLogo " + file.getPath());
BufferedReader input = new BufferedReader(new InputStreamReader(
p.getInputStream()));
String line;
while ((line = input.readLine()) != null) {
result += line;
}
input.close();
file.delete();
} catch (Exception e) {
e.fillInStackTrace();
}
if (result.trim().length() < 1 || result == null) {
result = "无CPU_ID被读取";
}
return result.trim();
}
/**
* 获取MAC地址,使用前请修改，只适合中文系统，并且名称为以太网适配器的网卡地址
*/
@Deprecated
public static String getMac() {
String result = "";
try {
Process process = Runtime.getRuntime().exec("ipconfig /all");
InputStreamReader ir = new InputStreamReader(process.getInputStream(),"GBK");
LineNumberReader input = new LineNumberReader(ir);
String line;
while ((line = input.readLine()) != null){
if(line.indexOf("以太网适配器")!=-1){
while ((line = input.readLine()) != null){
if (line.indexOf("Physical Address") >=0||line.indexOf("物理地址")>=0) {
String MACAddr = line.substring(line.indexOf("-") - 2);
result = MACAddr;
break;
}
}
break;
}
}
} catch (java.io.IOException e) {
System.err.println("IOException " + e.getMessage());
}
return result;
}
public static void main(String[] args) {
System.out.println("CPU序列号:"+getCPUSerial());
}
}
-
获取ip及用户名
package com.github.wxiaoqi.demo;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* 获取IP地址和机器名
*/
public class GetIPAddress {
/**
* 获取本机的IP地址
* @return
* @throws UnknownHostException
*/
public static String getLocalIP() throws UnknownHostException {
InetAddress addr = InetAddress.getLocalHost();
return addr.getHostAddress();
}
/**
* 获取本机的机器名
* @return
* @throws UnknownHostException
*/
public static String getLocalHostName() throws UnknownHostException {
InetAddress addr = InetAddress.getLocalHost();
return addr.getHostName();
}
/**
* 根据域名获得主机的IP地址
* @param hostName 域名
* @return
* @throws UnknownHostException
*/
public static String getIPByName(String hostName)
throws UnknownHostException {
InetAddress addr = InetAddress.getByName(hostName);
return addr.getHostAddress();
}
/**
* 根据域名获得主机所有的IP地址
* @param hostName 域名
* @return
* @throws UnknownHostException
*/
public static String[] getAllIPByName(String hostName)
throws UnknownHostException {
InetAddress[] addrs = InetAddress.getAllByName(hostName);
String[] ips = new String[addrs.length];
for (int i = 0; i < addrs.length; i++) {
ips[i] = addrs[i].getHostAddress();
}
return ips;
}
public static void main(String[] args) throws UnknownHostException {
// 获取本机的IP地址和机器名
System.out.println("Local IP: " + GetIPAddress.getLocalIP());
System.out.println("Local HostName: " + GetIPAddress.getLocalHostName());
}
}
封装信息的工具类
-
国家名与代码
package com.hz.tgb.common;
import com.hz.tgb.common.pojo.CountryInfo;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/** 国家名称与代码
* Created by hezhao on 2018/7/3 11:22.
*/
public class CountryUtil {
/** 所有的国家信息列表 */
public static final List<CountryInfo> COUNTRY_INFO_LIST = new ArrayList<>(233);
/** 电话区号与国家信息键值对 */
public static final Map<String, CountryInfo> COUNTRY_PHONE_CODE_MAP = new HashMap<>();
/** 电话区号(带+号)与国家信息键值对 */
public static final Map<String, CountryInfo> COUNTRY_PHONE_CODE_PLUS_MAP = new HashMap<>();
/** 英文名称与国家信息键值对 */
public static final Map<String, CountryInfo> COUNTRY_ENGLISH_NAME_MAP = new HashMap<>();
/** 中文名称与国家信息键值对 */
public static final Map<String, CountryInfo> COUNTRY_CHINESE_NAME_MAP = new HashMap<>();
/** 国际域名缩写与国家信息键值对 */
public static final Map<String, CountryInfo> COUNTRY_SHORT_NAME_MAP = new HashMap<>();
static {
initialCountryInfoList();
initialCountryMap();
}
/**
* 初始化所有国家信息
*/
private static void initialCountryInfoList() {
COUNTRY_INFO_LIST.add(new CountryInfo("Angola", "安哥拉", "AO", "244", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Afghanistan", "阿富汗", "AF", "93", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Albania", "阿尔巴尼亚", "AL", "355", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Algeria", "阿尔及利亚", "DZ", "213", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Andorra", "安道尔共和国", "AD", "376", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Anguilla", "安圭拉岛", "AI", "1264", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Antigua and Barbuda", "安提瓜和巴布达", "AG", "1268", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Argentina", "阿根廷", "AR", "54", "-11"));
COUNTRY_INFO_LIST.add(new CountryInfo("Armenia", "亚美尼亚", "AM", "374", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Ascension", "阿森松", "", "247", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Australia ", "澳大利亚", "AU", "61", "+2"));
COUNTRY_INFO_LIST.add(new CountryInfo("Austria", "奥地利", "AT", "43", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Azerbaijan", "阿塞拜疆", "AZ", "994", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Bahamas", "巴哈马", "BS", "1242", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Bahrain", "巴林", "BH", "973", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Bangladesh", "孟加拉国", "BD", "880", "-2"));
COUNTRY_INFO_LIST.add(new CountryInfo("Barbados", "巴巴多斯", "BB", "1246", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Belarus", "白俄罗斯", "BY", "375", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Belgium", "比利时", "BE", "32", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Belize", "伯利兹", "BZ", "501", "-14"));
COUNTRY_INFO_LIST.add(new CountryInfo("Benin", "贝宁", "BJ", "229", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Bermuda Is.", "百慕大群岛", "BM", "1441", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Bolivia", "玻利维亚", "BO", "591", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Botswana", "博茨瓦纳", "BW", "267", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Brazil", "巴西", "BR", "55", "-11"));
COUNTRY_INFO_LIST.add(new CountryInfo("Brunei", "文莱", "BN", "673", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Bulgaria", "保加利亚", "BG", "359", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Burkina-faso", "布基纳法索", "BF", "226", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Burma", "缅甸", "MM", "95", "-1.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Burundi", "布隆迪", "BI", "257", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Cameroon", "喀麦隆", "CM", "237", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Canada", "加拿大", "CA", "1", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Cayman Is.", "开曼群岛", "", "1345", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Central African Republic", "中非共和国", "CF", "236", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Chad", "乍得", "TD", "235", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Chile", "智利", "CL", "56", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("China", "中国", "CN", "86", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Colombia", "哥伦比亚", "CO", "57", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Congo", "刚果", "CG", "242", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Cook Is.", "库克群岛", "CK", "682", "-18.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Costa Rica", "哥斯达黎加", "CR", "506", "-14"));
COUNTRY_INFO_LIST.add(new CountryInfo("Cuba", "古巴", "CU", "53", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Cyprus", "塞浦路斯", "CY", "357", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Czech Republic", "捷克", "CZ", "420", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Denmark", "丹麦", "DK", "45", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Djibouti", "吉布提", "DJ", "253", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Dominica Rep.", "多米尼加共和国", "DO", "1890", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Ecuador", "厄瓜多尔", "EC", "593", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Egypt", "埃及", "EG", "20", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("EI Salvador", "萨尔瓦多", "SV", "503", "-14"));
COUNTRY_INFO_LIST.add(new CountryInfo("Estonia", "爱沙尼亚", "EE", "372", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Ethiopia", "埃塞俄比亚", "ET", "251", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Fiji", "斐济", "FJ", "679", "+4"));
COUNTRY_INFO_LIST.add(new CountryInfo("Finland", "芬兰", "FI", "358", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("France", "法国", "FR", "33", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("French Guiana", "法属圭亚那", "GF", "594", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Gabon", "加蓬", "GA", "241", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Gambia", "冈比亚", "GM", "220", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Georgia", "格鲁吉亚", "GE", "995", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Germany", "德国", "DE", "49", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Ghana", "加纳", "GH", "233", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Gibraltar", "直布罗陀", "GI", "350", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Greece", "希腊", "GR", "30", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Grenada", "格林纳达", "GD", "1809", "-14"));
COUNTRY_INFO_LIST.add(new CountryInfo("Guam", "关岛", "GU", "1671", "+2"));
COUNTRY_INFO_LIST.add(new CountryInfo("Guatemala", "危地马拉", "GT", "502", "-14"));
COUNTRY_INFO_LIST.add(new CountryInfo("Guinea", "几内亚", "GN", "224", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Guyana", "圭亚那", "GY", "592", "-11"));
COUNTRY_INFO_LIST.add(new CountryInfo("Haiti", "海地", "HT", "509", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Honduras", "洪都拉斯", "HN", "504", "-14"));
COUNTRY_INFO_LIST.add(new CountryInfo("Hongkong", "香港", "HK", "852", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Hungary", "匈牙利", "HU", "36", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Iceland", "冰岛", "IS", "354", "-9"));
COUNTRY_INFO_LIST.add(new CountryInfo("India", "印度", "IN", "91", "-2.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Indonesia", "印度尼西亚", "ID", "62", "-0.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Iran", "伊朗", "IR", "98", "-4.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Iraq", "伊拉克", "IQ", "96", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Ireland", "爱尔兰", "IE", "353", "-4.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Israel", "以色列", "IL", "972", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Italy", "意大利", "IT", "39", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Ivory Coast", "科特迪瓦", "", "225", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Jamaica", "牙买加", "JM", "1876", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Japan", "日本", "JP", "81", "+1"));
COUNTRY_INFO_LIST.add(new CountryInfo("Jordan", "约旦", "JO", "962", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Kampuchea (Cambodia )", "柬埔寨", "KH", "855", "-1"));
COUNTRY_INFO_LIST.add(new CountryInfo("Kazakstan", "哈萨克斯坦", "KZ", "327", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Kenya", "肯尼亚", "KE", "254", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Korea", "韩国", "KR", "82", "+1"));
COUNTRY_INFO_LIST.add(new CountryInfo("Kuwait", "科威特", "KW", "965", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Kyrgyzstan", "吉尔吉斯坦", "KG", "331", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Laos", "老挝", "LA", "856", "-1"));
COUNTRY_INFO_LIST.add(new CountryInfo("Latvia", "拉脱维亚", "LV", "371", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Lebanon", "黎巴嫩", "LB", "961", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Lesotho", "莱索托", "LS", "266", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Liberia", "利比里亚", "LR", "231", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Libya", "利比亚", "LY", "218", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Liechtenstein", "列支敦士登", "LI", "423", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Lithuania", "立陶宛", "LT", "370", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Luxembourg", "卢森堡", "LU", "352", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Macao", "澳门", "MO", "853", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Madagascar", "马达加斯加", "MG", "261", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Malawi", "马拉维", "MW", "265", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Malaysia", "马来西亚", "MY", "60", "-0.5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Maldives", "马尔代夫", "MV", "960", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Mali", "马里", "ML", "223", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Malta", "马耳他", "MT", "356", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Mariana Is", "马里亚那群岛", "", "1670", "+1"));
COUNTRY_INFO_LIST.add(new CountryInfo("Martinique", "马提尼克", "", "596", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Mauritius", "毛里求斯", "MU", "230", "-4"));
COUNTRY_INFO_LIST.add(new CountryInfo("Mexico", "墨西哥", "MX", "52", "-15"));
COUNTRY_INFO_LIST.add(new CountryInfo("Moldova Republic of", "摩尔多瓦", "MD", "373", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Monaco", "摩纳哥", "MC", "377", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Mongolia", "蒙古", "MN", "976", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Montserrat Is", "蒙特塞拉特岛", "MS", "1664", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Morocco", "摩洛哥", "MA", "212", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Mozambique", "莫桑比克", "MZ", "258", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Namibia", "纳米比亚", "NA", "264", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Nauru", "瑙鲁", "NR", "674", "+4"));
COUNTRY_INFO_LIST.add(new CountryInfo("Nepal", "尼泊尔", "NP", "977", "-2.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Netheriands Antilles", "荷属安的列斯", "599", "", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Netherlands", "荷兰", "NL", "31", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("New Zealand", "新西兰", "NZ", "64", "+4"));
COUNTRY_INFO_LIST.add(new CountryInfo("Nicaragua", "尼加拉瓜", "NI", "505", "-14"));
COUNTRY_INFO_LIST.add(new CountryInfo("Niger", "尼日尔", "NE", "227", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Nigeria", "尼日利亚", "NG", "234", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("North Korea", "朝鲜", "KP", "850", "+1"));
COUNTRY_INFO_LIST.add(new CountryInfo("Norway", "挪威", "NO", "47", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Oman", "阿曼", "OM", "968", "-4"));
COUNTRY_INFO_LIST.add(new CountryInfo("Pakistan", "巴基斯坦", "PK", "92", "-2.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Panama", "巴拿马", "PA", "507", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Papua New Cuinea", "巴布亚新几内亚", "PG", "675", "+2"));
COUNTRY_INFO_LIST.add(new CountryInfo("Paraguay", "巴拉圭", "PY", "595", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Peru", "秘鲁", "PE", "51", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Philippines", "菲律宾", "PH", "63", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Poland", "波兰", "PL", "48", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("French Polynesia", "法属玻利尼西亚", "PF", "689", "+3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Portugal", "葡萄牙", "PT", "351", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Puerto Rico", "波多黎各", "PR", "1787", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Qatar", "卡塔尔", "QA", "974", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Reunion", "留尼旺", "", "262", "-4"));
COUNTRY_INFO_LIST.add(new CountryInfo("Romania", "罗马尼亚", "RO", "40", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Russia", "俄罗斯", "RU", "7", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Saint Lueia", "圣卢西亚", "LC", "1758", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Saint Vincent", "圣文森特岛", "VC", "1784", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Samoa Eastern", "东萨摩亚(美)", "", "684", "-19"));
COUNTRY_INFO_LIST.add(new CountryInfo("Samoa Western", "西萨摩亚", "", "685", "-19"));
COUNTRY_INFO_LIST.add(new CountryInfo("San Marino", "圣马力诺", "SM", "978", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Sao Tome and Principe", "圣多美和普林西比", "ST", "239", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Saudi Arabia", "沙特阿拉伯", "SA", "966", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Senegal", "塞内加尔", "SN", "221", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Seychelles", "塞舌尔", "SC", "248", "-4"));
COUNTRY_INFO_LIST.add(new CountryInfo("Sierra Leone", "塞拉利昂", "SL", "232", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Singapore", "新加坡", "SG", "65", "+0.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Slovakia", "斯洛伐克", "SK", "421", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Slovenia", "斯洛文尼亚", "SI", "386", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Solomon Is", "所罗门群岛", "SB", "677", "+3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Somali", "索马里", "SO", "252", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("South Africa", "南非", "ZA", "27", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Spain", "西班牙", "ES", "34", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Sri Lanka", "斯里兰卡", "LK", "94", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Sudan", "苏丹", "SD", "249", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Suriname", "苏里南", "SR", "597", "-11.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Swaziland", "斯威士兰", "SZ", "268", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Sweden", "瑞典", "SE", "46", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Switzerland", "瑞士", "CH", "41", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Syria", "叙利亚", "SY", "963", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Taiwan", "台湾", "TW", "886", "0"));
COUNTRY_INFO_LIST.add(new CountryInfo("Tajikstan", "塔吉克斯坦", "TJ", "992", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Tanzania", "坦桑尼亚", "TZ", "255", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Thailand", "泰国", "TH", "66", "-1"));
COUNTRY_INFO_LIST.add(new CountryInfo("Togo", "多哥", "TG", "228", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("Tonga", "汤加", "TO", "676", "+4"));
COUNTRY_INFO_LIST.add(new CountryInfo("Trinidad and Tobago", "特立尼达和多巴哥", "TT", "1809", "-12"));
COUNTRY_INFO_LIST.add(new CountryInfo("Tunisia", "突尼斯", "TN", "216", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Turkey", "土耳其", "TR", "90", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Turkmenistan", "土库曼斯坦", "TM", "993", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Uganda", "乌干达", "UG", "256", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Ukraine", "乌克兰", "UA", "380", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("United Arab Emirates", "阿拉伯联合酋长国", "AE", "971", "-4"));
COUNTRY_INFO_LIST.add(new CountryInfo("United Kiongdom", "英国", "UK", "44", "-8"));
COUNTRY_INFO_LIST.add(new CountryInfo("United States of America", "美国", "US", "1", "-13"));
COUNTRY_INFO_LIST.add(new CountryInfo("Uruguay", "乌拉圭", "UY", "598", "-10.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Uzbekistan", "乌兹别克斯坦", "UZ", "233", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Venezuela", "委内瑞拉", "VE", "58", "-12.3"));
COUNTRY_INFO_LIST.add(new CountryInfo("Vietnam", "越南", "VN", "84", "-1"));
COUNTRY_INFO_LIST.add(new CountryInfo("Yemen", "也门", "YE", "967", "-5"));
COUNTRY_INFO_LIST.add(new CountryInfo("Yugoslavia", "南斯拉夫", "YU", "381", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Zimbabwe", "津巴布韦", "ZW", "263", "-6"));
COUNTRY_INFO_LIST.add(new CountryInfo("Zaire", "扎伊尔", "ZR", "243", "-7"));
COUNTRY_INFO_LIST.add(new CountryInfo("Zambia", "赞比亚", "ZM", "260", "-6"));
}
/**
* 初始化国家信息键值对
*/
private static void initialCountryMap() {
for (CountryInfo countryInfo : COUNTRY_INFO_LIST) {
COUNTRY_PHONE_CODE_MAP.put(countryInfo.getPhoneCode(), countryInfo);
COUNTRY_PHONE_CODE_PLUS_MAP.put("+" + countryInfo.getPhoneCode(), countryInfo);
COUNTRY_ENGLISH_NAME_MAP.put(countryInfo.getEnglishName(), countryInfo);
COUNTRY_CHINESE_NAME_MAP.put(countryInfo.getChineseName(), countryInfo);
COUNTRY_SHORT_NAME_MAP.put(countryInfo.getShortName(), countryInfo);
}
}
public static void main(String[] args) {
// 根据电话区号查询国家信息
CountryInfo countryInfo = CountryUtil.COUNTRY_PHONE_CODE_PLUS_MAP.get("+86");
System.out.println(countryInfo);
// 根据缩写查询国家信息
CountryInfo countryInfo2 = CountryUtil.COUNTRY_SHORT_NAME_MAP.get("JP");
System.out.println(countryInfo2);
}
}
// 附录：国家代号(CountryCode)与区号
// 拷贝自：https://www.cnblogs.com/catvi/archive/2009/01/06/1952961.html
/*
Countries and Regions 国家或地区 国际域名缩写 电话代码 时差
===================================================================
Angola 安哥拉 AO 244 -7
Afghanistan 阿富汗 AF 93 0
Albania 阿尔巴尼亚 AL 355 -7
Algeria 阿尔及利亚 DZ 213 -8
Andorra 安道尔共和国 AD 376 -8
Anguilla 安圭拉岛 AI 1264 -12
Antigua and Barbuda 安提瓜和巴布达 AG 1268 -12
Argentina 阿根廷 AR 54 -11
Armenia 亚美尼亚 AM 374 -6
Ascension 阿森松 247 -8
Australia 澳大利亚 AU 61 +2
Austria 奥地利 AT 43 -7
Azerbaijan 阿塞拜疆 AZ 994 -5
Bahamas 巴哈马 BS 1242 -13
Bahrain 巴林 BH 973 -5
Bangladesh 孟加拉国 BD 880 -2
Barbados 巴巴多斯 BB 1246 -12
Belarus 白俄罗斯 BY 375 -6
Belgium 比利时 BE 32 -7
Belize 伯利兹 BZ 501 -14
Benin 贝宁 BJ 229 -7
Bermuda Is. 百慕大群岛 BM 1441 -12
Bolivia 玻利维亚 BO 591 -12
Botswana 博茨瓦纳 BW 267 -6
Brazil 巴西 BR 55 -11
Brunei 文莱 BN 673 0
Bulgaria 保加利亚 BG 359 -6
Burkina-faso 布基纳法索 BF 226 -8
Burma 缅甸 MM 95 -1.3
Burundi 布隆迪 BI 257 -6
Cameroon 喀麦隆 CM 237 -7
Canada 加拿大 CA 1 -13
Cayman Is. 开曼群岛 1345 -13
Central African Republic 中非共和国 CF 236 -7
Chad 乍得 TD 235 -7
Chile 智利 CL 56 -13
China 中国 CN 86 0
Colombia 哥伦比亚 CO 57 0
Congo 刚果 CG 242 -7
Cook Is. 库克群岛 CK 682 -18.3
Costa Rica 哥斯达黎加 CR 506 -14
Cuba 古巴 CU 53 -13
Cyprus 塞浦路斯 CY 357 -6
Czech Republic 捷克 CZ 420 -7
Denmark 丹麦 DK 45 -7
Djibouti 吉布提 DJ 253 -5
Dominica Rep. 多米尼加共和国 DO 1890 -13
Ecuador 厄瓜多尔 EC 593 -13
Egypt 埃及 EG 20 -6
EI Salvador 萨尔瓦多 SV 503 -14
Estonia 爱沙尼亚 EE 372 -5
Ethiopia 埃塞俄比亚 ET 251 -5
Fiji 斐济 FJ 679 +4
Finland 芬兰 FI 358 -6
France 法国 FR 33 -8
French Guiana 法属圭亚那 GF 594 -12
Gabon 加蓬 GA 241 -7
Gambia 冈比亚 GM 220 -8
Georgia 格鲁吉亚 GE 995 0
Germany 德国 DE 49 -7
Ghana 加纳 GH 233 -8
Gibraltar 直布罗陀 GI 350 -8
Greece 希腊 GR 30 -6
Grenada 格林纳达 GD 1809 -14
Guam 关岛 GU 1671 +2
Guatemala 危地马拉 GT 502 -14
Guinea 几内亚 GN 224 -8
Guyana 圭亚那 GY 592 -11
Haiti 海地 HT 509 -13
Honduras 洪都拉斯 HN 504 -14
Hongkong 香港 HK 852 0
Hungary 匈牙利 HU 36 -7
Iceland 冰岛 IS 354 -9
India 印度 IN 91 -2.3
Indonesia 印度尼西亚 ID 62 -0.3
Iran 伊朗 IR 98 -4.3
Iraq 伊拉克 IQ 964 -5
Ireland 爱尔兰 IE 353 -4.3
Israel 以色列 IL 972 -6
Italy 意大利 IT 39 -7
Ivory Coast 科特迪瓦 225 -6
Jamaica 牙买加 JM 1876 -12
Japan 日本 JP 81 +1
Jordan 约旦 JO 962 -6
Kampuchea (Cambodia ) 柬埔寨 KH 855 -1
Kazakstan 哈萨克斯坦 KZ 327 -5
Kenya 肯尼亚 KE 254 -5
Korea 韩国 KR 82 +1
Kuwait 科威特 KW 965 -5
Kyrgyzstan 吉尔吉斯坦 KG 331 -5
Laos 老挝 LA 856 -1
Latvia 拉脱维亚 LV 371 -5
Lebanon 黎巴嫩 LB 961 -6
Lesotho 莱索托 LS 266 -6
Liberia 利比里亚 LR 231 -8
Libya 利比亚 LY 218 -6
Liechtenstein 列支敦士登 LI 423 -7
Lithuania 立陶宛 LT 370 -5
Luxembourg 卢森堡 LU 352 -7
Macao 澳门 MO 853 0
Madagascar 马达加斯加 MG 261 -5
Malawi 马拉维 MW 265 -6
Malaysia 马来西亚 MY 60 -0.5
Maldives 马尔代夫 MV 960 -7
Mali 马里 ML 223 -8
Malta 马耳他 MT 356 -7
Mariana Is 马里亚那群岛 1670 +1
Martinique 马提尼克 596 -12
Mauritius 毛里求斯 MU 230 -4
Mexico 墨西哥 MX 52 -15
Moldova Republic of 摩尔多瓦 MD 373 -5
Monaco 摩纳哥 MC 377 -7
Mongolia 蒙古 MN 976 0
Montserrat Is 蒙特塞拉特岛 MS 1664 -12
Morocco 摩洛哥 MA 212 -6
Mozambique 莫桑比克 MZ 258 -6
Namibia 纳米比亚 NA 264 -7
Nauru 瑙鲁 NR 674 +4
Nepal 尼泊尔 NP 977 -2.3
Netheriands Antilles 荷属安的列斯 599 -12
Netherlands 荷兰 NL 31 -7
New Zealand 新西兰 NZ 64 +4
Nicaragua 尼加拉瓜 NI 505 -14
Niger 尼日尔 NE 227 -8
Nigeria 尼日利亚 NG 234 -7
North Korea 朝鲜 KP 850 +1
Norway 挪威 NO 47 -7
Oman 阿曼 OM 968 -4
Pakistan 巴基斯坦 PK 92 -2.3
Panama 巴拿马 PA 507 -13
Papua New Cuinea 巴布亚新几内亚 PG 675 +2
Paraguay 巴拉圭 PY 595 -12
Peru 秘鲁 PE 51 -13
Philippines 菲律宾 PH 63 0
Poland 波兰 PL 48 -7
French Polynesia 法属玻利尼西亚 PF 689 +3
Portugal 葡萄牙 PT 351 -8
Puerto Rico 波多黎各 PR 1787 -12
Qatar 卡塔尔 QA 974 -5
Reunion 留尼旺 262 -4
Romania 罗马尼亚 RO 40 -6
Russia 俄罗斯 RU 7 -5
Saint Lueia 圣卢西亚 LC 1758 -12
Saint Vincent 圣文森特岛 VC 1784 -12
Samoa Eastern 东萨摩亚(美) 684 -19
Samoa Western 西萨摩亚 685 -19
San Marino 圣马力诺 SM 378 -7
Sao Tome and Principe 圣多美和普林西比 ST 239 -8
Saudi Arabia 沙特阿拉伯 SA 966 -5
Senegal 塞内加尔 SN 221 -8
Seychelles 塞舌尔 SC 248 -4
Sierra Leone 塞拉利昂 SL 232 -8
Singapore 新加坡 SG 65 +0.3
Slovakia 斯洛伐克 SK 421 -7
Slovenia 斯洛文尼亚 SI 386 -7
Solomon Is 所罗门群岛 SB 677 +3
Somali 索马里 SO 252 -5
South Africa 南非 ZA 27 -6
Spain 西班牙 ES 34 -8
Sri Lanka 斯里兰卡 LK 94 0
Sudan 苏丹 SD 249 -6
Suriname 苏里南 SR 597 -11.3
Swaziland 斯威士兰 SZ 268 -6
Sweden 瑞典 SE 46 -7
Switzerland 瑞士 CH 41 -7
Syria 叙利亚 SY 963 -6
Taiwan 台湾 TW 886 0
Tajikstan 塔吉克斯坦 TJ 992 -5
Tanzania 坦桑尼亚 TZ 255 -5
Thailand 泰国 TH 66 -1
Togo 多哥 TG 228 -8
Tonga 汤加 TO 676 +4
Trinidad and Tobago 特立尼达和多巴哥 TT 1809 -12
Tunisia 突尼斯 TN 216 -7
Turkey 土耳其 TR 90 -6
Turkmenistan 土库曼斯坦 TM 993 -5
Uganda 乌干达 UG 256 -5
Ukraine 乌克兰 UA 380 -5
United Arab Emirates 阿拉伯联合酋长国 AE 971 -4
United Kiongdom 英国 UK 44 -8
United States of America 美国 US 1 -13
Uruguay 乌拉圭 UY 598 -10.3
Uzbekistan 乌兹别克斯坦 UZ 233 -5
Venezuela 委内瑞拉 VE 58 -12.3
Vietnam 越南 VN 84 -1
Yemen 也门 YE 967 -5
Yugoslavia 南斯拉夫 YU 381 -7
Zimbabwe 津巴布韦 ZW 263 -6
Zaire 扎伊尔 ZR 243 -7
Zambia 赞比亚 ZM 260 -6
*/