ip地址，子网掩码，日期转换相关工具方法

/**
*
*/
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.StringTokenizer;
import java.util.Vector;
import java.math.BigDecimal;


public class FormatUtil {
private static final SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

private static NumberFormat numFormat = NumberFormat.getNumberInstance();

private static NumberFormat percentFormat = NumberFormat.getPercentInstance();

private FormatUtil() {

}

/**
* 获取IP地址对应的主机域名，如果enalbelDNS为false，仅仅返回IP地址
* @param s IP地址
* @return 主机域名或IP地址
* @throws UnknownHostException
*/
public static String getDNSName(String s) throws UnknownHostException {
InetAddress addr = InetAddress.getByName(s);
String dns = addr.getHostName().trim();
return dns.toLowerCase();
}

/**
* 判断ipaddress是否属于私有地址
* @param ipaddress
* @return
*/
public static boolean isPrivateIP(String ipaddress) throws ParseException {
boolean flag = false;
flag = isAddressInRange(ipaddress, "10.0.0.0", "10.255.255.255");

if (!flag) {
flag = isAddressInRange(ipaddress, "172.16.0.0", "172.31.255.255");
}
if (!flag) {
flag = isAddressInRange(ipaddress, "192.168.0.0", "192.168.255.255");
}
if (!flag) {
flag = isAddressInRange(ipaddress, "127.0.0.0", "127.255.255.255");
}
return flag;
}

/**
* 校验是否为合法的IP地址
* @param ipAddr
* @return
*/
public static boolean isValidIPAddr(String ipAddr) {
try {
getAddrArray(ipAddr);
return true;
} catch (ParseException e) {
return false;
}
}

public static boolean isValidNetmask(String ipAddr) {
if (ipAddr == null) {
return false;
}

StringTokenizer stringtokenizer = new StringTokenizer(ipAddr, ".");
if (stringtokenizer.countTokens() != 4) {
return false;
}
int ai[] = new int[4];
try {
for (int i = 0; i < 4; i++) {
ai[i] = Integer.parseInt(stringtokenizer.nextToken());

}
} catch (NumberFormatException numberformatexception) {
return false;
}

boolean evenFlag;
if (ai[3] % 2 == 0) {
evenFlag = true;
} else {
evenFlag = false;
}
if (!evenFlag) {
// 应全是奇数
for (int j = 3; j >= 0; j--) {
// 将四个整数从上到下依次解析为二进制数，
if (ai[j] == 0) {
return false;
}

while (ai[j] > 0) {
if (ai[j] % 2 == 0) {
return false;
}
ai[j] = ai[j] >> 1;

}
}
} else {
// 遇到奇数后就全是奇数
for (int j = 3; j >= 0; j--) {
if (ai[j] % 2 == 0) {
if (!evenFlag) {
return false;
}
} else {
evenFlag = false;
}

while (ai[j] > 0) {
if (ai[j] % 2 == 0) {
if (!evenFlag) {
return false;
}
} else {
evenFlag = false;
}
ai[j] = ai[j] >> 1;
}
}
}

return true;

}

public static boolean isBroadcastAddr(String s) throws ParseException {
long l = getAddrLong(s);
long l1 = getAddrLong("0.0.0.255");
long l2 = l & l1;
return l2 == 255L;
}

/**
* 检查一个IP地址是否在一些IP地址段内
* @param s IP地址
* @param vector 最小IP地址组
* @param vector1 最大IP地址组
* @return 该IP地址是否在范围内
*/
public static boolean isAddressInRange(String s, Vector vector, Vector vector1) throws ParseException {
if (vector == null || vector1 == null) {
return true;
}
if (vector.size() != vector1.size()) {
// TODO 抛出异常，异常要国际化
return false;
}
long l = getAddrLong(s);
if (l == 0L) {
return false;
}
for (int i = 0; i < vector.size(); i++) {
long l1 = getAddrLong((String) vector.elementAt(i));
long l2 = getAddrLong((String) vector1.elementAt(i));
if (l <= l2 && l >= l1) {
return true;
}
}
return false;
}

/**
* 校验两个子网是否有交叉
* @param srcIpAddr
* @param srcNetmask
* @param destIpAddr
* @param destNetmask
* @return
*/
public static boolean isNetInterCross(String srcIpAddr, String srcNetmask, String destIpAddr, String destNetmask) {
boolean flag = false;
try {
if (FormatUtil.inNet(srcIpAddr, destIpAddr, destNetmask)) {
flag = true;
} else {
String srcEndIpAddr = FormatUtil.getNetEndIP(srcIpAddr, srcNetmask);
if (FormatUtil.inNet(srcEndIpAddr, destIpAddr, destNetmask)) {
flag = true;
} else {
if (FormatUtil.inNet(destIpAddr, srcIpAddr, srcNetmask)) {
flag = true;
} else {
String destEndIpAddr = FormatUtil.getNetEndIP(destIpAddr, destNetmask);
if (FormatUtil.inNet(destEndIpAddr, srcIpAddr, srcNetmask)) {
flag = true;
}
}

}
}

} catch (Exception e) {
e.printStackTrace();
}
return flag;
}

/**
* 检查一个IP地址是否在一些IP地址段内
* @param s IP地址
* @param vector 最小IP地址组
* @param vector1 最大IP地址组
* @return 该IP地址是否在范围内
*/
public static boolean isAddressInRange(String ip, String startIP, String endIP) throws ParseException {
if (ip == null || (startIP == null && endIP == null)) {
return true;
}
long l = getAddrLong(ip);
if (l == 0L) {
return false;
}
boolean flag = true;
if (startIP != null) {
long l1 = getAddrLong(startIP);
if (l < l1) {
flag = false;
}
}
if (endIP != null) {
long l2 = getAddrLong(endIP);
if (l > l2) {
flag = false;
}
}
return flag;
}

/**
* 检查一个IP地址是否在一个子网范围内
* @param s IP地址
* @param s1 子网地址
* @param s2 子网掩码
* @return IP地址是否在一个子网内
*/
public static boolean inNet(String s, String s1, String s2) throws ParseException {
if (s2.equals("255.255.255.255")) {
if (s.equals(s1)) {
return true;
}
return false;
}
long l = getAddrLong("255.255.255.255");
long l1 = getAddrLong(s2);
long l2 = getAddrLong(s1);
l2 &= l1;
long l3 = l ^ l1;
long l4 = getAddrLong(s);
if (l4 == 0L) {
return false;
}
return l4 < l2 + l3 && l4 >= l2;
}

/**
* 获取给定子网掩码的子网所包括的IP地址个数
* @param s 以字符串表示网络地址
* @param s1 以字符串表示的子网掩码
* @return 子网所包括的IP地址个数，用long值表示
*/
public static long getNumIPs(String s, String s1) throws ParseException {
long l = getAddrLong("255.255.255.255");
long l1 = getAddrLong(s1);
if (l1 == l) {
return 0L;
}
long l2 = getAddrLong(s);
long l3 = l ^ l1;
if (l1 == 0L || l2 == 0L || l1 > l || l3 > l) {
throw new ParseException("ErrorIPFormat" + s + " " + s1, -1);
}
return l3;
}

public static String getNetworkNetMask(String network, String netmask) throws ParseException {
if (network == null || netmask == null) {
throw new ParseException("ErrorIPFormat" + network + " " + netmask,-1);
}
long l = getAddrLong("255.255.255.255");
long l1 = getAddrLong(netmask);
long l3 = l ^ l1;
int num = 0;
while (l3 > 0) {
num++;
l3 = l3 >> 1;
}
return network + "/" + (32 - num);
}

public static String[] parseNetworkNetMask(String networkNetmask) throws ParseException {

if (networkNetmask == null) {
throw new ParseException("ErrorIPFormat" + networkNetmask, -1);
}
int index = networkNetmask.indexOf("/");
if (index == -1) {
return null;
}
String netip = networkNetmask.substring(0, index);
int num = 0;
try {
num = Integer.parseInt(networkNetmask.substring(index + 1));
if (num > 32) {
return null;
}
} catch (Exception ee) {
return null;
}
long l = 1;

int count = num;
while (count > 1) {
count--;
l = (l << 1) + 1;
}
count = 32 - num;
while (count > 0) {
count--;
l = l << 1;
}
String[] network = new String[2];
network[0] = netip;
network[1] = getAddrString(l);
return network;
}

public static String getNetMask(String startip, String endip) throws ParseException {
if (startip == null || endip == null) {
throw new ParseException("ErrorIPFormat" + startip + " " + endip, -1);
}
long l = getAddrLong(startip);
long l1 = getAddrLong(endip);
long l2 = ~(l1 ^ l);
return getAddrString(l2);
}

/**
* @param startip
* @param netmask
* @return
*/
public static String getNetEndIP(String startip, String p_netmask) throws ParseException {
String netmask = p_netmask;
if (startip != null && netmask != null) {
if (startip.equals(netmask)) {
netmask = "255.255.255.0";
}
if (netmask.equals("0.0.0.0")) {
netmask = "255.255.255.0";
}
}
long l = getAddrLong(startip);
long l1 = getAddrLong(netmask);
long l2 = ~l1 | l;
return getAddrString(l2);
}

/**
* 从一个给定IP（可能是节点地址）和子网掩码，获取子网地址
* @param s IP地址
* @param s1 子网掩码
* @return 子网地址
*/
public static String getNetAddr(String s, String p_s1) throws ParseException {
String s1 = p_s1;
if (s != null && s1 != null) {
if (s.equals(s1)) {
s1 = "255.255.255.0";
}
if (s1.equals("0.0.0.0")) {
s1 = "255.255.255.0";
}
}
long l = getAddrLong(s1);
long l1 = getAddrLong(s);
long l2 = l1 & l;
return getAddrString(l2);
}

/**
* 获取一个IP数组内最小或最大IP地址
* @param vector IP地址数组
* @param flag 是否是最大IP地址
* @return 最大或最小IP地址
*/
public static String getMinMaxAddr(Vector vector, boolean flag) throws ParseException {
String s = (String) vector.firstElement();
long l = getAddrLong(s);
for (int i = 1; i < vector.size(); i++) {
String s1 = (String) vector.elementAt(i);
long l1 = getAddrLong(s1);
if (!flag) {
if (l1 < l) {
s = s1;
l = l1;
}
} else if (l1 > l) {
s = s1;
l = l1;
}
}
return s;
}

/**
* 获取一个子网内的所有IP地址
* @param ip 网络地址
* @param mask 网络掩码
* @return IP地址字符数组
*/
public static String[] getIPList(String ip, String mask) throws ParseException {
String as[] = null;
long l = getAddrLong("255.255.255.255");
long l1 = getAddrLong(mask);
if (l1 == l) {
as = new String[1];
as[0] = ip;
return as;
}
long l2 = getAddrLong(ip);
long l3 = l ^ l1;
if (l1 == 0L || l2 == 0L || l1 > l || l3 > l) {
throw new ParseException("ErrorIPFormat" + ip + " " + mask, -1);
}
if (l3 > 0x10000L) {
throw new ParseException("ErrorIPFormat" + ip + " " + mask, -1);
}
if (l3 == 2L) {
as = new String[1];
as[0] = getAddrString(l2 + 1L);
return as;
}
if ((l2 + l3) - 1L > l) {
throw new ParseException(I18nUtil.getInstance().getValue("ErrorIPFormat") + ip + " " + mask, -1);
}
as = new String[(int) l3 - 1];
for (int i = 0; i < l3 - 1; i++) {
as[i] = getAddrString(l2 + 1L + i);
}
return as;
}

/**
* 获取主机域名对应的IP地址
* @param s 主机域名
* @return 主机域名对应的IP地址，如果找不到相应的IP地址，返回主机域名
*/
public static String getIP(String s) throws UnknownHostException {
InetAddress addr = InetAddress.getByName(s);
String ip = addr.getHostAddress().trim();
return ip;
}

/**
* 基于给定的网络地址，得到特定网络的缺省子网掩码。 这个方法基于对A、B、C类网络的猜测，返回相应的子网掩码。
* @param s - 字符串表示的网络地址.
* @return 缺省的网络掩码
* @throws ParseException
*/
public static String getDefaultNetMask(String s) throws ParseException {
int ai[] = getAddrArray(s);
if (ai[0] < 128) {// A类地址
return "255.0.0.0";
}
if (ai[0] < 192) { // B类地址
return "255.255.0.0";
}
// C、D、E类地址
return "255.255.255.0";
}

/**
* 将IP地址转换为long型值，这个方法检查输入的有效性
* @param s IP地址
* @return IP地址对应的long型值
* @throws ParseException
*/
public static long getAddrLong(String s) throws ParseException {
int ai[] = getAddrArray(s);
long l = 0L;
for (int i = 0; i < 4; i++) {
l |= (long) ai[i] << 8 * (3 - i);
}
return l;
}

/**
* 将点分十进制表示的IP地址转换为长度为4的数组
* @param s IP地址
* @return 长度为4的数组，存放点号分开的值
* @throws ParseException
*/
public static int[] getAddrArray(String p_s) throws ParseException {
String s = p_s;
if (s == null) {
throw new ParseException(I18nUtil.getInstance().getValue("ErrorIPFormat") + s, -1);
}
s = s.trim();
StringTokenizer stringtokenizer = new StringTokenizer(s, ".");
if (stringtokenizer.countTokens() != 4) {
throw new ParseException(I18nUtil.getInstance().getValue("ErrorIPFormat") + s, stringtokenizer
.countTokens());
}
int ai[] = new int[4];
for (int i = 0; i < 4; i++) {
try {
ai[i] = Integer.parseInt(stringtokenizer.nextToken());
} catch (NumberFormatException numberformatexception) {
throw new ParseException("ErrorIPFormat" + s, i);
}
}
for (int i = 0; i < 4; i++) {
if (ai[i] < 0 || ai[i] > 255) {
throw new ParseException("ErrorIPFormat" + s, i);
}
}
return ai;
}

/**
* 将一个long型值转换为一个IP地址串，这个方法并不检查输入的有效性。
* @param l long值数据
* @return IP地址
*/
public static String getAddrString(long l) {
int ai[] = new int[4];
for (int i = 0; i < 4; i++) {
ai[i] = (int) (l >> 8 * (3 - i) & 255L);
}
return new String(ai[0] + "." + ai[1] + "." + ai[2] + "." + ai[3]);
}

/**
* 获得一个yyyy-mm-dd hh:mm:ss格式的字符串的每个域的值
* @param dateTime yyyy-mm-dd hh:mm:ss格式的字符串
* @return 数组从0到5的六个元素分别是年，月，日，时，分，秒
*/
public static String[] parseDateTime(String dateTime) {
String[] result = new String[6];
StringTokenizer token = new StringTokenizer(dateTime, " ");
String date = token.nextToken();
String time = token.nextToken();

StringTokenizer dateToken = new StringTokenizer(date, "-");
result[0] = dateToken.nextToken();
result[1] = dateToken.nextToken();
result[2] = dateToken.nextToken();

StringTokenizer timeToken = new StringTokenizer(time, ":");
result[3] = timeToken.nextToken();
result[4] = timeToken.nextToken();
result[5] = timeToken.nextToken();

return result;
}

/**
* 获得一个hh:mm:ss格式的字符串的每个域的值
* @param time hh:mm:ss格式的字符串
* @return 数组从0到2的三个元素分别是时，分，秒
*/
public static String[] parseTime(String time) {
String[] result = new String[3];
StringTokenizer timeToken = new StringTokenizer(time, ":");
result[0] = timeToken.nextToken();
result[1] = timeToken.nextToken();
result[2] = timeToken.nextToken();
return result;
}

public static String to_Oracle_Date(String dateStr) {
return "to_date('" + dateStr + "','yyyy-mm-dd hh24:mi:ss')";
}

public static String to_Oracle_Char(String dateField) {
return "to_char(" + dateField + ",'yyyy-mm-dd hh24:mi:ss')";
}

/**
* 将日期类型格式化成 yyyy-mm-dd hh24:mi:ss 格式
* @param date
* @return
*/
public static String formatDate(Date date) {
return simpleDateFormat.format(date);
}

/**
* 将日期类型格式转换为yyyyMMddHHmmss的格式
* @param date
* @return
*/
public static String formatDateToNumber(Date date) {
if (date == null) {
return "";
}
SimpleDateFormat df = new java.text.SimpleDateFormat("yyyyMMddHHmmss");
return df.format(date);
}

/**
* 将Web端如：2007-2-8 12:12:12 转换long型(以便入库)
* @param str
* @return
*/
public static long formatDateToLong(String str) {
long flag = 0;
if (str != null && !str.equals("")) {
try {
flag = parseDate(str).getTime();
} catch (ParseException e) {
e.printStackTrace();
}
}
return flag;
}

/**
* 根据数据库中long型时间，转换为时间的String到Web端显示
* @param time
* @return
*/
public static String formatDateToString(long time) {
String flag = "";
if (time > 0) {
flag = formatDate(new Date(time));
}
return flag;
}

/**
* 从 yyyy-mm-dd hh24:mi:ss 格式的字符串中生成日期
* @param str
* @return
* @throws ParseException
*/
public static Date parseDate(String str) throws ParseException {
return simpleDateFormat.parse(str);
}

public static Number parseNumber(String str) throws ParseException {
return numFormat.parse(str);
}

/**
* 格式化Number
* @param value
* @param minDigit 小数点后最小位数
* @param maxDigit 小数点后最大位数
* @return
*/
public static String formatValue(Number number, int minDigit, int maxDigit) {
synchronized (numFormat) {
if (numFormat.getMaximumFractionDigits() != maxDigit) {
numFormat.setMaximumFractionDigits(maxDigit);
}
if (numFormat.getMinimumFractionDigits() != minDigit) {
numFormat.setMinimumFractionDigits(minDigit);
}
return numFormat.format(number);
}
}

public static Number parsePercent(String str) throws ParseException {
return percentFormat.parse(str);
}

/**
* 格式化百分数
* @param number
* @param minDigit
* @param maxDigit
* @return
*/
public static String formatPercent(Number number, int minDigit, int maxDigit) {
synchronized (percentFormat) {
if (percentFormat.getMaximumFractionDigits() != maxDigit) {
percentFormat.setMaximumFractionDigits(maxDigit);
}
if (percentFormat.getMinimumFractionDigits() != minDigit) {
percentFormat.setMinimumFractionDigits(minDigit);
}
return percentFormat.format(number);
}
}

/**
* 格式化百分数
* @param number
* @param minDigit
* @param maxDigit
* @return
*/
public static String formatPercent(double number, int minDigit, int maxDigit) {
synchronized (percentFormat) {
if (percentFormat.getMaximumFractionDigits() != maxDigit) {
percentFormat.setMaximumFractionDigits(maxDigit);
}
if (percentFormat.getMinimumFractionDigits() != minDigit) {
percentFormat.setMinimumFractionDigits(minDigit);
}
return percentFormat.format(number);
}
}

/**
* 格式化百分数
* @param number
* @param minDigit
* @param maxDigit
* @return
*/
public static String formatPercent(float number, int minDigit, int maxDigit) {
synchronized (percentFormat) {
if (percentFormat.getMaximumFractionDigits() != maxDigit) {
percentFormat.setMaximumFractionDigits(maxDigit);
}
if (percentFormat.getMinimumFractionDigits() != minDigit) {
percentFormat.setMinimumFractionDigits(minDigit);
}
return percentFormat.format(number);
}
}

/**
* 格式化float
* @param value
* @param minDigit 小数点后最小位数
* @param maxDigit 小数点后最大位数
* @return
*/
public static String formatValue(float value, int minDigit, int maxDigit) {
synchronized (numFormat) {
if (numFormat.getMaximumFractionDigits() != maxDigit) {
numFormat.setMaximumFractionDigits(maxDigit);
}
if (numFormat.getMinimumFractionDigits() != minDigit) {
numFormat.setMinimumFractionDigits(minDigit);
}
return numFormat.format(value);
}
}

/**
* 格式化double
* @param value
* @param minDigit 小数点后最小位数
* @param maxDigit 小数点后最大位数
* @return
*/
public static String formatValue(double value, int minDigit, int maxDigit) {
synchronized (numFormat) {
if (numFormat.getMaximumFractionDigits() != maxDigit) {
numFormat.setMaximumFractionDigits(maxDigit);
}
if (numFormat.getMinimumFractionDigits() != minDigit) {
numFormat.setMinimumFractionDigits(minDigit);
}
return numFormat.format(value);
}
}

/**
* 获取流量速度的字符串
* @param value
* @param minDigit
* @param maxDigit
* @return
*/
public static String getbpsString(double p_value, int minDigit, int maxDigit) {
double value = p_value;
if (value > 1000) {
value /= 1000;
if (value > 1000) {
value /= 1000;
if (value > 1000) {
value /= 1000;
return formatValue(value, minDigit, maxDigit) + "Gbps";
}
return formatValue(value, minDigit, maxDigit) + "Mbps";
}
return formatValue(value, minDigit, maxDigit) + "Kbps";
}
return formatValue(value, 0, 0) + "bps";
}

public static String getBytesPerSecString(double p_value, int minDigit, int maxDigit) {
double value = p_value;
if (value > 1024) {
value /= 1024;
if (value > 1024) {
value /= 1024;
if (value > 1024) {
value /= 1024;
return formatValue(value, minDigit, maxDigit) + "GB/S";
}
return formatValue(value, minDigit, maxDigit) + "MB/S";
}
return formatValue(value, minDigit, maxDigit) + "KB/S";
}
return formatValue(value, 0, 0) + "B/S";
}

/**
* 获取速度的字符串
* @param value
* @param minDigit
* @param maxDigit
* @return
*/
public static String getPsString(double p_value, int minDigit, int maxDigit, String unit) {
double value = p_value;
if (value >= 1024) {
value /= 1024;
if (value >= 1024) {
value /= 1024;
if (value >= 1024) {
value /= 1024;
return formatValue(value, minDigit, maxDigit) + "G" + unit;
}
return formatValue(value, minDigit, maxDigit) + "M" + unit;
}
return formatValue(value, minDigit, maxDigit) + "K" + unit;
}
return formatValue(value, 0, 0) + unit;
}

/**
* 获取字节大小的字符串
* @param value
* @param minDigit
* @param maxDigit
* @return
*/
public static String getBytesString(double p_value, int minDigit, int maxDigit) {
double value = p_value;
if (value > 1024) {
value /= 1024;
if (value > 1024) {
value /= 1024;
if (value > 1024) {
value /= 1024;
return formatValue(value, minDigit, maxDigit) + "GB";
}
return formatValue(value, minDigit, maxDigit) + "MB";
}
return formatValue(value, minDigit, maxDigit) + "KB";
}
return formatValue(value, 0, 0) + "B";

}

public static String getPeriodString(long seconds) {
long hour = seconds / 3600;
long minute = (seconds % 3600) / 60;
long second = (seconds % 3600) % 60;
String period = "";
if (hour > 0)
period = period + hour + I18nUtil.getInstance().getValue("Hour");
if (minute > 0)
period = period + minute + I18nUtil.getInstance().getValue("Minute");
if (second > 0)
period = period + second + I18nUtil.getInstance().getValue("Second");
return period;
}

public static String getPeriodByMS(long ms) {
if (ms == 0) {
return ("0ms");
}
long hour = ms / 3600000;
long ret = ms % 3600000;
long minute = ret / 60000;
ret %= 60000;
long second = ret / 1000;
long mSecond = ret % 1000;
String period = "";
if (hour > 0) {
period += hour + "h";
}

if (minute > 0) {
period += minute + "m";
}

if (second > 0) {
period += second + "s";
}
if (mSecond > 0) {
period += mSecond + "ms";
}
return period;
}

/**
* 从i18n文件中读取的"\n"符不再是一个字符，所以需要替换，将读取出来的字符串转成有换行符的合法串
* @param str
* @return
*/
public static String getNewLineString(String p_str) {
String str = p_str;
if (str == null) {
return null;
}

byte[] x = { 92, 110 }; // 从i18n文件中读取的"\n"的byte值
String newline = new String(x);
int idx = str.indexOf(newline);
String tmp = "";
while (idx > 0) {
tmp = str.substring(0, idx) + "\n" + str.substring(idx + 2);
str = tmp;
idx = str.indexOf(newline);
}

return str;
}

/**
* 获取当前系统时间的前n个时刻的时间 例：传入1，当前系统时间为(2007-10-11 10:12:12 的毫秒数表示) 返回时间为 (2007-10-11 9:45:00 的毫秒数表示)
* @param preQuarterCount
* @return Date==〉
* @author wenju
*/
public static Date getDatePreQuarter(int preQuarterCount) {
int QUARTER_MILL = 900000;
long currentMill = System.currentTimeMillis();
long needReduce = currentMill % QUARTER_MILL;
needReduce += QUARTER_MILL * preQuarterCount;
currentMill -= needReduce;
return new Date(currentMill);

}

/**
* 获取流量字节数
* @param value
* @param minDigit
* @param maxDigit
* @return
*/
public static String getbyteString(long bytes) {
BigDecimal filesize = new BigDecimal(bytes);
BigDecimal gegabyte = new BigDecimal( 1024 * 1024 * 1024 );
float returnValue = filesize.divide(gegabyte, 2 , BigDecimal.ROUND_UP).floatValue();
if(returnValue>1){
return (returnValue + "GB" );
}
BigDecimal megabyte = new BigDecimal( 1024 * 1024 );
returnValue = filesize.divide(megabyte, 2 , BigDecimal.ROUND_UP).floatValue();
if(returnValue>1 ){
return (returnValue + "MB" );
}
BigDecimal kilobyte = new BigDecimal(1024);
returnValue = filesize.divide(kilobyte,2,BigDecimal.ROUND_UP).floatValue();
if(returnValue>1 ){
return (returnValue + "KB" );
}
return (bytes + "B");
}

/**
* 格式化Double(保留位，非四舍五入)
* @param number
* @param maxDigit
* @return
*/
public static String formatdouble(double ratio,int maxDigit){
String ratiostr=String.valueOf(ratio);
ratiostr=ratiostr.replace('.',',');
String Rate=ratiostr;
String[] ratiolist=ratiostr.split(",");
if(maxDigit>0){
if(ratiolist.length>1){
if(ratiolist[1].length()>=maxDigit){
Rate=ratiolist[0]+"."+ratiolist[1].substring(0,maxDigit);
}else{
String str="";
for(int i=ratiolist[1].length();i<maxDigit;i++){
str+="0";
}
Rate=ratiolist[0]+"."+ratiolist[1]+str;
}
}else{
String str="";
for(int i=0;i<maxDigit;i++){
str+="0";
}
Rate=ratiolist[0]+"."+str;
}
}else{
Rate=ratiolist[0];
}
return Rate;
}

}