`
myclover
  • 浏览: 195066 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

一个简单的String操作工具类

    博客分类：
  • java
Mobile正则表达式Blog 
阅读更多
对一些常用的方法进行简单的封装，有些正则表达式来源于网络，要是有任何问题，请各位高手多多指教！ 


//StringOperateUtils.java

package com.myclover.utils.string;

import java.math.BigDecimal;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.LinkedHashSet;
import java.util.Random;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.myclover.utils.constant.StringConstants;



/**
  * <pre>
  * 功能描述： 字符串操作类
  *           把一些String相关的常用的方法进行了封装，方便以后直接使用
  * </pre>
  * @author 方方   <p>
  * 				Blog:  http://myclover.iteye.com <p>
  * 				日   期：  2010-08-30 <p>
  * @version 1.0 <p>
  * {@code com.myclover.utils.string.StringOperateUtils.java com.myclover.utils.constant.StringConstants.java}
  *
 */
public class StringOperateUtils {
	
	// 身份证加权因子
	private static final int[] weight = new int[] { 7, 9, 10, 5, 8, 4, 2, 1, 6,
			3, 7, 9, 10, 5, 8, 4, 2, 1 };
	// 身份证校验码
	private static final int[] checkDigit = new int[] { 1, 0, 'X', 9, 8, 7, 6,
			5, 4, 3, 2 };
	
	/**
	 * 功能描述：验证字符串为null或空字符串
	 * @param  strTemp  需要验证的字符串
	 * @return    返回：如果验证成功，则返回true，否则返回false
	 */
	public static boolean validateNull(String strTemp) {
		if (strTemp == null || strTemp.length() == 0) {
			return true;
		}
		return false;
	}

	
	/**
	 * 功能描述：过滤Html特殊字符
	 * @param strTemp  需要过滤的字符串
	 * @return   返回：返回过滤后的新字符串
	 * 
	 */
	public static String filterHtml(String strTemp) {
		if (strTemp == null) {
			return null;
		}
		if (strTemp.length() == 0) {
			return strTemp;
		}

		String temp = null;
		temp = strTemp.replaceAll("&", "&amp;");
		temp = temp.replaceAll("<", "&lt;");
		temp = temp.replaceAll(">", "&gt;");
		temp = temp.replaceAll(" ", "&nbsp;");
		temp = temp.replaceAll("'", "&#39;");
		temp = temp.replaceAll("\"", "&quot;");
		temp = temp.replaceAll("\n", "<br>");
		return temp;
	}
	
	
	/**
	 * 功能描述：验证E-mail地址的合法性
	 * @param email  需要验证的email地址
	 * @return 返回：如果是合法的email地址，则返回true，否则返回false
	 * 
	 */
	public static boolean validateEmail(String email) {
		Pattern p = Pattern.compile(StringConstants.EMAIL_REGEXP);
		Matcher m = p.matcher(email);
		if (m.matches()) {
			return true;
		}
		return false;
	}

	
	/**
	 * 功能描述：验证电话号码的合法性
	 * @param  phone  需要验证的电话号码
	 * @return  返回：合法的电话号码则返回true，否则返回false
	 * 
	 */
	public static boolean validatePhone(String phone) {
		Pattern p = Pattern.compile(StringConstants.PHONE_REGEXP);
		Matcher m = p.matcher(phone);
		if (m.matches()) {
			return true;
		}
		return false;
	}
	
	
	/**
	 * 功能描述：验证邮政编码的合法性
	 * @param zip  需要验证的邮政编码
	 * @return 返回：合法的邮政编码则返回true，否则返回false
	 */
	public static boolean validateZIP(String zip){
		Pattern p = Pattern.compile(StringConstants.ZIP_REGEXP);
		Matcher m = p.matcher(zip);
		if(m.matches())
		{
			return true;
		}
		return false;
	}
	
	
	/**
	 * 功能描述：验证URL的合法性
	 * @param url  需要验证的URL
	 * @return 返回：合法的URL则返回true，否则返回false
	 */
	public static boolean validateURL(String url){
		Pattern p = Pattern.compile(StringConstants.URL_REGEXP);
		Matcher m = p.matcher(url);
		if(m.matches())
		{
			return true;
		}
		return false;
	}
	
	
	/**
	 * 功能描述：验证HTTP的合法性
	 * @param http  需要验证的HTTP
	 * @return 返回：合法的HTTP则返回true，否则返回false
	 */
	public static boolean validateHTTP(String http){
		Pattern p = Pattern.compile(StringConstants.HTTP_REGEXP);
		Matcher m = p.matcher(http);
		if(m.matches())
		{
			return true;
		}
		return false;
	}
	
	
	/**
	 * 功能描述：验证中文字符的合法性
	 * @param zh  需要验证的中文字符
	 * @return 返回：合法的中文字符则返回true，否则返回false
	 */
	public static boolean validateZH(String zh){
		Pattern p = Pattern.compile(StringConstants.ZH_REGEXP);
		Matcher m = p.matcher(zh);
		if(m.matches())
		{
			return true;
		}
		return false;
	}
	
	
	/**
	 * 功能描述：验证手机号码的合法性
	 * @param mobile  需要验证的手机号码
	 * @return 返回：合法的手机号码则返回true，否则返回false
	 */
	public static boolean validateMobile(String mobile){
		Pattern p = Pattern.compile(StringConstants.MOBILE_REGEXP);
		Matcher m = p.matcher(mobile);
		if(m.matches())
		{
			return true;
		}
		return false;
	}
	
	
	/**
	 * 功能描述：验证图片格式的合法性
	 * @param img  需要验证的图片格式
	 * @return 返回：合法的图片格式则返回true，否则返回false
	 */
	public static boolean validateImg(String img){
		Pattern p = Pattern.compile(StringConstants.ICON_REGEXP);
		Matcher m = p.matcher(img);
		if(m.matches())
		{
			return true;
		}
		return false;
	}
	
	
	/**
	 * 功能描述：判断字符串是否是合法的Java标识符
	 * @param java.lang.String s  待判断的字符串参数
	 * @return  返回：如果符合Java标识符，则返回true
	 *                否则返回false
	 */
	public static boolean isJavaIdentifier(String s){
        //如果字符串为空或者长度为0，返回false
		if ((s == null) || (s.length() == 0)) {
            return false;
        }
        //字符串中每一个字符都必须是Java标识符的一部分
        for (int i=0; i<s.length(); i++) {
            if (!Character.isJavaIdentifierPart(s.charAt(i))) {
                return false;
            }
        }
        return true;
	}
	
	
	/**
	 * 功能描述：将字符串第一个字母转为大写
	 * @param java.lang.String  str   需要转换的字符串参数
	 * @return   返回：返回转换后的新字符串
	 */
	public static String convertFirstToUpper(String str){
		String str1 = str.substring(0,1).toUpperCase();
		String str2 = str.substring(1,str.length());
		return str1+str2;
	}
	
	
	/**
	 * 功能描述：替换掉特殊字符
	 * @param java.lang.String  strFileContent  原字符串
	 * @return   返回：替换后的新字符串
	 */
	public static String replaceSpecialChar(String strFileContent){    	  
  	  Pattern pattern = Pattern.compile("[<>*?|\\/:\"]+");
  	  Matcher m = pattern.matcher(strFileContent);
  	  strFileContent = m.replaceAll("");
  	  return strFileContent;
    }
	
	/**
     * 功能描述：如果原字符串不为空，则返回原字符串，否则返回给定的字串str2
     * @param java.lang.String  str  原字符串
     * @param java.lang.String  str2 给定的字符
     * @return  返回：如果原字符串不为空，则返回原字符串，否则返回给定的字串str2
     */
    public static String nullString(String str,String str2){    	  
  	  str = (str==null)?str2:str;
  	  str = (str.equals("null"))?str2:str;
  	  str = (str.equals(""))?str2:str;
  	  return str;
    }
    
    /**
     * 功能描述：空判断，如果为空，返回给定的字串str2
     * @param strFileContent
     * @param str 原字符串
     * @param str2 给定的字符
     * @return
     */
    public static String emptyString(String str,String str2){    	  
  	  str = nullString(str,str2);
  	  str = (str.equals(""))?str2:str;
  	  return str;
    }
    
/**
 * 功能描述： 对指定字符串的截取
 * 
 * @param java.lang.String strFile
 *            给定的字符串，从1开始计算
 * @param iStart
 *            起始位置，
 * @param iLen
 *            截取的字串长度
 * @return
 * 		  返回：返回截取后的新子串	
 */
	public static String getStringByLocation(String strFile, int iStart,int iLen) {
	String strLocate = "";
	try {
		if (strFile.length() >= (iStart + iLen)) {
			strLocate = strFile.substring(iStart - 1, iStart + iLen - 1);
		} else if (strFile.length() >= iStart) {
			strLocate = strFile.substring(iStart - 1);
		} else {
			strLocate = "";
		}
	} catch (Exception e) {
		System.err.println(e);
	}
	return strLocate.trim();// strFile2
}
	
	/**
	 * 功能描述：截取指定字符之前的字串
	 * @param java.lang.String strFile 
	 *           给定的字符串
	 * @param java.lang.String loc  
	 *           指定字符,默认为一个空格
	 * @return
	 * 		  返回：截取后的字符串
	 */
	public static String getStringByLocation(String strFile, String loc) {
	if ("".equals(loc)) {
		loc = " ";
	}
	//  如果不存在指定的字符串loc
	// strFile = strFile.substring(0,strFile.indexOf(loc));这一句会报错
	if (strFile.indexOf(loc) == -1)
		return strFile;
	try {
		if (!"".equals(strFile)) {
			strFile = strFile.trim();
			strFile = strFile.substring(0, strFile.indexOf(loc));
		} else {
			return "";
		}
	} catch (Exception e) {
		System.err.println(e);
	}
	return strFile;// strFile2
}
	
	/**
	 * 功能描述：根据指定的位置截取字符串，并在字符串后面追加给定的子串
	 * @param java.lang.String strFile 
	 *          需要截取的字符串，从1开始计算的
	 * @param iStart  起始位置，
	 * @param iLen    截取的字串长度
	 * @param java.lang.String strAdd  
	 *          后面增加指定字符
	 * @return
	 *         返回：截取后的新字符串
	 */
	public static String getStringByLocation(String strFile, int iStart,int iLen,String strAdd) {
	String strLocate = "";
	try {
		if (strFile.length() >= (iStart + iLen)) {
			strLocate = strFile.substring(iStart - 1, iStart + iLen - 1);
		} else if (strFile.length() >= iStart) {
			strLocate = strFile.substring(iStart - 1);
		} else {
			strLocate = "";
		}
	} catch (Exception e) {
		System.err.println(e);
	}
	return strLocate.trim()+strAdd;// strFile2
}
	
	/**
	 * 功能描述：从指定的起始和截止位置对指定的字符串进行截取
	 * @param java.lang.String strFile 
	 * 				  给定的字符串
	 * @param iStart  起始位置，
	 * @param iEnd    结束位置
	 * @return
	 *        返回： 截取后的新串
	 */
	public static String getBeginEndLocation(String strFile, int iStart,int iEnd) {
	String strLocate = "";
	if (iEnd < 0 || iEnd < iStart) {
		return "";
	}
	try {
		if (strFile.length() >= (iEnd)) {
			strLocate = strFile.substring(iStart, iEnd);
		} else if (strFile.length() >= iStart) {
			strLocate = strFile.substring(iStart);
		} else {
			strLocate = "";
		}
	} catch (Exception e) {
		System.err.println(e);
	}
	return strLocate.trim();// strFile2
}
	
	/**
	 * 功能描述：根据指定的位置截取字符串，并在字符串后面追加给定的子串
	 * @param java.lang.String strFile 
	 * 				  给定字串
	 * @param iStart  
	 *                起始位置，
	 * @param iEnd    
	 *                结束位置
	 * @param java.lang.String strAdd  
	 *                后面增加指定字符
	 * @return
	 *        返回：截取后的新字符串
	 */
	public static String getBeginEndLocation(String strFile, int iStart,int iEnd,String strAdd) {
	String strLocate = "";
	try {
		if (strFile.length() >= (iEnd)) {
			strLocate = strFile.substring(iStart, iEnd);
		} else if (strFile.length() >= iStart) {
			strLocate = strFile.substring(iStart);
		} else {
			strLocate = "";
		}
	} catch (Exception e) {
		System.err.println(e);
	}
	return strLocate.trim() + strAdd;// strFile2
}
	
	/**
	 * 功能描述：根据指定的位置截取子字符串
	 * @param java.lang.String strFile 
	 *                给定字串 从1开始计算的
	 * @param iStart  
	 *                起始位置，
	 * @param iLen    
	 *               截取的字串长度
	 * @return
	 *        返回：截取后的子串
	 */
	public static String getBeginEnd1Location(String strFile, int iStart,int iLen) {
	String strLocate = "";
	try {
		if (strFile.length() >= (iStart + iLen)) {
			strLocate = strFile.substring(iStart - 1, (iStart + iLen) - 1);
		} else if (strFile.length() >= iStart) {
			strLocate = strFile.substring(iStart - 1);
		} else {
			strLocate = "";
		}
	} catch (Exception e) {
		System.err.println(e);
	}
	return strLocate.trim();// strFile2
}
	
	/**
	 * 功能描述：根据指定的位置截取子串，并在后面进行追加指定的字符串
	 * @param java.lang.String  strFile
	 * 				  给定字串 从1开始计算的
	 * @param iStart  
	 *                起始位置，
	 * @param iLen    
	 *                截取的字串长度
	 * @param java.lang.String  strAdd  
	 *                后面增加指定字符
	 * @return
	 *        返回：   截取并且追加后的子串
	 */
	public static String getBeginEnd1Location(String strFile, int iStart,int iLen,String strAdd) {
	String strLocate = "";
	try {
		if (strFile.length() >= (iStart + iLen)) {
			strLocate = strFile.substring(iStart - 1, (iStart + iLen) - 1);
		} else if (strFile.length() >= iStart) {
			strLocate = strFile.substring(iStart - 1);
		} else {
			strLocate = "";
		}
	} catch (Exception e) {
		System.err.println(e);
	}
	return strLocate.trim() + strAdd;// strFile2
}
	
	/**
	 * 功能描述: 返回指定长度的空字符串
	 * @param iLen
	 * @return
	 *        返回：指定长度的空串
	 */
	public static String getSpace(int iLen){
		StringBuffer str = new StringBuffer("");
		for(int i = 0;i<iLen;i++){
			str.append(" ");
		}
		return str.toString();
	}
	
	
	/**
	 * 功能描述：将字符串转换成整型数据
	 * @param str  字符串
	 * @return  返回：返回转换后的整型数据
	 */
	public static int stringToInt(String str){
		str = nullString(str,"0");
		if(StringOperateUtils.isNumeric(str))
		{
			return Integer.parseInt(str);
		}
		return 0;
	}
	
	
/**
 * 功能描述: 返回指定个数的指定字符串
 * @param iLen 
 *              指定个数
 * @param java.lang.String str2  
 *              指定字符串
 * @return
 *        返回：新字符串
 */
	public static String getSpace(int iLen,String str2){
		StringBuffer str = new StringBuffer("");
		for(int i = 0;i<iLen;i++){
			str.append(str2);
		}
		return str.toString();
	}
	
/**
 * 
 * 功能描述: 返回指定长度的指定字符串   	
 * @param java.lang.String str
 *             原字符串
 * @param iLen
 *             增加子串的长度数量，其中iLen-str.getBytes().length 为str2增加的个数
 * @param java.lang.String str2
 *             增加的子串
 * @param java.lang.String strLR
 *             子串增加的位置，其中strLR为H或h表示在头增加子串，否则在尾部增加
 * @return
 *        返回：新的字符串
 */
	public static String parseString(String str,int iLen,String str2,String strLR){
		str = StringOperateUtils.emptyString(str, "");
	String strTmp = "";
	int istrLen = str.getBytes().length;
	for (int i = istrLen; i < iLen; i++) {
		strTmp += str2;
	}
	if ("H".equalsIgnoreCase(strLR)) {
		return strTmp + str;
	} else {
		return str + strTmp;
	}
	}
	
	/**
	 * 功能描述：特殊字符，全角转半角
	 * @param java.lang.String str
	 *          含有全角的字符串
	 * @return
	 *        返回：只有半角的字符串
	 */
	public static String replaceRN(String str){
		if (str != null) {
		str = str.replaceAll("’", "'");
		str = str.replaceAll("，", ",");
		str = str.replaceAll("。", ".");
		str = str.replaceAll("？", "?");
		str = str.replaceAll("`", "");
		str = str.replaceAll("；", ";");
		str = str.replaceAll("：", ":");
		str = str.replaceAll("！", "!");
	}
		return str;
	}
	
	
