通过Java正则表达式去掉SQL代码中回车换行和多余空格

　　public static void main(String[] args) {

　　String sql = "SELECT * FROM \n" +

　　" `testdb`.`foo` LIMIT 0, 100";

　　String s = "SELECT * FROM `testdb`.`foo` LIMIT 0, 100";

　　String sql2 = Pattern.compile(" {2,}").matcher(s).replaceAll(" ");

　　String sql3 = s.replaceAll(" {2,}"," ");

　　String sql4 = sql.replace('\r', ' ').replace('\n', ' ').replaceAll(" {2,}"," ");;

　　String sql5 = sql.replace('\r', ' ').replace('\n', ' ').replaceAll(" {2,}?"," ");;

　　String sql6 = sql.replace('\r', ' ').replace('\n', ' ').replaceAll(" {2,}+"," ");;

　　System.out.println(sql2);

　　System.out.println(sql3);

　　System.out.println(sql4);

　　System.out.println(sql5);

　　System.out.println(sql6);

　　}

　　SELECT * FROM `testdb`.`foo` LIMIT 0, 100

　　SELECT * FROM `testdb`.`foo` LIMIT 0, 100

　　SELECT * FROM `testdb`.`foo` LIMIT 0, 100

　　SELECT * FROM `testdb`.`foo` LIMIT 0, 100

　　SELECT * FROM `testdb`.`foo` LIMIT 0, 100

　　[code]

　　Process finished with exit code 0

　　结果可以看出，有一个是没有去掉多余空格的。

　　可见java中的正则式，同样含义的还有多重写法，呵呵！其实主要是不同数量词匹配模式在作怪：

　　原版API文档中写道：

　　Greedy 数量词

　　X? X，一次或一次也没有

　　X* X，零次或多次

　　X+ X，一次或多次

　　X{n} X，恰好 n 次

　　X{n,} X，至少 n 次

　　X{n,m} X，至少 n 次，但是不超过 m 次

　　Reluctant 数量词

　　X?? X，一次或一次也没有

　　X*? X，零次或多次

　　X+? X，一次或多次

　　X{n}? X，恰好 n 次

　　X{n,}? X，至少 n 次

　　X{n,m}? X，至少 n 次，但是不超过 m 次

　　Possessive 数量词

　　X?+ X，一次或一次也没有

　　X*+ X，零次或多次

　　X++ X，一次或多次

　　X{n}+ X，恰好 n 次

　　X{n,}+ X，至少 n 次

　　X{n,m}+ X，至少 n 次，但是不超过 m 次

　　但是，没有对三种方式进行更详细的说明，其实三种模式的区别如下：

　　Greedy ：尝试找到最长的匹配。

　　Reluctant ：尝试找到最短的匹配。

　　Possessive ：也尝试找到最长的匹配。

　　尽管greedy和possessive迫使一个matcher在进行第一次匹配之前读取整个的text，greedy常常导致为了找到一个match进行多次尝试，然而possessive让一个matcher仅尝试一个match一次。

　　下面是一个我工具中的方法：

　　[code]

　　/**

　　* 判断一条SQL语句是否已经是分页的SQL

　　*

　　* @param sql 源SQL

　　* @return 是已经分页的SQL时返回ture，否则返回False；

　　*/

　　public boolean isAlreadySegmentSQL(String sql) {

　　return sql.replace('\r', ' ').replace('\n', ' ').replaceAll(" {2,}", " ").matches("(?i).+LIMIT [\\d+ *|\\d *, *\\d+].+");

　　}

　　// regList.put("(?i)bit\\([2-9]\\)\\z", "byte[]");

　　// regList.put("(?i)bit\\(\\d{2,}\\)\\z", "byte[]");

　　regList.put("(?i)bit\\((\\d{2,}|[2-9])\\)\\z", "byte[]");