Java笔记17：JAVA常用函数

2021-10-04 21:19:27

  1. **  

  2.  * 根据传入的格式获取日期  

  3.  *   

  4.  * @param format  

  5.  *            如:YYYYMMDD || MM/dd/yyyy, hh:mm:ss  

  6.  * @return 字符串的日期  

  7.  */  

  8. public String getSysDate(String format) {   

  9.     String dateStr = "";   

  10.     try {   

  11.         Format formatter;   

  12.         Date date = new Date();   

  13.         formatter = new SimpleDateFormat(format);   

  14.         dateStr = formatter.format(date);   

  15.     } catch (Exception e) {   

  16.         System.out.println(e);   

  17.     }   

  18.     return dateStr;   

  19. }   

  20. /**  

  21.  * 根据传入的格式获取日期  

  22.  *   

  23.  * @param format  

  24.  *            如:YYYYMMDD || MM/dd/yyyy, hh:mm:ss  

  25.  * @return 字符串的日期  

  26.  */  

  27. public String getFormatDate(Date date, String format) {   

  28.     String dateStr = "";   

  29.     try {   

  30.         Format formatter;   

  31.         formatter = new SimpleDateFormat(format);   

  32.         dateStr = formatter.format(date);   

  33.     } catch (Exception e) {   

  34.         System.out.println(e);   

  35.     }   

  36.     return dateStr;   

  37. }   

  38. /**  

  39.  * 获取分割后的字符串数组信息  

  40.  *   

  41.  * @param Str  

  42.  * @param Split  

  43.  * @return 字符串数组  

  44.  */  

  45. public String[] getSplit(String Str, String Split) {   

  46.     return Str.split(Split);   

  47. }   

  48. /**  

  49.  * 把字符串转换成指定的日期格式  

  50.  *   

  51.  * @param str  

  52.  * @param format  

  53.  * @return  

  54.  */  

  55. public Date Convert(String str, String format) {   

  56.     java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(format);   

  57.     try {   

  58.         java.util.Date d = sdf.parse(str);   

  59.         return d;   

  60.     } catch (Exception ex) {   

  61.         ex.printStackTrace();   

  62.         return null;   

  63.     }   

  64. }   

  65. /**  

  66.  * 获取月的天数  

  67.  *   

  68.  * @param year  

  69.  * @param month  

  70.  * @return  

  71.  */  

  72. public static int getdays(String year, String month) {   

  73.     int yearInt = Integer.parseInt(year);   

  74.     int monthInt = Integer.parseInt(month);   

  75.     int monthdays = 31;   

  76.     switch (monthInt) {   

  77.     case 1:   

  78.     case 3:   

  79.     case 5:   

  80.     case 7:   

  81.     case 8:   

  82.     case 10:   

  83.     case 12: {   

  84.         monthdays = 31;   

  85.         break;   

  86.     }   

  87.     case 2: {   

  88.         if (isLeapyear(yearInt)) {   

  89.             monthdays = 29;   

  90.         } else {   

  91.             monthdays = 28;   

  92.         }   

  93.         break;   

  94.     }   

  95.     case 4:   

  96.     case 6:   

  97.     case 9:   

  98.     case 11: {   

  99.         monthdays = 30;   

  100.         break;   

  101.     }   

  102.     }   

  103.     return monthdays;   

  104. }   

  105.   

  106. /**  

  107.  * 判断闰年  

  108.  *   

  109.  * @param year  

  110.  * @return  

  111.  */  

  112. public static boolean isLeapyear(int year) {   

  113.     if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {   

  114.         return true;   

  115.     } else {   

  116.         return false;   

  117.     }   

  118. }   

  119.   

  120. /**  

  121.  * 判断某天是星期几  

  122.  *   

  123.  * @param strDate  

  124.  * @return 0 表示是星期天  

  125.  */  

  126. public static int getWeekByDate(String strDate) {   

  127.     int dayOfWeek = 0;   

  128.     try {   

  129.   

  130.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");   

  131.         Calendar calendar = Calendar.getInstance();   

  132.         Date date = new Date();   

  133.         date = sdf.parse(strDate);   

  134.         calendar.setTime(date);   

  135.         dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);   

  136.     } catch (Exception e) {   

  137.         e.printStackTrace();   

  138.     }   

  139.     return dayOfWeek - 1;   

  140. }   

  141. /**  

  142.  * 判断字符串是不是数字  

  143.  *   

  144.  * @param str  

  145.  * @return  

  146.  */  

  147. public static boolean isNumeric(String str) {   

  148.     Pattern pattern = Pattern.compile("[0-9]*");   

  149.     Matcher isNum = pattern.matcher(str);   

  150.     if (!isNum.matches()) {   

  151.         return false;   

  152.     }   

  153.     return true;   

  154. }   

  155. /**  

  156.  * 获得距给定日期countday的字符串格式  

  157.  *   

  158.  * @param date  

  159.  * @param countday  

  160.  * @param flag  

  161.  *            为true表示日期前，为false表示日期后  

  162.  * @return YYYY-MM-DD  

  163.  */  

  164. public String getDateString(Date date, int countday, boolean flag) {   

  165.     String datestr = "";   

  166.     if (flag) {   

  167.         datestr = getFormatDate(new Date((new Date()).getTime() - countday   

  168.                 * 24 * 60 * 60 * 1000l), "yyyy-MM-dd");   

  169.     } else {   

  170.         datestr = getFormatDate(new Date((new Date()).getTime() + countday   

  171.                 * 24 * 60 * 60 * 1000l), "yyyy-MM-dd");   

  172.     }   

  173.     return datestr;   

  174. }   

  175. /***************************************************************************  

  176.  * 根据两个时间判断时间差  

  177.  * @throws ParseException   

  178.  * @throws ParseException   

  179.  **************************************************************************/  

  180. public Long getDateDifference(Date date1,Date date2) throws ParseException {   

  181. //      Date date1 = new SimpleDateFormat("yyyy-mm-dd").parse("2008-3-31");   

  182. //      Date date2 = new SimpleDateFormat("yyyy-mm-dd").parse("2008-3-30");   

  183.     // 日期相减得到相差的日期   

  184.     long day = (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000) > 0 ? (date1   

  185.             .getTime() - date2.getTime())   

  186.             / (24 * 60 * 60 * 1000)   

  187.             : (date2.getTime() - date1.getTime()) / (24 * 60 * 60 * 1000);   

  188.     return day;   

  189.   

  190. }   

  191. /***************************************************************************  

  192.  * 根据两个时间来判断时间的差值  

  193.  * @param days  

  194.  * @return  

  195.  */  

  196. public Long getDateDifference1(Date date1,Date date2) throws ParseException {   

  197.     // 日期相减得到相差的日期   

  198.     long day = (date1.getTime() - date2.getTime())/ (24 * 60 * 60 * 1000);   

  199.     return day;   

  200. }   

  201. /***************************************************************************  

  202.  * 返回当前时间的一个时间差时间  

  203.  * @param days  

  204.  * @return  

  205.  */  

  206. public static String Ds(int days) {   

  207.     SimpleDateFormat form = new SimpleDateFormat("yyyy-MM-dd");   

  208.     Calendar calendar = Calendar.getInstance();   

  209.     int day = calendar.get(Calendar.DAY_OF_YEAR);   

  210.     calendar.set(Calendar.DAY_OF_YEAR, day - days);   

  211.     Date cc = calendar.getTime();   

  212.     return form.format(cc);   

  213. }   

  214. /*************************************************************************  

  215.  * 获取系统当前时间  

  216.  */  

  217. public static Date getSystemDate(){   

  218.     SimpleDateFormat   sf   =   new   SimpleDateFormat("yyyy-MM-dd");      

  219.     Date   date   =   new   Date();                                                                    

  220.     try {   

  221.         return new SimpleDateFormat("yyyy-mm-dd").parse(sf.format(date));   

  222.     } catch (ParseException e) {   

  223.     }   

  224.     return null;   

  225. }   

  226.  /**  

  227.    * 判断是否为整数  

  228.    *   

  229.    * @param str 传入的字符串  

  230.    * @return 是整数返回true,否则返回false  

  231.    */  

  232.   public static boolean isInteger(String str) {   

  233.     Pattern pattern = Pattern.compile("^[-//+]?[//d]*$");   

  234.     return pattern.matcher(str).matches();   

  235.  }   

  236. /**  

  237.    * 判断是否为浮点数，包括double和float  

  238.    *   

  239.    * @param str 传入的字符串  

  240.    * @return 是浮点数返回true,否则返回false  

  241.    */  

  242.   public static boolean isDouble(String str) {   

  243.     Pattern pattern = Pattern.compile("^[-//+]?[.//d]*$");   

  244.     return pattern.matcher(str).matches();   

  245.   }   

  246. /**  

  247.    * 判断输入的字符串是否符合Email样式.  

  248.    *   

  249.    * @param str 传入的字符串  

  250.    * @return 是Email样式返回true,否则返回false  

  251.    */  

  252.   public static boolean isEmail(String str) {   

  253.     Pattern pattern = Pattern.compile("^//w+([-+.]//w+)*@//w+([-.]//w+)*//.//w+([-.]//w+)*$");   

  254.     return pattern.matcher(str).matches();   

  255.   }   

  256. /**  

  257.    * 判断输入的字符串是否为纯汉字  

  258.    *   

  259.    * @param str 传入的字符窜  

  260.    * @return 如果是纯汉字返回true,否则返回false  

  261.    */  

  262.   public static boolean isChinese(String str) {   

  263.     Pattern pattern = Pattern.compile("[/u0391-/uFFE5]+$");   

  264.     return pattern.matcher(str).matches();   

  265.   }   

  266.   

  267. /**  

  268.    * 是否为空白,包括null和""  

  269.    *   

  270.    * @param str  

  271.    * @return  

  272.    */  

  273.   public static boolean isBlank(String str) {   

  274.     return str == null || str.trim().length() == 0;   

  275.   }   

  276. /**  

  277.    * 判断是否为质数  

  278.    *   

  279.    * @param x  

  280.    * @return  

  281.    */  

  282.   public static boolean isPrime(int x) {   

  283.     if (x <= 7) {   

  284.       if (x == 2 || x == 3 || x == 5 || x == 7)   

  285.         return true;   

  286.     }   

  287.     int c = 7;   

  288.     if (x % 2 == 0)   

  289.       return false;   

  290.     if (x % 3 == 0)   

  291.       return false;   

  292.     if (x % 5 == 0)   

  293.       return false;   

  294.     int end = (int) Math.sqrt(x);   

  295.     while (c <= end) {   

  296.       if (x % c == 0) {   

  297.         return false;   

  298.       }   

  299.       c += 4;   

  300.       if (x % c == 0) {   

  301.         return false;   

  302.       }   

  303.       c += 2;   

  304.       if (x % c == 0) {   

  305.         return false;   

  306.       }   

  307.       c += 4;   

  308.       if (x % c == 0) {   

  309.         return false;   

  310.       }   

  311.       c += 2;   

  312.       if (x % c == 0) {   

  313.         return false;   

  314.       }   

  315.       c += 4;   

  316.       if (x % c == 0) {   

  317.         return false;   

  318.       }   

  319.       c += 6;   

  320.       if (x % c == 0) {   

  321.         return false;   

  322.       }   

  323.       c += 2;   

  324.       if (x % c == 0) {   

  325.         return false;   

  326.       }   

  327.       c += 6;   

  328.     }   

  329.     return true;   

  330.   }   

  331. /**  

  332.      * 人民币转成大写  

  333.      *   

  334.      * @param value  

  335.      * @return String  

  336.      */  

  337.     public static String hangeToBig(double value)   

  338.     {   

  339.         char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示   

  340.         char[] vunit = { '万', '亿' }; // 段名表示   

  341.         char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示   

  342.         long midVal = (long) (value * 100); // 转化成整形   

  343.         String valStr = String.valueOf(midVal); // 转化成字符串   

  344.   

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

  346.         String rail = valStr.substring(valStr.length() - 2); // 取小数部分   

  347.   

  348.         String prefix = ""; // 整数部分转化的结果   

  349.         String suffix = ""; // 小数部分转化的结果   

  350.         // 处理小数点后面的数   

  351.         if (rail.equals("00"))   

  352.         { // 如果小数部分为0   

  353.             suffix = "整";   

  354.         }   

  355.         else  

  356.         {   

  357.             suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来   

  358.         }   

  359.         // 处理小数点前面的数   

  360.         char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组   

  361.         char zero = '0'; // 标志'0'表示出现过0   

  362.         byte zeroSerNum = 0; // 连续出现0的次数   

  363.         for (int i = 0; i < chDig.length; i++)   

  364.         { // 循环处理每个数字   

  365.             int idx = (chDig.length - i - 1) % 4; // 取段内位置   

  366.             int vidx = (chDig.length - i - 1) / 4; // 取段位置   

  367.             if (chDig[i] == '0')   

  368.             { // 如果当前字符是0   

  369.                 zeroSerNum++; // 连续0次数递增   

  370.                 if (zero == '0')   

  371.                 { // 标志   

  372.                     zero = digit[0];   

  373.                 }   

  374.                 else if (idx == 0 && vidx > 0 && zeroSerNum < 4)   

  375.                 {   

  376.                     prefix += vunit[vidx - 1];   

  377.                     zero = '0';   

  378.                 }   

  379.                 continue;   

  380.             }   

  381.             zeroSerNum = 0; // 连续0次数清零   

  382.             if (zero != '0')   

  383.             { // 如果标志不为0,则加上,例如万,亿什么的   

  384.                 prefix += zero;   

  385.                 zero = '0';   

  386.             }   

  387.             prefix += digit[chDig[i] - '0']; // 转化该数字表示   

  388.             if (idx > 0)   

  389.                 prefix += hunit[idx - 1];   

  390.             if (idx == 0 && vidx > 0)   

  391.             {   

  392.                 prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿   

  393.             }   

  394.         }   

  395.   

  396.         if (prefix.length() > 0)   

  397.             prefix += '圆'; // 如果整数部分存在,则有圆的字样   

  398.         return prefix + suffix; // 返回正确表示   

  399.     }   

  400. /**  

  401.      * 全角字符转半角字符  

  402.      *   

  403.      * @param QJStr  

  404.      * @return String  

  405.      */  

  406.     public static final String QJToBJChange(String QJStr)   

  407.     {   

  408.         char[] chr = QJStr.toCharArray();   

  409.         String str = "";   

  410.         for (int i = 0; i < chr.length; i++)   

  411.         {   

  412.             chr[i] = (char) ((int) chr[i] - 65248);   

  413.             str += chr[i];   

  414.         }   

  415.         return str;   

  416.     }   

  417. /**  

  418.      * 去掉字符串中重复的子字符串  

  419.      *   

  420.      * @param str  

  421.      * @return String  

  422.      */  

  423.     private static String removeSameString(String str)   

  424.     {   

  425.         Set<String> mLinkedSet = new LinkedHashSet<String>();   

  426.         String[] strArray = str.split(" ");   

  427.         StringBuffer sb = new StringBuffer();   

  428.   

  429.         for (int i = 0; i < strArray.length; i++)   

  430.         {   

  431.             if (!mLinkedSet.contains(strArray[i]))   

  432.             {   

  433.                 mLinkedSet.add(strArray[i]);   

  434.                 sb.append(strArray[i] + " ");   

  435.             }   

  436.         }   

  437.         System.out.println(mLinkedSet);   

  438.         return sb.toString().substring(0, sb.toString().length() - 1);   

  439.     }   

  440. /**     

  441.      * 根据指定方法的参数去构造一个新的对象的拷贝并将他返回  

  442.      * @param obj 原始对象  

  443.      * @return 新对象  

  444.      * @throws NoSuchMethodException      

  445.      * @throws InvocationTargetException      

  446.      * @throws IllegalAccessException      

  447.      * @throws InstantiationException      

  448.      * @throws SecurityException      

  449.      * @throws IllegalArgumentException      

  450.      */  

  451.     @SuppressWarnings("unchecked")   

  452.     public static Object copy(Object obj) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException,   

  453.                     InvocationTargetException, NoSuchMethodException   

  454.     {   

  455.         //获得对象的类型       

  456.         Class classType = obj.getClass();   

  457.   

  458.         //通过默认构造方法去创建一个新的对象，getConstructor的视其参数决定调用哪个构造方法       

  459.         Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});   

  460.   

  461.         //获得对象的所有属性       

  462.         Field[] fields = classType.getDeclaredFields();   

  463.   

  464.         for(int i = 0; i < fields.length; i++)   

  465.         {   

  466.             //获取数组中对应的属性       

  467.             Field field = fields[i];   

  468.   

  469.             String fieldName = field.getName();   

  470.             String stringLetter = fieldName.substring(0, 1).toUpperCase();   

  471.   

  472.             //获得相应属性的getXXX和setXXX方法名称       

  473.             String getName = "get" + stringLetter + fieldName.substring(1);   

  474.             String setName = "set" + stringLetter + fieldName.substring(1);   

  475.   

  476.             //获取相应的方法       

  477.             Method getMethod = classType.getMethod(getName, new Class[]{});   

  478.             Method setMethod = classType.getMethod(setName, new Class[]{field.getType()});   

  479.   

  480.             //调用源对象的getXXX（）方法       

  481.             Object value = getMethod.invoke(obj, new Object[]{});   

  482.   

  483.             //调用拷贝对象的setXXX（）方法       

  484.             setMethod.invoke(objectCopy, new Object[]{value});   

  485.         }   

  486.   

  487.         return objectCopy;   

  488.     }   

  489.   

  490. //过滤特殊字符   

  491. public static String encoding(String src){   

  492.         if (src==null)   

  493.             return "";   

  494.         StringBuilder result=new StringBuilder();   

  495.         if (src!=null){   

  496.             src=src.trim();   

  497.             for (int pos=0;pos<src.length();pos++){   

  498.                 switch(src.charAt(pos)){   

  499.                     case '/"':result.append("&quot;");break;   

  500.                     case '<':result.append("&lt;");break;   

  501.                     case '>':result.append("&gt;");break;   

  502.                     case '/'':result.append("&apos;");break;   

  503.                     case '&':result.append("&amp;");break;   

  504.                     case '%':result.append("&pc;");break;   

  505.                     case '_':result.append("&ul;");break;   

  506.                     case '#':result.append("&shap;");break;   

  507.                     case '?':result.append("&ques;");break;   

  508.                     default:result.append(src.charAt(pos));break;   

  509.                 }   

  510.             }   

  511.         }   

  512.         return result.toString();   

  513.     }   

  514. //反过滤特殊字符   

  515.     public static String decoding(String src){   

  516.         if (src==null)   

  517.             return "";   

  518.         String result=src;   

  519.         result=result.replace("&quot;", "/"").replace("&apos;", "/'");   

  520.         result=result.replace("&lt;", "<").replace("&gt;", ">");   

  521.         result=result.replace("&amp;", "&");   

  522.         result=result.replace("&pc;", "%").replace("&ul", "_");   

  523.         result=result.replace("&shap;", "#").replace("&ques", "?");   

  524.         return result;   

  525.     }   

  526. // toUtf8String将文件名转成GBK后再附到ContentDisposition   

  527. public static String toUtf8String(String s) {   

  528.     StringBuffer sb = new StringBuffer();   

  529.     for (int i = 0; i < s.length(); i++) {   

  530.         char c = s.charAt(i);   

  531.         if (c >= 0 && c <= 255) {   

  532.             sb.append(c);   

  533.         } else {   

  534.             byte[] b;   

  535.             try {   

  536.                 b = Character.toString(c).getBytes("utf-8");   

  537.             } catch (Exception ex) {   

  538.                 System.out.println(ex);   

  539.                 b = new byte[0];   

  540.             }   

  541.             for (int j = 0; j < b.length; j++) {   

  542.                 int k = b[j];   

  543.                 if (k < 0)   

  544.                     k += 256;   

  545.                 sb.append("%" + Integer.toHexString(k).toUpperCase());   

  546.             }   

  547.         }   

  548.     }   

  549.     return sb.toString();   

  550. }   

  551. /**  

  552.      * 对字节流进行GBK解码  

  553.      *   

  554.      * @param byteBuffer  

  555.      * @return  

  556.      */  

  557.     public static String decode(ByteBuffer byteBuffer) {   

  558.         Charset charset = Charset.forName("ISO-8859-1");   

  559.         CharsetDecoder decoder = charset.newDecoder();   

  560.         try {   

  561.             CharBuffer charBuffer = decoder.decode(byteBuffer);   

  562.             return new String(charBuffer.toString().getBytes("ISO8859_1"),   

  563.                     "GBK").trim();   

  564.         } catch (Exception e) {   

  565.             return null;   

  566.         }   

  567.     }   

  568. //实现百分比   

  569. public String myPercent(int y, int z) {   

  570.         String baifenbi = "";// 接受百分比的值   

  571.         double baiy = y * 1.0;   

  572.         double baiz = z * 1.0;   

  573.         double fen = baiy / baiz;   

  574.         // NumberFormat nf = NumberFormat.getPercentInstance(); 注释掉的也是一种方法   

  575.         // nf.setMinimumFractionDigits( 2 ); 保留到小数点后几位   

  576.         DecimalFormat df1 = new DecimalFormat("##.00%"); // ##.00%   

  577.                                                             // 百分比格式，后面不足2位的用0补齐   

  578.         // baifenbi=nf.format(fen);   

  579.         baifenbi = df1.format(fen);   

  580.         return baifenbi;   

  581.     }   

  582. 正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。    

  583.   

  584. 匹配中文字符的正则表达式： [/u4e00-/u9fa5]    

  585. 评注：匹配中文还真是个头疼的事，有了这个表达式就好办了    

  586.   

  587. 匹配双字节字符(包括汉字在内)：[^/x00-/xff]    

  588. 评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）    

  589.   

  590. 匹配空白行的正则表达式：/n/s*/r    

  591. 评注：可以用来删除空白行    

  592.   

  593. 匹配HTML标记的正则表达式： <(/S*?)[^>]*>.*? <//1>  <.*? />    

  594. 评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力    

  595.   

  596. 匹配首尾空白字符的正则表达式：^/s* /s*$    

  597. 评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式    

  598.   

  599. 匹配Email地址的正则表达式：/w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*    

  600. 评注：表单验证时很实用    

  601.   

  602. 匹配网址URL的正则表达式：[a-zA-z]+://[^/s]*    

  603. 评注：网上流传的版本功能很有限，上面这个基本可以满足需求    

  604.   

  605. 匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$    

  606. 评注：表单验证时很实用    

  607.   

  608. 匹配国内电话号码：/d{3}-/d{8} /d{4}-/d{7}    

  609. 评注：匹配形式如 0511-4405222 或 021-87888822    

  610.   

  611. 匹配腾讯QQ号：[1-9][0-9]{4,}    

  612. 评注：腾讯QQ号从10000开始    

  613.   

  614. 匹配中国邮政编码：[1-9]/d{5}(?!/d)    

  615. 评注：中国邮政编码为6位数字    

  616.   

  617. 匹配***：/d{15} /d{18}    

  618. 评注：中国的***为15位或18位    

  619.   

  620. 匹配ip地址：/d+/./d+/./d+/./d+    

  621. 评注：提取ip地址时有用    

  622.   

  623. 匹配特定数字：    

  624. ^[1-9]/d*$　 　 //匹配正整数    

  625. ^-[1-9]/d*$ 　 //匹配负整数    

  626. ^-?[1-9]/d*$　　 //匹配整数    

  627. ^[1-9]/d* 0$　 //匹配非负整数（正整数 + 0）    

  628. ^-[1-9]/d* 0$　　 //匹配非正整数（负整数 + 0）    

  629. ^[1-9]/d*/./d* 0/./d*[1-9]/d*$　　 //匹配正浮点数    

  630. ^-([1-9]/d*/./d* 0/./d*[1-9]/d*)$　 //匹配负浮点数    

  631. ^-?([1-9]/d*/./d* 0/./d*[1-9]/d* 0?/.0+ 0)$　 //匹配浮点数    

  632. ^[1-9]/d*/./d* 0/./d*[1-9]/d* 0?/.0+ 0$　　 //匹配非负浮点数（正浮点数 + 0）    

  633. ^(-([1-9]/d*/./d* 0/./d*[1-9]/d*)) 0?/.0+ 0$　　//匹配非正浮点数（负浮点数 + 0）    

  634. 评注：处理大量数据时有用，具体应用时注意修正    

  635.   

  636. 匹配特定字符串：    

  637. ^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串    

  638. ^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串    

  639. ^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串    

  640. ^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串    

  641. ^/w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串    

  642. 评注：最基本也是最常用的一些表达式    

  643.   

  644. String.split()方法中，有时需要特殊字符，见下：   

  645. /**  

  646. * 点的转义：.  ==> //u002E  

  647.  美元符号的转义：$  ==> //u0024  

  648.  乘方符号的转义：^  ==> //u005E  

  649.  左大括号的转义：{  ==> //u007B  

  650.  左方括号的转义：[  ==> //u005B  

  651.  左圆括号的转义：(  ==> //u0028  

  652.  竖线的转义：| ==> //u007C  

  653.  右圆括号的转义：) ==> //u0029  

  654.  星号的转义：*  ==> //u002A  

  655.  加号的转义：+  ==> //u002B  

  656.  问号的转义：?  ==> //u003F  

  657.  反斜杠的转义：/ ==> //u005C  

  658.  竖线:    | ==>//u007C  

  659. * */  




本文转自 风雨萧条 51CTO博客，原文链接：http://blog.51cto.com/1095221645/1562755，如需转载请自行联系原作者
上一篇：【对讲机的那点事】使用对讲机，你了解对讲机电池使用寿命及安全吗？


下一篇：TextView低级错误,细节细节