/**
 * 根据指定长度，给字串补齐,若超过指定长度，则进行截取处理
 * 
 * @param str
 *            给定字串
 * @param iLen
 *            指定长度
 * @param type
 *            保留变量
 * @param filterFlg
 *            是否过滤 true :过滤；false：不过滤
 * @return
 */
	public static String getSpaceString(String str,int iLen,String type,boolean filterFlg){   		
		if (str == null || str.equals("") || str.equals("null")) {
		str = " ";
	}
	// 过滤全角字符
	if (filterFlg) {
		str = replaceRN(str);
	}
	// 得到字符长度
	int iStrLen = str.length();
	if (iLen > iStrLen) {
		str += StringOperateUtils.getSpace(iLen - str.getBytes().length);
	} else {
		// IF Pos(is_errortext,as_type) = 0 Then is_errortext=is_errortext +
		// as_type +"~r~n"
		str = str.substring(0, iLen);
	}
	str.replaceAll("\n", "");
	return str;
	}
	
	/**
	 * 功能描述：返回四舍五入的double
	 * @param unroundedValue 
	 *           接收的输入参数
	 * @param ai_decimal 
	 *           小数位长度
	 * @return
	 *        返回：四舍五入后的double数据
	 */	
public static Double getRoundedDouble(double unroundedValue, int ai_decimal) {
	int aa=1;        
    for(int i = 0;i<ai_decimal;i++)
    {
    	aa = aa*10;
    }
	double bb = Double.parseDouble("1"+StringOperateUtils.getSpace(ai_decimal, "0") + "." + StringOperateUtils.getSpace(ai_decimal, "0"));	
	
	return Double.valueOf(Math.round(unroundedValue*aa)/bb);
}

/**
 * 功能描述：返回四舍五入的double
 * @param unroundedValue 
 *           接收的输入参数
 * @param ai_decimal 
 *           小数位长度
 * @return
 *        返回：四舍五入后的double数据
 */
public static Double getRoundedSimDouble(double unroundedValue, int ai_decimal){
	double total = 	new BigDecimal( unroundedValue ).setScale( ai_decimal, BigDecimal.ROUND_HALF_UP ).doubleValue( );	
	return new Double(total);
}



	/**
	 * 功能描述：判断是否是数字
	 * @param java.lang.String str
	 *           接收的字符串参数
	 * @return
	 *         返回：如果是数字，则返回true，否则返回false
	 */
	public static boolean isNumeric(String str)
	{
		Pattern pattern = Pattern.compile("[0-9]*");
		Matcher isNum = pattern.matcher(str);
		if( !isNum.matches() )
		{
			return false;
		}
		return true;
	} 

	/**
	 * 功能描述：把\n符号转换为</br>
	 * @param str
	 * @return
	 */
	public static String formatHtmlStr(String str){
		if(str == null)
			return "";
		return str.replaceAll("\n", "</br>");
	}

	/**
	 * 功能描述：截取得到从后往前的ilen位非字母的数字
	 * 
	 * @param java
	 *            .lang.String str 接收的字符串
	 * @param iLen
	 *            非字母数字的长度，如果数字的位数比这个长度小，则以空格补齐
	 * @return 返回：非字母的数字字符串
	 */
	public static String getShipId(String str, int iLen) {
		String strNumber = "";
		for (int i = str.length(); i > 0; i--) {
			String strTmp = str.substring(i - 1, i);
			if ("0123456789".indexOf(strTmp) != -1) {
				strNumber = strTmp + strNumber;
			}
			if (strNumber.length() > (iLen - 1))
				break;
		}
		return strNumber;
	}

	/**
	 * 功能描述：截取得到从前往后的iLen位非字母的数字
	 * 
	 * @param java
	 *            .lang.String str 接收的字符串
	 * @param iLen
	 *            非字母数字的长度，如果数字的位数比这个长度小，则以空格补齐
	 * @return 返回：非字母的数字字符串
	 */
	public static String getShipIdHead(String str, int iLen) {
		String strNum = "";
		for (int i = 0; i < str.length(); i++) {
			String strTmp = str.substring(i, i + 1);
			if ("0123456789".indexOf(strTmp) != -1) {
				strNum = strNum + strTmp;
			}
			if (strNum.length() > (iLen - 1)) {
				break;
			}

		}
		return strNum;
	}


	/**
	 * 判断任意一个整数是否素数
	 * 
	 * @param n
	 * @return boolean
	 */
	public static boolean isPrimes(int n) {
		for (int i = 2; i <= Math.sqrt(n); i++) {
			if (n % i == 0) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 获得任意一个整数的阶乘，递归
	 * 
	 * @param n
	 * @return n!
	 */
	public static int factorial(int n) {
		if (n == 1) {
			return 1;
		}
		return n * factorial(n - 1);
	}

	/**
	 * 获得任意一个整数的阶乘，递归
	 * 
	 * @param n
	 * @return n!
	 */
	public static long factorial(long n) {
		if (n == 1) {
			return 1;
		}
		return n * factorial(n - 1);
	}


	/**
	 * 功能描述：人民币转成大写
	 * @param value    需要转换的金额
	 * @return String  转换后的字符串
	 */
	public static String rmbToBigString(double value) {
		char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
		char[] vunit = { '万', '亿' }; // 段名表示
		char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
		long midVal = (long) (value * 100); // 转化成整形
		String valStr = String.valueOf(midVal); // 转化成字符串

		String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
		String rail = valStr.substring(valStr.length() - 2); // 取小数部分

		String prefix = ""; // 整数部分转化的结果
		String suffix = ""; // 小数部分转化的结果
		// 处理小数点后面的数
		if (rail.equals("00")) { // 如果小数部分为0
			suffix = "整";
		} else {
			suffix = digit[rail.charAt(0) - '0'] + "角"
					+ digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
		}
		// 处理小数点前面的数
		char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
		char zero = '0'; // 标志'0'表示出现过0
		byte zeroSerNum = 0; // 连续出现0的次数
		for (int i = 0; i < chDig.length; i++) { // 循环处理每个数字
			int idx = (chDig.length - i - 1) % 4; // 取段内位置
			int vidx = (chDig.length - i - 1) / 4; // 取段位置
			if (chDig[i] == '0') { // 如果当前字符是0
				zeroSerNum++; // 连续0次数递增
				if (zero == '0') { // 标志
					zero = digit[0];
				} else if (idx == 0 && vidx > 0 && zeroSerNum < 4) {
					prefix += vunit[vidx - 1];
					zero = '0';
				}
				continue;
			}
			zeroSerNum = 0; // 连续0次数清零
			if (zero != '0') { // 如果标志不为0,则加上,例如万,亿什么的
				prefix += zero;
				zero = '0';
			}
			prefix += digit[chDig[i] - '0']; // 转化该数字表示
			if (idx > 0)
				prefix += hunit[idx - 1];
			if (idx == 0 && vidx > 0) {
				prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
			}
		}

		if (prefix.length() > 0)
			prefix += '圆'; // 如果整数部分存在,则有圆的字样
		return prefix + suffix; // 返回正确表示
	}

	/**
	 * 功能描述：全角字符转半角字符
	 * 
	 * @param QJStr   全角字符
	 * @return String 转换后的半角字符
	 */
	public static final String QJToBJChange(String qjStr) {
		char[] chr = qjStr.toCharArray();
		String str = "";
		for (int i = 0; i < chr.length; i++) {
			chr[i] = (char) ((int) chr[i] - 65248);
			str += chr[i];
		}
		return str;
	}

	/**
	 * 功能描述：去掉字符串中重复的子字符串
	 * @param str    原字符串
	 * @param match  字符串分隔符
	 * @return String  返回分隔后不重复的新字符串
	 */
	public static String removeSameString(String str , String match) {
		Set mLinkedSet = new LinkedHashSet();
		if(match == null || "".equals(match.trim()))
		{
			match = " ";
		}
		String[] strArray = str.split(match);
		StringBuffer sb = new StringBuffer();

		for (int i = 0; i < strArray.length; i++) {
			if (!mLinkedSet.contains(strArray[i])) {
				mLinkedSet.add(strArray[i]);
				sb.append(strArray[i] + " ");
			}
		}
		return sb.toString().substring(0, sb.toString().length() - 1);
	}


	/**
	 * 功能描述：返回给定的两个字符串中相同的最大的子串
	 * @param a  字符串
	 * @param b  字符串
	 * @return   返回：返回两个字符串中相同的最大的子串
	 */
	public static String getMaxMatch(String a, String b) {
		StringBuffer tmp = new StringBuffer();
		String maxString = "";
		int max = 0;
		int len = 0;
		char[] aArray = a.toCharArray();
		char[] bArray = b.toCharArray();
		int posA = 0;
		int posB = 0;
		while (posA < aArray.length - max) {
			posB = 0;
			while (posB < (bArray.length - max)) {
				if (aArray[posA] == bArray[posB]) {
					len = 1;
					tmp = new StringBuffer();
					tmp.append(aArray[posA]);
					while ((posA + len < aArray.length)
							&& (posB + len < bArray.length)
							&& (aArray[posA + len] == bArray[posB + len])) {
						tmp.append(aArray[posA + len]);
						len++;
					}
					if (len > max) {
						max = len;
						maxString = tmp.toString();
					}
				}
				posB++;
			}
			posA++;
		}
		return maxString;
	}


	/**
	 * 功能描述：判断是不是合法字符 
	 * @param ch 要判断的字符
	 * @return 返回：如果是合法字符，则返回true，否则返回false
	 */
	public static boolean isLetter(char ch) {
		
		String c = String.valueOf(ch);
		
		if (c == null || c.length() < 0) {
			return false;
		}
		// a-z
		if (c.compareToIgnoreCase("a") >= 0 && c.compareToIgnoreCase("z") <= 0) {
			return true;
		}
		// 0-9
		if (c.compareToIgnoreCase("0") >= 0 && c.compareToIgnoreCase("9") <= 0) {
			return true;
		}
		// . - _
		if (c.equals(".") || c.equals("-") || c.equals("_")) {
			return true;
		}
		return false;
	}
	
	
	/**
	 * 功能描述：判断是不是由合法的字符组成的字符串
	 * @param str   需要判断的字符串
	 * @return   返回：如果是合法的则返回true，否则返回false
	 */
	public static boolean isRealLetter(String str)
	{
		if(str == null || str.length() < 0)
		{
			return false;
		}
		for(int i = 0 ; i < str.length() ; i++)
		{
			if(!StringOperateUtils.isLetter(str.charAt(i)))
			{
				return false;
			}
		}
			return true;
	}
	
	
	/**
	 * 功能描述：通过时间戳和三位随机数生成20位长度的UUID
	 * @return  返回：20位长度的UUID
	 */
	public static String generateUUID()
	{
		Calendar cal = new GregorianCalendar();
		Random r = new Random();
		StringBuffer sb = new StringBuffer();
		sb.append(cal.get(Calendar.YEAR));
		sb.append(StringOperateUtils.addZero(cal.get(Calendar.MONTH) + 1 , 2));
		sb.append(StringOperateUtils.addZero(cal.get(Calendar.DAY_OF_MONTH) , 2));
		sb.append(StringOperateUtils.addZero(cal.get(Calendar.HOUR_OF_DAY) , 2));
		sb.append(StringOperateUtils.addZero(cal.get(Calendar.MINUTE) , 2));
		sb.append(StringOperateUtils.addZero(cal.get(Calendar.SECOND) , 2));
		sb.append(StringOperateUtils.addZero(cal.get(Calendar.MILLISECOND) , 3));
		sb.append(r.nextInt(10));
		sb.append(r.nextInt(10));
		sb.append(r.nextInt(10));
		
		return sb.toString();
	}
	
	
	/**
	 * 功能描述：对给定的数字长度不够的在其前面补0
	 * @param date  给定的数字
	 * @param len   需要的长度
	 * @return      返回：返回给定长度的字符串
	 */
	public static String addZero(int date , int len)
	{
		String str = String.valueOf(date);
		StringBuffer sb = new StringBuffer("");
		while(str.length() < len)
		{
			sb.append("0");
			len--;
		}
		sb.append(str);
		return sb.toString();
	}
	
	
	/**
	 * <pre>
	 * 公民身份号码是特征组合码,由十七位数字本体码和一位数字校验码组成.排列顺序从左至右依次为:
	 * 六位数字地址码,八位数字出生日期码,三位数字顺序码和一位数字校验码。
	 * 1、地址码：表示编码对象常住户口所在县（市、旗、区）的行政区划代码，按 GB/T 2260 的规定执行。 
	 * 2、出生日期码：表示编码对象出生的年、月、日，按 * GB/T 7408 的规定执行。年、月、日代码之间不用分隔符。 
	 * 例：某人出生日期为 1966年10月26日，其出生日期码为 19661026。
	 * 3、顺序码：表示在同一地址码所标识的区域范围内，
	 * 对同年、同月、同日出生的人编定的顺序号，顺序码的奇数分配给男性，偶数千分配给女性。 
	 * 4、校验码：校验码采用ISO 7064：1983，MOD 11-2 校验码系统。 
	 * （1）十七位数字本体码加权求和公式 
	 * S = Sum(Ai * Wi), i = * 0, ... , 16 ，先对前17位数字的权求和 
	 * Ai:表示第i位置上的身份证号码数字值 
	 * Wi:表示第i位置上的加权因子 
	 * Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2 1
	 * （2）计算模 Y = mod(S, 11) 
	 * （3）通过模得到对应的校验码 
	 * Y: 0 1 2 3 4 5 6 7 8 9 10 
	 * 校验码: 1 0 X 9 8 7 6 5 4 3 2
	 * </pre>
	 * 功能描述：验证身份证是否合法
	 * @param java.lang.String idcard 传入身份证参数
	 * @return  
	 * 如果验证成功则返回：true  
	 * 否则返回：false
	 */
	public static boolean verifyIDCard(String idcard) {
		if (idcard.length() == 15) {
			idcard = StringOperateUtils.updateToeighteen(idcard);
		}
		if (idcard.length() != 18) {
			return false;
		}
		//获取输入身份证上的最后一位，它是校验码
		String checkDigit = idcard.substring(17, 18);
		//比较获取的校验码与本方法生成的校验码是否相等
		if (checkDigit.equals(StringOperateUtils.getCheckDigit(idcard))) {
			return true;
		}
		return false;
	}

	/**
	 * 功能描述：计算18位身份证的校验码
	 * @param java.lang.String eighteenCardID	18位身份证参数
	 * @return 返回18位的身份证字符串
	 */
	private static String getCheckDigit(String eighteenCardID) {
		int remaining = 0;
		if (eighteenCardID.length() == 18) {
			eighteenCardID = eighteenCardID.substring(0, 17);
		}

		if (eighteenCardID.length() == 17) {
			int sum = 0;
			int[] a = new int[17];
			//先对前17位数字的权求和
			for (int i = 0; i < 17; i++) {
				String k = eighteenCardID.substring(i, i + 1);
				a[i] = Integer.parseInt(k);
			}
			for (int i = 0; i < 17; i++) {
				sum = sum + weight[i] * a[i];
			}
			//再与11取模
			remaining = sum % 11;
		}
		return remaining == 2 ? "X" : String.valueOf(checkDigit[remaining]);
	}

	
	/**
	 * 功能描述：将15位身份证升级成18位身份证号码
	 * @param java.lang.String fifteenCardID 15位身份证参数
	 * @return  返回：把15位转换为18位的身份证字符串
	 */
	private static String updateToeighteen(String fifteenCardID) {
		//15位身份证上的生日中的年份没有19，要加上
		String eighteenCardID = fifteenCardID.substring(0, 6);
		eighteenCardID = eighteenCardID + "19";
		eighteenCardID = eighteenCardID + fifteenCardID.substring(6, 15);
		eighteenCardID = eighteenCardID + StringOperateUtils.getCheckDigit(eighteenCardID);
		return eighteenCardID;
	}
	
	/**
	 * 功能描述：判断ip地址是否合法
	 * @param strIP  需要判断的ip地址
	 * @return  返回：如果ip地址合法，则返回true，否则返回false
	 */
	public static boolean isRealIP(String strIP){
		String[] s = strIP.split("\\.");
		if(s.length != 4){
			return false;
		}
		for(int i=0;i<s.length;i++){
			if(Integer.parseInt(s[i]) > 255 || Integer.parseInt(s[i]) < 0)
				return false;
		}
		return true;
	}
	

	/**
	 * 功能描述：将127.0.0.1 形式的IP地址转换成10进制整数，这里没有进行任何错误处理
     * @param strIP  ip地址
     * @return  返回：返回转换后的整型数据
     */
    public static long ipToLong(String strIP){
    	if(!isRealIP(strIP)){
    		return -1;
    	}
         long[] ip=new long[4];
         //先找到IP地址字符串中.的位置
         int position1=strIP.indexOf(".");
         int position2=strIP.indexOf(".",position1+1);
         int position3=strIP.indexOf(".",position2+1);
         //将每个.之间的字符串转换成整型
         ip[0]=Long.parseLong(strIP.substring(0,position1));
         ip[1]=Long.parseLong(strIP.substring(position1+1,position2));
         ip[2]=Long.parseLong(strIP.substring(position2+1,position3));
         ip[3]=Long.parseLong(strIP.substring(position3+1));
         return (ip[0]<<24)+(ip[1]<<16)+(ip[2]<<8)+ip[3]; 
    }

    
    /**
     * 功能描述：将10进制整数形式转换成127.0.0.1形式的IP地址
     * @param longIP  整型类型的ip
     * @return    返回：返回转换后的真正的ip地址
     */
    public static String longToIP(long longIP){
    	if(longIP > 4294967295l){
    		return "输入的整数太大，目前还没有这样的IP地址!";
    	}
         StringBuffer sb=new StringBuffer("");
         //直接右移24位
         sb.append(String.valueOf(longIP>>>24));
         sb.append(".");          
         //将高8位置0，然后右移16位
         sb.append(String.valueOf((longIP&0x00FFFFFF)>>>16)); 
         sb.append(".");
         sb.append(String.valueOf((longIP&0x0000FFFF)>>>8));
         sb.append(".");
         sb.append(String.valueOf(longIP&0x000000FF));
         return sb.toString(); 
    } 
    
	
}


一些正则表达常量 


//StringConstants.java

package com.myclover.utils.constant;

public class StringConstants {

	 public static final String MAIL_REGEXP = "\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
	 public static final String HOMEPHONE_REGEXP = "^(?:0[0-9]{2,3}[-\\s]{1}|\\(0[0-9]{2,4}\\))[0-9]{6,8}$|^[1-9]{1}[0-9]{5,7}$|^[1-9]{1}[0-9]{10}$";
	 
	 /**
	  * 
	  * 匹配图象 <br>
	  * 格式: /相对路径/文件名.后缀 (后缀为gif,dmp,png)
	  * 匹配 : /forum/head_icon/admini20100830_ff.gif 或 admini20100830.dmp<br>
	  * 不匹配: D:/admins0830.gif
	  */
	 public static final String ICON_REGEXP = "^(/{0,1}\\w){1,}\\.(gif|dmp|png|jpg)$|^\\w{1,}\\.(gif|dmp|png|jpg)$";
	
	 /**
	  * 
	  * 匹配email地址 <br>
	  * 格式: XXX@XXX.XXX.XX
	  * 匹配 : test@eye.com 或 test@iteye.com.cn <br>
	  * 不匹配: test@eye 或 $$$@bar.com
	  */
	 public static final String EMAIL_REGEXP = "(?:\\w[-._\\w]*\\w@\\w[-._\\w]*\\w\\.\\w{2,3}$)";
	
	 /**
	  * 
	  * 匹配匹配并提取url <br>
	  * 格式: XXXX://XXX.XXX.XXX.XX/XXX.XXX?XXX=XXX
	  * 匹配 : http://www.javaeyecom 或news://www<br>
	  * 提取(MatchResult matchResult=matcher.getMatch()):
	  * matchResult.group(0)= http://www.iteye.com:8080/index.html?login=true
	  * matchResult.group(1) = http
	  * matchResult.group(2) = www.iteye.com
	  * matchResult.group(3) = :8080
	  * matchResult.group(4) = /index.html?login=true
	  * 不匹配: c:\window
	  */
	 public static final String URL_REGEXP = "(\\w+)://([^/:]+)(:\\d*)?([^#\\s]*)";

	 /**
	  * 
	  * 匹配并提取http <br>
	  * 格式: http://XXX.XXX.XXX.XX/XXX.XXX?XXX=XXX 或 ftp://XXX.XXX.XXX 或 https://XXX
	  * 匹配 : http://www.iteye.com:8080/index.html?login=true<br>
	  * 提取(MatchResult matchResult=matcher.getMatch()):
	  * matchResult.group(0)= http://www.iteye.com:8080/index.html?login=true
	  * matchResult.group(1) = http
	  * matchResult.group(2) = www.iteye.com
	  * matchResult.group(3) = :8080
	  * matchResult.group(4) = /index.html?login=true
	  * 不匹配: news://www
	  */
	 public static final String HTTP_REGEXP = "(http|https|ftp)://([^/:]+)(:\\d*)?([^#\\s]*)";

	 /**
	  * 
	  * 匹配日期 <br>
	  * 格式(首位不为0): XXXX-XX-XX 或 XXXX XX XX 或 XXXX-X-X <br>
	  * 范围:1900--2099 <br>
	  * 匹配 : 2010-08-04 <br>
	  * 不匹配: 01-01-01
	  */
	 public static final String DATE_REGEXP = "^((((19){1}|(20){1})d{2})|d{2})[-\\s]{1}[01]{1}d{1}[-\\s]{1}[0-3]{1}d{1}$";// 匹配日期

	 /**
	  * 
	  * 匹配电话 <br>
	  * 格式为: 0XXX-XXXXXX(10-13位首位必须为0) 或0XXX XXXXXXX(10-13位首位必须为0) 或 <br>
	  * (0XXX)XXXXXXXX(11-14位首位必须为0) 或 XXXXXXXX(6-8位首位不为0) 或
	  * XXXXXXXXXXX(11位首位不为0) <br>
	  * 匹配 : 0371-123456 或 (0371)1234567 或 (028)12345678 或 010-123456 或
	  * 010-12345678 或 12345678912 <br>
	  * 不匹配: 1111-134355 或 0123456789
	  s*/
	 public static final String PHONE_REGEXP = "^(?:0[0-9]{2,3}[-\\s]{1}|\\(0[0-9]{2,4}\\))[0-9]{6,8}$|^[1-9]{1}[0-9]{5,7}$|^[1-9]{1}[0-9]{10}$";

	 /**
	  * 
	  * 匹配邮编代码 <br>
	  * 格式为: XXXXXX(6位) <br>
	  * 匹配 : 123456 <br>
	  * 不匹配: 012345
	  */
	 public static final String ZIP_REGEXP = "^[1-9]{6}$";

	 /**
	  * 不包括特殊字符的匹配 (字符串中不包括符号 数学次方号^ 单引号' 双引号" 分号; 逗号, 帽号: 数学减号- 右尖括号> 左尖括号< 反斜杠\ 即空格,制表符,回车符等 )<br>
	  * 格式为: x 或 一个一上的字符 <br>
	  * 匹配 : 012345 <br>
	  * 不匹配: 0123456
	  */
	 public static final String NON_SPECIAL_CHAR_REGEXP = "^[^'\"\\;,:-<>\\s].+$";// 匹配邮编代码

	 /**
	  * 匹配非负整数（正整数 + 0)
	  */
	 public static final String NON_NEGATIVE_INTEGERS_REGEXP = "^\\d+$";
	 
	 /**
	  * 匹配不包括零的非负整数（正整数 > 0)
	  */
	 public static final String NON_ZERO_NEGATIVE_INTEGERS_REGEXP = "^[1-9]+\\d*$";

	 /**
	  * 匹配正整数
	  */
	 public static final String POSITIVE_INTEGER_REGEXP = "^[0-9]*[1-9][0-9]*$";

	 /**
	  * 匹配非正整数（负整数 + 0）
	  */
	 public static final String NON_POSITIVE_INTEGERS_REGEXP = "^((-\\d+)|(0+))$";

	 /**
	  * 匹配负整数
	  */
	 public static final String NEGATIVE_INTEGERS_REGEXP = "^-[0-9]*[1-9][0-9]*$";

	 /**
	  * 匹配整数
	  */
	 public static final String INTEGER_REGEXP = "^-?\\d+$";

	 /**
	  * 匹配非负浮点数（正浮点数 + 0）
	  */
	 public static final String NON_NEGATIVE_RATIONAL_NUMBERS_REGEXP = "^\\d+(\\.\\d+)?$";

	 /**
	  * 匹配正浮点数
	  */
	 public static final String POSITIVE_RATIONAL_NUMBERS_REGEXP = "^(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*))$";

	 /**
	  * 匹配非正浮点数（负浮点数 + 0）
	  */
	 public static final String NON_POSITIVE_RATIONAL_NUMBERS_REGEXP = "^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$";

	 /**
	  * 匹配负浮点数
	  */
	 public static final String NEGATIVE_RATIONAL_NUMBERS_REGEXP = "^(-(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*)))$";

	 /**
	  * 匹配浮点数
	  */
	 public static final String RATIONAL_NUMBERS_REGEXP = "^(-?\\d+)(\\.\\d+)?$";

	 /**
	  * 匹配由26个英文字母组成的字符串
	  */
	 public static final String LETTER_REGEXP = "^[A-Za-z]+$";

	 /**
	  * 匹配由26个英文字母的大写组成的字符串
	  */
	 public static final String UPWARD_LETTER_REGEXP = "^[A-Z]+$";

	 /**
	  * 匹配由26个英文字母的小写组成的字符串
	  */
	 public static final String LOWER_LETTER_REGEXP = "^[a-z]+$";

	 /**
	  * 匹配由数字和26个英文字母组成的字符串
	  */
	 public static final String LETTER_NUMBER_REGEXP = "^[A-Za-z0-9]+$";

	 /**
	  * 匹配由数字、26个英文字母或者下划线组成的字符串
	  */
	 public static final String LETTER_NUMBER_UNDERLINE_REGEXP = "^\\w+$";
	 
	 /**
	  * 匹配中文
	  */
	 public static final String ZH_REGEXP = "^[\u0391-\uFFE5]+$";
	 
	 /**
	  * 匹配手机号码，以13、14、15、18开头的11位号码
	  */
	 public static final String  MOBILE_REGEXP = "(86)*0*1[3,4,5,8]\\d{9}";
	 
		
}
分享到：
| 一个简单的日期操作工具类
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    使用字符指针实现的一个简单string类

    在C++编程中，`string`类是一个非常重要的数据类型，用于存储和操作文本字符串。标准库中的`std::string`提供了丰富的功能，包括赋值、比较、拼接等。然而，有时候为了学习或者特定需求，我们需要自定义一个简单的`...

    C++文件操作工具类

    总之，“C++文件操作工具类”是一个为了提高开发效率和代码质量而创建的实用工具，它将底层的文件操作接口进行了封装，使得在C++项目中处理文件变得更加简单和高效。通过深入理解和运用此类工具，开发者可以更好地...

    一个简单工具类

    标题中的“一个简单工具类”通常指的是在编程中创建的一个通用功能集合的类，它包含了许多方便的方法，供其他类在需要时调用，以提高代码的复用性和可维护性。这种工具类通常不持有任何状态（即成员变量），只提供...

    简单的string类

    首先，`std::string`是C++标准库中的一个类模板，它表示可变长度的字符序列。在声明时，你可以通过构造函数初始化字符串，例如： ```cpp std::string str = "Hello, World!"; ``` 这将创建一个包含"Hello, World!...

    30个java工具类

    [工具类] 文件操作工具类 .java.txt [工具类] 序列化保存为XML文件的工具类 .java.txt [工具类] 一个压缩工具类.java.txt [工具类] 用java编写简单UDP网络通信程序 .java.txt [工具类] 中文验证.jsp.txt [工具类] ...

    jedis操作redis工具类，使用该工具类无需配置spring

    在Java项目中，为了简化开发和提高代码复用，通常会创建一个Redis操作的工具类。这个工具类封装了与Redis服务器通信的所有逻辑，开发者只需调用相应的方法即可完成数据的读写操作，无需关心连接管理、命令构建等底层...

    java，redis，jedis操作工具类，自己写的简易 demo

    创建一个Jedis操作工具类可以封装常用的操作方法，如设置键值对、获取键值对、删除键、集合操作等，使得代码更加简洁易用。例如： ```java public class RedisUtil { private static JedisPool jedisPool; /...

    【强2】30个java工具类

    [工具类] 文件操作工具类 .java.txt [工具类] 序列化保存为XML文件的工具类 .java.txt [工具类] 一个压缩工具类.java.txt [工具类] 用java编写简单UDP网络通信程序 .java.txt [工具类] 中文验证.jsp.txt [工具类] ...

    HttpClient接口调用工具类(附带demo)

    这个工具类可能封装了上述四个方法，为开发者提供便利的API，例如`post(String url, Map&lt;String, String&gt; params)`、`get(String url)`、`put(String url, Map&lt;String, String&gt; params)`和`delete(String url)`。...

    Rabbitmq工具类，java工具类RabbitmqUtil

    `RabbitmqUtil` 是一个专门为Java开发者设计的工具类，简化了与RabbitMQ交互的复杂过程，使得开发者能够更快速、更方便地发送和接收消息。 首先，我们来详细了解一下`RabbitmqUtil`工具类的主要功能： 1. **连接...

    C# ini文件操作工具类 亲测可用 超详细 带说明文档

    为了在C#中操作ini文件，我们可以创建一个工具类，如`LToolIni`，这个类可以封装各种ini文件操作方法。以下是一些核心方法的实现概览： 1. **读取ini文件**： - `GetAllSections()`：返回ini文件中的所有节。 - `...

    Android数据操作工具类

    "Android数据操作工具类" 提供了一种便捷的方式来进行数据的存储和读取，特别适合于简单的键值对存储需求。这个工具类是基于SharedPreferences（SP）存储机制实现的，SharedPreferences是Android系统提供的一种轻量...

    java字符串中${}或者{}等的占位符替换工具类

    Java字符串中${}或者{}等占位符替换工具类是一个功能强大且实用的工具类，它可以将Java字符串中的占位符依次替换为指定的值。该工具类的主要功能是实现占位符的替换，即将字符串中的${}或者{}等占位符依次替换为args...

    android工具类 26个实用工具类

    6. **文件操作工具类**：如`FileUtil`，提供文件的创建、删除、复制、移动、读写等操作，方便开发者处理本地文件。 7. **权限检查工具类**：在Android 6.0及以上版本，需要动态申请权限，`PermissionUtil`可以帮助...

    淘淘商城07-工具类

    除了上述的几个主要类别，这个压缩包可能还包含了其他实用工具类，如日期时间处理（DateUtil）、字符串操作（StringUtil）、文件操作（FileUtil）、线程池管理（ThreadPoolUtil）等。这些工具类通常提供了静态方法...

    图片操作工具类

    本篇文章将深入解析标题为"图片操作工具类"的相关知识点，主要围绕`PictureUtil.java`这个类来展开。 首先，我们关注的是图片的质量压缩。在Android应用中，图片加载过大可能会导致内存溢出（OOM）问题，因此需要对...

    一个简单的时间格式化工具类

    标题中的“一个简单的时间格式化工具类”指的是一个Java编程中的实用工具类，它主要用于处理日期和时间的格式化工作。在Java开发中，日期和时间的格式化是常见的需求，例如将日期从一种格式转换为另一种格式，或者将...

    java操作sftp的工具类(JSch)

    本文将详细介绍如何使用JSch进行SFTP操作，并提供一个简单的`SftpUtil`工具类示例。 首先，我们需要了解SFTP的基本概念。SFTP是一种在不安全的网络上安全传输文件的协议，它基于SSH（Secure Shell）协议，提供了...

    POI 操作Excel工具类

    以下是一个简单的示例，展示如何使用 POI 创建一个简单的 Excel 文件： ```java import org.apache.poi.ss.usermodel.*; import org.apache.poi.xssf.usermodel.XSSFWorkbook; import java.io.FileOutputStream; ...

    简单Dialog工具类

    "简单Dialog工具类"是对这种功能的封装，旨在简化开发过程，提高代码复用性，使得开发者能够快速地创建和展示对话框。下面我们将详细探讨Dialog的基本概念、封装工具类的优点以及如何实现和使用这样的工具类。 1. ...

Magicbox
Global site tag (gtag.js) - Google Analytics